paper_name
stringlengths 11
170
| text
stringlengths 8.07k
307k
| summary
stringlengths 152
6.16k
| paper_id
stringlengths 43
43
|
|---|---|---|---|
For interpolating kernel machines, minimizing the norm of the ERM solution minimizes stability | 1 INTRODUCTION . Statistical learning theory studies the learning properties of machine learning algorithms , and more fundamentally , the conditions under which learning from finite data is possible . In this context , classical learning theory focuses on the size of the hypothesis space in terms of different complexity measures , such as combinatorial dimensions , covering numbers and Rademacher/Gaussian complexities ( Shalev-Shwartz & Ben-David , 2014 ; Boucheron et al. , 2005 ) . Another more recent approach is based on defining suitable notions of stability with respect to perturbation of the data ( Bousquet & Elisseeff , 2001 ; Kutin & Niyogi , 2002 ) . In this view , the continuity of the process that maps data to estimators is crucial , rather than the complexity of the hypothesis space . Different notions of stability can be considered , depending on the data perturbation and metric considered ( Kutin & Niyogi , 2002 ) . Interestingly , the stability and complexity approaches to characterizing the learnability of problems are not at odds with each other , and can be shown to be equivalent as shown in Poggio et al . ( 2004 ) and Shalev-Shwartz et al . ( 2010 ) . In modern machine learning overparameterized models , with a larger number of parameters than the size of the training data , have become common . The ability of these models to generalize is well explained by classical statistical learning theory as long as some form of regularization is used in the training process ( Bühlmann & Van De Geer , 2011 ; Steinwart & Christmann , 2008 ) . However , it was recently shown - first for deep networks ( Zhang et al. , 2017 ) , and more recently for kernel methods ( Belkin et al. , 2019 ) - that learning is possible in the absence of regularization , i.e. , when perfectly fitting/interpolating the data . Much recent work in statistical learning theory has tried to find theoretical ground for this empirical finding . Since learning using models that interpolate is not exclusive to deep neural networks , we study generalization in the presence of interpolation in the case of kernel methods . We study both linear and kernel least squares problems in this paper . Our Contributions : • We characterize the generalization properties of interpolating solutions for linear and kernel least squares problems using a stability approach . While the ( uniform ) stability properties of regularized kernel methods are well known ( Bousquet & Elisseeff , 2001 ) , we study interpolating solutions of the unregularized ( `` ridgeless '' ) regression problems . • We obtain an upper bound on the stability of interpolating solutions , and show that this upper bound is minimized by the minimum norm interpolating solution . This also means that among all interpolating solutions , the minimum norm solution has the best test error . In particular , the same conclusion is also true for gradient descent , since it converges to the minimum norm solution in the setting we consider , see e.g . Rosasco & Villa ( 2015 ) . • Our stability bounds show that the average stability of the minimum norm solution is controlled by the condition number of the empirical kernel matrix . It is well known that the numerical stability of the least squares solution is governed by the condition number of the associated kernel matrix ( see the discussion of why overparametrization is “ good ” in Poggio et al . ( 2019 ) ) . Our results show that the condition number also controls stability ( and hence , test error ) in a statistical sense . Organization : In section 2 , we introduce basic ideas in statistical learning and empirical risk minimization , as well as the notation used in the rest of the paper . In section 3 , we briefly recall some definitions of stability . In section 4 , we study the stability of interpolating solutions to kernel least squares and show that the minimum norm solutions minimize an upper bound on the stability . In section 5 we discuss our results in the context of recent work on high dimensional regression . We conclude in section 6 . 2 STATISTICAL LEARNING AND EMPIRICAL RISK MINIMIZATION . We begin by recalling the basic ideas in statistical learning theory . In this setting , X is the space of features , Y is the space of targets or labels , and there is an unknown probability distribution µ on the product space Z = X × Y . In the following , we consider X = Rd and Y = R. The distribution µ is fixed but unknown , and we are given a training set S consisting of n samples ( thus |S| = n ) drawn i.i.d . from the probability distribution on Zn , S = ( zi ) ni=1 = ( xi , yi ) n i=1 . Intuitively , the goal of supervised learning is to use the training set S to “ learn ” a function fS that evaluated at a new value xnew should predict the associated value of ynew , i.e . ynew ≈ fS ( xnew ) . The loss is a function V : F × Z → [ 0 , ∞ ) , where F is the space of measurable functions from X to Y , that measures how well a function performs on a data point . We define a hypothesis space H ⊆ F where algorithms search for solutions . With the above notation , the expected risk of f is defined as I [ f ] = EzV ( f , z ) which is the expected loss on a new sample drawn according to the data distribution µ . In this setting , statistical learning can be seen as the problem of finding an approximate minimizer of the expected risk given a training set S. A classical approach to derive an approximate solution is empirical risk minimization ( ERM ) where we minimize the empirical risk IS [ f ] = 1 n ∑n i=1 V ( f , zi ) . A natural error measure for our ERM solution fS is the expected excess risk ES [ I [ fS ] −minf∈H I [ f ] ] . Another common error measure is the expected generalization error/gap given by ES [ I [ fS ] − IS [ fS ] ] . These two error measures are closely related since , the expected excess risk is easily bounded by the expected generalization error ( see Lemma 5 ) . 2.1 KERNEL LEAST SQUARES AND MINIMUM NORM SOLUTION . The focus in this paper is on the kernel least squares problem . We assume the loss function V is the square loss , that is , V ( f , z ) = ( y − f ( x ) ) 2 . The hypothesis space is assumed to be a reproducing kernel Hilbert space , defined by a positive definite kernel K : X ×X → R or an associated feature map Φ : X → H , such that K ( x , x′ ) = 〈Φ ( x ) , Φ ( x′ ) 〉H for all x , x′ ∈ X , where 〈· , ·〉H is the inner product in H. In this setting , functions are linearly parameterized , that is there exists w ∈ H such that f ( x ) = 〈w , Φ ( x ) 〉H for all x ∈ X . The ERM problem typically has multiple solutions , one of which is the minimum norm solution : f†S = arg min f∈M ‖f‖H , M = arg min f∈H 1 n n∑ i=1 ( f ( xi ) − yi ) 2 . ( 1 ) Here ‖·‖H is the norm onH induced by the inner product . The minimum norm solution can be shown to be unique and satisfy a representer theorem , that is for all x ∈ X : f†S ( x ) = n∑ i=1 K ( x , xi ) cS [ i ] , cS = K †y ( 2 ) where cS = ( cS [ 1 ] , . . . , cS [ n ] ) , y = ( y1 . . . yn ) ∈ Rn , K is the n by n matrix with entries Kij = K ( xi , xj ) , i , j = 1 , . . . , n , and K† is the Moore-Penrose pseudoinverse of K. If we assume n ≤ d and that we have n linearly independent data features , that is the rank of X is n , then it is possible to show that for many kernels one can replace K† by K−1 ( see Remark 2 ) . Note that invertibility is necessary and sufficient for interpolation . That is , if K is invertible , f†S ( xi ) = yi for all i = 1 , . . . , n , in which case the training error in ( 1 ) is zero . Remark 1 ( Pseudoinverse for underdetermined linear systems ) A simple yet relevant example are linear functions f ( x ) = w > x , that correspond toH = Rd and Φ the identity map . If the rank of X ∈ Rd×n is n , then any interpolating solution wS satisfies w > S xi = yi for all i = 1 , . . . , n , and the minimum norm solution , also called Moore-Penrose solution , is given by ( w†S ) > = y > X† where the pseudoinverse X† takes the form X† = X > ( XX > ) −1 . Remark 2 ( Invertibility of translation invariant kernels ) Translation invariant kernels are a family of kernel functions given by K ( x1 , x2 ) = k ( x1 − x2 ) where k is an even function on Rd . Translation invariant kernels are Mercer kernels ( positive semidefinite ) if the Fourier transform of k ( · ) is non-negative . For Radial Basis Function kernels ( K ( x1 , x2 ) = k ( ||x1 − x2|| ) ) we have the additional property due to Theorem 2.3 of Micchelli ( 1986 ) that for distinct points x1 , x2 , . . . , xn ∈ Rd the kernel matrix K is non-singular and thus invertible . The above discussion is directly related to regularization approaches . Remark 3 ( Stability and Tikhonov regularization ) Tikhonov regularization is used to prevent potential unstable behaviors . In the above setting , it corresponds to replacing Problem ( 1 ) by minf∈H 1 n ∑n i=1 ( f ( xi ) − yi ) 2 + λ ‖f‖ 2 H where the corresponding unique solution is given by fλS ( x ) = ∑n i=1K ( x , xi ) c [ i ] , c = ( K + λIn ) −1y . In contrast to ERM solutions , the above approach prevents interpolation . The properties of the corresponding estimator are well known . In this paper , we complement these results focusing on the case λ→ 0 . Finally , we end by recalling the connection between minimum norm and the gradient descent . Remark 4 ( Minimum norm and gradient descent ) In our setting , it is well known that both batch and stochastic gradient iterations converge exactly to the minimum norm solution when multiple solutions exist , see e.g . Rosasco & Villa ( 2015 ) . Thus , a study of the properties of the minimum norm solution explains the properties of the solution to which gradient descent converges . In particular , when ERM has multiple interpolating solutions , gradient descent converges to a solution that minimizes a bound on stability , as we show in this paper . | This paper investigates kernel ridge-less regression from a stability viewpoint by deriving its risk bounds. Using stability arguments to derive risk bounds have been widely adopting in machine learning. However, related studies on kernel ridge-less regression are still sparse. The present study fills this gap, which, in my opinion, is also one of the main contributions of the present study. | SP:4d08cdb2de2044bcb574a425b42963b83fbebfbc |
Discriminative Representation Loss (DRL): A More Efficient Approach than Gradient Re-Projection in Continual Learning | 1 INTRODUCTION . In the real world , we are often faced with situations where data distributions are changing over time , and we would like to update our models by new data in time , with bounded growth in system size . These situations fall under the umbrella of “ continual learning ” , which has many practical applications , such as recommender systems , retail supply chain optimization , and robotics ( Lesort et al. , 2019 ; Diethe et al. , 2018 ; Tian et al. , 2018 ) . Comparisons have also been made with the way that humans are able to learn new tasks without forgetting previously learned ones , using common knowledge shared across different skills . The fundamental problem in continual learning is catastrophic forgetting ( McCloskey & Cohen , 1989 ; Kirkpatrick et al. , 2017 ) , i.e . ( neural network ) models have a tendency to forget previously learned tasks while learning new ones . There are three main categories of methods for alleviating forgetting in continual learning : i ) regularization-based methods which aim in preserving knowledge of models of previous tasks ( Kirkpatrick et al. , 2017 ; Zenke et al. , 2017 ; Nguyen et al. , 2018 ) ii ) architecture-based methods for incrementally evolving the model by learning task-shared and task-specific components ( Schwarz et al. , 2018 ; Hung et al. , 2019 ) ; iii ) replay-based methods which focus in preserving knowledge of data distributions of previous tasks , including methods of experience replay by episodic memories or generative models ( Shin et al. , 2017 ; Rolnick et al. , 2019 ) , methods for generating compact episodic memories ( Chen et al. , 2018 ; Aljundi et al. , 2019 ) , and methods for more efficiently using episodic memories ( Lopez-Paz & Ranzato , 2017 ; Chaudhry et al. , 2019a ; Riemer et al. , 2019 ; Farajtabar et al. , 2020 ) . Gradient-based approaches using episodic memories , in particular , have been receiving increasing attention . The essential idea is to use gradients produced by samples from episodic memories to constrain the gradients produced by new samples , e.g . by ensuring the inner product of the pair of gradients is non-negative ( Lopez-Paz & Ranzato , 2017 ) as follows : 〈gt , gk〉 = 〈 ∂L ( xt , θ ) ∂θ , ∂L ( xk , θ ) ∂θ 〉 ≥ 0 , ∀k < t ( 1 ) where t and k are time indices , xt denotes a new sample from the current task , and xk denotes a sample from the episodic memory . Thus , the updates of parameters are forced to preserve the performance on previous tasks as much as possible . In Gradient Episodic Memory ( GEM ) ( Lopez-Paz & Ranzato , 2017 ) , gt is projected to a direction that is closest to it in L2-norm whilst also satisfying Eq . ( 1 ) : ming̃ 12 ||gt − g̃|| 2 2 , s.t.〈g̃ , gk〉 ≥ 0 , ∀k < t. Optimization of this objective requires a high-dimensional quadratic program and thus is computationally expensive . Averaged-GEM ( A-GEM ) ( Chaudhry et al. , 2019a ) alleviates the computational burden of GEM by using the averaged gradient over a batch of samples instead of individual gradients of samples in the episodic memory . This not only simplifies the computation , but also obtains comparable performance with GEM . Orthogonal Gradient Descent ( OGD ) ( Farajtabar et al. , 2020 ) projects gt to the direction that is perpendicular to the surface formed by { gk|k < t } . Moreover , Aljundi et al . ( 2019 ) propose Gradient-based Sample Selection ( GSS ) , which selects samples that produce most diverse gradients with other samples into episodic memories . Here diversity is measured by the cosine similarity between gradients . Since the cosine similarity is computed using the inner product of two normalized gradients , GSS embodies the same principle as other gradient-based approaches with episodic memories . Although GSS suggests the samples with most diverse gradients are important for generalization across tasks , Chaudhry et al . ( 2019b ) show that the average gradient over a small set of random samples may be able to obtain good generalization as well . In this paper , we answer the following questions : i ) Which samples tend to produce diverse gradients that strongly conflict with other samples and why are such samples able to help with generalization ? ii ) Why does a small set of randomly chosen samples also help with generalization ? iii ) Can we reduce the diversity of gradients in a more efficient way ? Our answers reveal the relation between diversity of gradients and discriminativeness of representations , and further show connections between Deep Metric Learning ( DML ) ( Kaya & Bilge , 2019 ; Roth et al. , 2020 ) and continual learning . Drawing on these findings we propose a new approach , Discriminative Representation Loss ( DRL ) , for classification tasks in continual learning . Our methods show improved performance with relatively low computational cost in terms of time and RAM cost when compared to several state-of-theart ( SOTA ) methods across multiple benchmark tasks in the setting of online continual learning . 2 A NEW PERSPECTIVE OF REDUCING DIVERSITY OF GRADIENTS . According to Eq . ( 1 ) , negative cosine similarities between gradients produced by current and previous tasks result in worse performance in continual learning . This can be interpreted from the perspective of constrained optimization as discussed by Aljundi et al . ( 2019 ) . Moreover , the diversity of gradients relates to the Gradient Signal to Noise Ratio ( GSNR ) ( Liu et al. , 2020 ) , which plays a crucial role in the model ’ s generalization ability . Intuitively , when more of the gradients point in diverse directions , the variance will be larger , leading to a smaller GSNR , which indicates that reducing the diversity of gradients can improve generalization . This finding leads to the conclusion that samples with the most diverse gradients contain the most critical information for generalization which is consistent with in Aljundi et al . ( 2019 ) . 2.1 THE SOURCE OF GRADIENT DIVERSITY . We first conducted a simple experiment on classification tasks of 2-D Gaussian distributions , and tried to identify samples with most diverse gradients in the 2-D feature space . We trained a linear model on the first task to discriminate between two classes ( blue and orange dots in Fig . 1a ) . We then applied the algorithm Gradient-based Sample Selection with Interger Quadratic Programming ( GSS-IQP ) ( Aljundi et al. , 2019 ) to select 10 % of the samples of training data that produce gradients with the lowest similarity ( black dots in Fig . 1a ) , and denote this set of samples as M̂ = minM ∑ i , j∈M 〈gi , gj〉 ||gi||·||gj || . It is clear from Fig . 1a that the samples in M̂ are mostly around the decision boundary between the two classes . Increasing the size of M̂ results in the inclusion of samples that trace the outer edges of the data distributions from each class . Clearly the gradients can be strongly opposed when samples from different classes are very similar . Samples close to decision boundaries are most likely to exhibit this characteristic . Intuitively , storing the decision boundaries of previously learned classes should be an effective way to preserve classification performance on those classes . However , if the episodic memory only includes samples representing the learned boundaries , it may miss important information when the model is required to incrementally learn new classes . We show this by introducing a second task - training the model above on a third class ( green dots ) . We display the decision boundaries ( which split the feature space in a one vs. all manner ) learned by the model after 4 2 0 2 4 6 x 4 2 0 2 4 6 8 y class 0 class 1 M ( a ) Samples with most diverse gradients ( M̂ ) after learning task 1 , the green line is the decision boundary . 4 2 0 2 4 6 x 4 2 0 2 4 6 8 y class 0 class 1 class 2 memory ( b ) Learned decision boundaries ( purple lines ) after task 2 . Here the episodic memory includes samples in M̂ . 4 2 0 2 4 6 x 4 2 0 2 4 6 8 y class 0 class 1 class 2 memory ( c ) Learned decision boundaries ( purple lines ) after task 2 . Here the episodic memory consists of random samples . ( a ) Splitting samples into several subsets in a 3-class classification task . Dots in different colors are from different classes . ( b ) Estimated distributions of β when drawing negative pairs from different subsets of samples . ( c ) Estimated distributions of α− δ when drawing negative pairs from different subsets of samples . Figure 2 : Illustration of how Pr ( 2β > α − δ ) in Theorem 1 behaves in various cases by drawing negative pairs from different subsets of a 3-class feature space which are defined in Fig . 2a . The classifier is a linear model . y-axis in the right side of ( b ) & ( c ) is for the case of x ∈ S1 ∪ S2 . We see that α− δ behaves in a similar way with β but in a smaller range which makes β the key in studying Pr ( 2β > α − δ ) . In the case of x ∈ S3 the distribution of β has more mass on larger values than other cases because the predicted probabilities are mostly on the two classes in a pair , and it causes all 〈gn , gm〉 having the opposite sign of 〈xn , xm〉 as shown in Tab . 1. task 2 with M̂ ( Fig . 1b ) and a random set of samples ( Fig . 1c ) from task 1 as the episodic memory . The random episodic memory shows better performance than the one selected by GSS-IQP , since the new decision boundaries rely on samples not included in M̂ . It explains why randomly selected memories may generalize better in continual learning . Ideally , with M̂ large enough , the model can remember all edges of each class , and hence learn much more accurate decision boundaries sequentially . However , memory size is often limited in practice , especially for high-dimensional data . A more efficient way could be learning more informative representations . The experimental results indicate that : 1 ) more similar representations in different classes result in more diverse gradients . 2 ) more diverse representations in a same class help with learning new boundaries incrementally . Now we formalise the connection between the diversity of gradients and the discriminativeness of representations for the linear model ( proofs are in Appx . A ) . Notations : Negative pair represents two samples from different classes . Positive pair represents two samples from a same class . Let L represent the softmax cross entropy loss , W ∈ RD×K is the weight matrix of the linear model , and xn ∈ RD denotes the input data , yn ∈ RK is a one-hot vector that denotes the label of xn , D is the dimension of representations , K is the number of classes . Let pn = softmax ( on ) , where on = W Txn , the gradient gn = ∇WL ( xn , yn ; W ) . xn , xm are two different samples when n 6= m. Lemma 1 . Let n = pn − yn , we have : 〈gn , gm〉 = 〈xn , xm〉〈 n , m〉 , Theorem 1 . Suppose yn 6= ym , and let cn denote the class index of xn ( i.e . yn , cn = 1 , yn , i = 0 , ∀i 6= cn ) . Let α , ||pn||2 + ||pm||2 , β , pn , cm + pm , cn and δ , ||pn − pm||22 , then : Pr ( sign ( 〈gn , gm〉 ) = sign ( −〈xn , xm〉 ) ) = Pr ( 2β > α− δ ) , Theorem 2 . Suppose yn = ym , when 〈gn , gm〉 6= 0 , we have : sign ( 〈gn , gm〉 ) = sign ( 〈xn , xm〉 ) For a better understanding of the theorems , we conduct empirical study by partitioning the feature space of three classes into several subsets as shown in Fig . 2a and examine four cases of pairwise samples by these subsets : 1 ) . x ∈ S0 , both samples in a pair are near the intersection of the three classes ; 2 ) . x ∈ S0∪S1 , one sample is close to decision boundaries and the other is far away from the boundaries ; 3 ) . x ∈ S3 , both samples close to the decision boundary between their true classes but away from the third class ; 4 ) . x ∈ S1 ∪ S2 , both samples are far away from the decision boundaries . Theorem 1 says that for samples from different classes , 〈gn , gm〉 gets an opposite sign of 〈xn , xm〉 with a probability that depends on the predictions pn and pm . This probability of flipping the sign especially depends on β which reflects how likely to misclassify both samples to its opposite class . We show the empirical distributions of β and ( α− δ ) obtained by a linear model in Figs . 2b and 2c , respectively . In general , ( α− δ ) shows similar behaviors with β in the four cases but in a smaller range , which makes 2β > ( α − δ ) tends to be true except when β is around zero . Basically , a subset including more samples close to decision boundaries leads to more probability mass on large values of β , and the case of x ∈ S3 results in largest mass on large values of β because the predicted probabilities mostly concentrate on the two classes in a pair . As shown in Tab . 1 , more mass on large values of β leads to larger probabilities of flipping the sign . These results demonstrate that samples with most diverse gradients ( which gradients have largely negative similarities with other samples ) are close to decision boundaries because they tend to have large β and 〈xn , xm〉 tend to be positive . In the case of x ∈ S1 ∪ S2 the probability of flipping the sign is zero because β concentrates around zero . According to Lemma 1 〈gn , gm〉 are very close to zero in this case because the predictions are close to true labels , hence , such samples are not considered as with most diverse gradients . Theorem 2 says 〈gn , gm〉 has the same sign as 〈xn , xm〉 when the two samples from a same class . We can see the results of positive pairs in Tab . 1 matches Theorem 2 . In the case of S0 ∪ S1 the two probabilities do not add up to exactly 1 because the implementation of cross-entropy loss in tensorflow smooths the function by a small value for preventing numerical issues which slightly changes the gradients . As 〈xn , xm〉 is mostly positive for positive pairs , 〈gn , gm〉 hence is also mostly positive , which explains why samples with most diverse gradients are not sufficient to preserve information within classes in experiments of Fig . 1 . On the other hand , if 〈xn , xm〉 is negative then 〈gn , gm〉 will be negative , which indicates representations within a class should not be too diverse . Extending this theoretical analysis based on a linear model , we also provide empirical study of non-linear models ( Multi-layer Perceptrons ( MLPs ) ) . As demonstrated in Tab . 1 , the probability of flipping the sign in MLPs are very similar with the linear model since it only depends on the predictions and all models have learned reasonable decision boundaries . The probability of getting negative 〈gn , gm〉 is also similar with the linear model except in the case of S1 ∪ S2 for negative pairs , in which the MLP with ReLU gets much less negative 〈gn , gm〉 . As MLP with tanh activations is still consistent with the linear model in this case , we consider the difference is caused by the representations always being positive due to ReLU activations . These results demonstrate that non-linear models exhibit similar behaviors with linear models that mostly align with the theorems . Since only negative 〈gn , gm〉 may cause conflicts , reducing the diversity of gradients hence relies on reducing negative 〈gn , gm〉 . We consider to reduce negative 〈gn , gm〉 by two ways : 1 ) .minimize the representation inner product of negative pairs , which pushes the inner product to be negative or zero ( for positive representations ) ; 2 ) .optimize the predictions to decrease the probability of flipping the sign . In this sense , decreasing the representation similarity of negative pairs might help with both ways . In addition , according to Fig . 2b x ∼ S3 gets larger prediction similarity than x ∼ S0 due to the predictions put most probability mass on both classes of a pair , which indicates decreasing the similarity of predictions may decrease the probability of flipping the sign . Hence , we include logits in the representations . We verify this idea by training two binary classifiers for two groups of MNIST classes ( { 0 , 1 } and { 7 , 9 } ) . The classifiers have two hidden layers each with 100 hidden units and ReLU activations . We randomly chose 100 test samples from each group to compute the pairwise cosine similarities . Representations are obtained by concatenating the output of all layers ( including logits ) of the neural network , gradients are computed by all parameters of the model . We display the similarities in Figs . 3a and 3b . The correlation coefficients between the gradient and representation similarities of negative pairs are -0.86 and -0.85 , which of positive pairs are 0.71 and 0.79 . In all cases , the similarities of representations show strong correlations with the similarities of gradients . The classifier for class 0 and 1 gets smaller representation similarities and much less negative gradient similarities for negative pairs ( blue dots ) and it also gains a higher accuracy than the other classifier ( 99.95 % vs. 96.25 % ) , which illustrates the potential of reducing the gradient diversity by decreasing the representation similarity of negative pairs . | This paper presents a novel way of making full use of compact episodic memory to alleviate catastrophic forgetting in continual learning. This is done by adding the proposed discriminative representation loss to regularize the gradients produced by new samples. Authors gave insightful analysis on the influence of gradient diversity to the performance of continual learning, and proposed a regularization that connects metric learning and continual learning. However, there are still some issues to be addressed as below. | SP:b80bc890180934092cde037b49d94d6e4e06fad9 |
Learning without Forgetting: Task Aware Multitask Learning for Multi-Modality Tasks | 1 INTRODUCTION . The process of Multi-Task Learning ( MTL ) on a set of related tasks is inspired by the patterns displayed by human learning . It involves a pretraining phase over all the tasks , followed by a finetuning phase . During pretraining , the model tries to grasp the shared knowledge of all the tasks involved , while in the finetuning phase , task-specific learning is performed to improve the performance . However , as a result of the finetuning phase , the model forgets the information about the other tasks that it learnt during pretraining . Humans , on the other hand , are less susceptible to forgetfulness and retain existing knowledge/skills while mastering a new task . For example , a polyglot who masters a new language learns to translate from this language without losing the ability to translate other languages . Moreover , the lack of task-based flexibility and having different finetuning/pretraining phases cause gaps in the learning process due to the following reasons : Role Mismatch : Consider the MTL system being trained to perform the Speech Translation ( ST ) , Automatic Speech Recognition ( ASR ) and Machine Translation ( MT ) tasks . The Encoder block has a very different role in the standalone ASR , MT and ST models and hence we can not expect a single encoder to perform well on all the tasks without any cues to identify/use task information . Moreover , there is a discrepancy between pretraining and finetuning hampering the MTL objective . Task Awareness : At each step in the MTL , the model tries to optimize over the task at hand . For tasks like ST and ASR with the same source language , it is impossible for the model to identify the task and alter its parameters accordingly , hence necessitating a finetuning phase . A few such examples have been provided in Table 1 . Humans , on the other hand , grasp the task they have to perform by means of context or explicit cues . Although MTL strategies help the finetuned models to perform better than the models directly trained on those tasks , their applicability is limited to finding a good initialization point for the finetuning phase . Moreover , having a separate model for each task increases the memory requirements , which is detrimental in low resource settings . In order to achieve the goal of jointly learning all the tasks , similar to humans , we need to perform shared learning in synergy with task-specific learning . Previous approaches such as Raffel et al . ( 2019 ) trained a joint model for a set of related text-to-text tasks by providing the task information along with the inputs during the joint learning phase . However , providing explicit task information is not always desirable , e.g. , consider the automatic multilingual speech translation task . In order to ensure seamless user experience , it is expected that the model extracts the task information implicitly . Thus , a holistic joint learning strategy requires a generic framework which learns task-specific information without any explicit supervision . In this work , we propose a generic framework which can be easily integrated into the MTL strategies which can extract task-based characteristics . The proposed approach helps align existing MTL approaches with human learning processes by incorporating task information into the learning process and getting rid of the issues related to forgetfulness . We design a modulation network for learning the task characteristics and modulating the parameters of the model during MTL . As discussed above , the task information may or may not be explicitly available during the training . Hence , we propose two different designs of task modulation network to learn the task characteristics ; one uses explicit task identities while the other uses the examples from the task as input . The model , coupled with the modulation network , jointly learns on all the tasks and at the same time , performs the task-specific learning . The proposed approach tackles issues related to forgetfulness by keeping a single model for all the tasks , and hence avoiding the expensive finetuning phase . Having a single model for all the tasks also reduces memory constraints , improving suitability for low resource devices . To evaluate the proposed framework , we conduct two sets of experiments . First , we include the task information during MTL on text-to-text tasks to show the effect of task information . Secondly , we train a model on tasks with different modalities and end goals , with highly confounding tasks . Our proposed framework allows the model to learn the task characteristics without any explicit supervision , and hence train a single model which performs well on all the tasks . The main contributions of this work are as follows : • We propose an approach to tackle the issue of forgetfulness which occurs during the finetuning phase of existing MTL strategies . • Our model , without any finetuning , achieves superior performance on all the tasks which alleviates the need to keep separate task-specific models . • Our proposed framework is generic enough to be used with any MTL strategy involving tasks with multiple modalities . 2 TASK-AWARE MULTITASK LEARNING . An overview of our proposed approach is shown in Figure 1 . 2.1 BASE MODEL . In general , the sequence-to-sequence architecture consists of two components : ( 1 ) an encoder which computes a set of representationsX = { x1 , · · · , xm } ∈ Rm×d corresponding to x , and a decoder coupled with attention mechanism ( Bahdanau et al. , 2015 ) dynamically reads encoder ’ s output and predicts target language sequence Y = { y1 , · · · , yn } ∈ Rn×d . It is trained on a dataset D to maximize the p ( Y |X ; θ ) , where θ are parameters of the model . We use the Transformer Vaswani et al . ( 2017 ) as our base model . Based on the task modalities , we choose the preprocessing layer in the Transformer , i.e. , speech or the text ( text-embedding ) preprocessing layer . The speech preprocessing layer consists of a stack of k CNN layers with stride 2 for both time and frequency dimensions . This layer compresses the speech sequence and produces the output sequence such that input sequences corresponding to all the tasks have similar dimensions , d. The overview of the base sequence-to-sequence model is shown in the rightmost part of Figure 1 . 2.2 TASK MODULATION NETWORK . The task modulation network performs two operations . In the first step , it computes the task characteristics ( te ) using the task characteristics layer . It then modulates the model parameters θ using te in the second step . 2.2.1 TASK CHARACTERISTICS NETWORK : . We propose two types of Task Characteristics Networks ( TCN ) to learn the task characteristics , where one uses explicit task identities while the other uses source-target sequences as input . Explicit Task Information : In this approach , the tasks involved are represented using different task identities and fed as input to this TCN as one hot vectors . This network consists of a feed-forward layer which produces the task embedding used for modulating the model parameters . te = FFN ( e ) , ( 1 ) where e ∈ Rs is a one-hot encoding of s tasks used during joint learning . Implicit Task Information : The Implicit TCN computes the task embeddings using example sequences from the tasks without any external supervision . It consists of four sub-layers : ( 1 ) Sequence Representation Layer , ( 2 ) Bi-directional Attention Layer , ( 3 ) Sequence Summary Layer , and ( 4 ) Task Embedding Layer . The sequence representation sub-layer consists of uni-directional Transformer Encoder ( TE ) blocks Vaswani et al . ( 2017 ) . It takes the source and target sequences from the tasks as input and produces self-attended source and target sequences . Xsa = TE ( X ) , Y sa = TE ( Y ) , ( 2 ) whereXsa ∈ RM×d , Y sa ∈ RN×d . This sub-layer computes the contextual representation of the sequences . The Bi-directional Attention ( BiA ) sub-layer takes the self-attended source and target sequences from the previous layer as input and computes the relation between them using Dot-Product Attention Luong et al . ( 2015 ) . As a result , we get target aware source ( Xat ∈ RM×d ) and source aware target ( Y asRN×d ) representations as outputs . Xat = BiA ( Xsa , Y sa ) , Y as = BiA ( Y sa , Xsa ) . ( 3 ) The sequence summary sub-layer is similar to the sequence representation sub layer and summarizes the sequences . The sequence summaries are given by : Xs = TEu ( X at ) , Y s = TEu ( Y as ) , ( 4 ) whereXs ∈ RM×d , Y s ∈ RN×d . The Equation 4 summarizes the sequencesXat and Y as which contain the contextual and attention information . We take the last tokens from both the xs ∈ Rd and ys ∈ Rd , since the last token can see the whole sequence and acts as a summary of the sequence . The task embedding layer computes te by taking the outputs of the sequence summary sub-layer and applying a feed-forward network : te = FFN ( [ x s : ys ] ) . ( 5 ) 2.2.2 MODULATING MODEL PARAMETERS . We modulate the parameters ( θ ) of the network ( Section 2.1 ) to account for the task-specific variation during MTL over a set of tasks . We achieve this by scaling ( γ ) and shifting ( β ) the outputs of each layer ( e.g. , transformer block ) including any preprocessing layers in the model adopted based on the Feature-wise Linear Modulation ( FiLM ; Perez et al . ( 2018 ) ) . The γ and β parameters are obtained from the task embedding te either by using equation 1 or 5. γ = te [ : d ] , β = te [ d : ] , ( 6 ) where te ∈ R2d , and d is the hidden dimension of the model . Once we have γ and β , we apply the feature-wise linear modulation ( Perez et al. , 2018 ) to compute the modulated output ( Ol ) for each block of the model . Ol = γ ∗ fl ( vl ; θl ) + β , l = 1 , · · · , L , ( 7 ) where L is the total number of blocks in the model and fl represents the lth block of the model with parameters θl ∈ θ and inputs vl . 2.3 TRAINING . MTL has been successfully applied across different applications of machine learning such as natural language processing ( Hashimoto et al. , 2016 ; Collobert & Weston , 2008 ) , speech recognition ( Liu et al. , 2019 ; Deng et al. , 2013 ) , computer vision ( Zhang et al. , 2014 ; Liu et al. , 2015 ; Girshick , 2015 ) , and drug discovery ( Ramsundar et al. , 2015 ) . It comes in many forms : joint learning , learning to learn , and learning with auxiliary tasks . We consider two MTL strategies : ( 1 ) joint learning and ( 2 ) learning to learn to train on set of S tasks , T = { τ1 , · · · , τS } with corresponding datasets D = { D1 , · · · , DS } . As our first training strategy , we use Joint Learning ( JL ) ( Caruana , 1997 ) , which is the most commonly used training strategy for MTL . In JL , the model parameters , including the output layer , are shared across all the tasks involved in the training . For the second training strategy under the learning-tolearn approach , we use a variant of meta-learning , Modality Agnostic Meta Learning ( MAML ) ( Finn et al. , 2017a ) . Even though MAML is mostly used in few-shot learning settings , we use it since it allows for task-specific learning during the meta-train step and it has also been shown to provide improvements in the field of speech translation ( Indurthi et al. , 2020 ) . We resolve the source-target vocabulary mismatch across different tasks in MTL by using a vocabulary of subwords ( Sennrich et al. , 2016 ) computed from all the tasks . We sample a batch of examples from Ds and use this as input to the TCN and the Transformer model . To ensure that each training example uses the task embedding computed using another example , we randomly shuffle this batch while using them as input to the TCN . This random shuffling improves the generalization performance by forcing the network to learn task-specific characteristics ( te ) in Equation 1 or 5 . We compute the task embedding in the meta-train step as well ; however , the parameters of the TCN are updated only during the meta-test step . During inference time , we use the precomputed task embeddings using a batch of examples randomly sampled from the training set . | This paper proposes a new framework that computes the task-specific representations to modulate the model parameters during the multi-task learning (MTL). This framework uses a single model with shared representations for learning multiple tasks together. Also, explicit task information may not be always available, in such cases the proposed framework is useful. The proposed framework is evaluated on various datasets spanning multiple modalities, where the MTL model even achieves state-of-the-art results on some datasets. | SP:09f2fe6a482bbd6f9bd2c62aa841f995171ba939 |
A Robust Fuel Optimization Strategy For Hybrid Electric Vehicles: A Deep Reinforcement Learning Based Continuous Time Design Approach | 1 INTRODUCTION . Hybrid electric vehicles powered by fuel cells and batteries have attracted great enthusiasm in modern days as they have the potential to eliminate emissions from the transport sector . Now , both the fuel cells and batteries have got several operational challenges which make the separate use of each of them in automotive systems quite impractical . HEVs and PHEVs powered by conventional diesel engines and batteries merely reduce the emissions , but can not eliminate completely . Some of the drawbacks include carbon emission causing environmental pollution from fuel cells and long charging times , limited driving distance per charge , non-availability of charging stations along the driving distance for the batteries . Fuel Cell powered Hybrid Electric Vehicles ( FCHEVs ) powered by fuel cells and batteries offer emission-free operation while overcoming the limitations of driving distance per charge and long charging times . So , FCHEVs have gained significant attention in recent years . As we find , most of the existing research which studied and developed several types of Fuel and Energy Management Systems ( FEMS ) for transport applications include Sulaiman et al . ( 2018 ) who has presented a critical review of different energy and fuel management strategies for FCHEVs . Li et al . ( 2017 ) has presented an extensive review of FMS objectives and strategies for FCHEVs . These strategies , however can be divided into two groups , i.e. , model-based and modelfree . The model-based methods mostly depend on the discretization of the state space and therefore suffers from the inherent curse of dimensionality . The coumputational complexity increases in an exponential fashion with the increase in the dimension of the state space . This is quite evident in the methods like state-based EMS ( Jan et al. , 2014 ; Zadeh et al. , 2014 ; 2016 ) , rule-based fuzzy logic strategy ( Motapon et al. , 2014 ) , classical PI and PID strategies ( Segura et al. , 2012 ) , Potryagin ’ s minimum principle ( PMP ) ( Zheng et al. , 2013 ; 2014 ) , model predictive control ( MPC ) ( Kim et al. , 2007 ; Torreglosa et al. , 2014 ) and differential dynamic programming ( DDP ) ( Kim et al. , 2007 ) . Out of all these methods , differential dynamic programming is considered to be computationally quite efficient which rely on the linearization of the non-linear system equations about a nominal state trajectory followed by a policy iteration to improve the policy . In this approach , the control policy for fuel optimization is used to compute the optimal trajectory and the policy is updated until the convergence is achieved . The model-free methods mostly deal with the Adaptive Dynamic Programming ( Bithmead et al. , 1991 ; Zhong et al. , 2014 ) and Reinforcement Learning ( RL ) based strategies ( Mitrovic et al. , 2010 ; Khan et al. , 2012 ) icluding DDP ( Mayne et al. , 1970 ) . Here , they tend to compute the control policy for fuel optimization by continous engagement with the environment and measuring the system response thus enabling it to achieve at a solution of the DP equation recursively in an online fashion . In deep reinforcement learning , multi-layer neural networks are used to represent the learning function using a non-linear parameterized approximation form . Although a compact paremeterized form do exist for the learning function , the inability to know it apriori renders the method suffer from the curse of dimensionality ( O ( d2 ) where , d is the dimension of the state space ) , thus making it infeasible to apply to a high-dimemsional fuel managememt system . The problem of computational complexity of the traditional RL methods like policy iteration ( PI ) and value iteration ( VI ) ( Bellman et al. , 1954 ; 2003 ; Barto et al. , 1983 ; Bartsekas , 2007 ) can be overcome by a simulation based approach ( Sutton et al. , 1998 ) where the policy or the value function can be parameterized with sufficient accuracy using a small number of parameters . Thus , we will be able to transform the optimal control problem to an approximation problem in the parameter space ( Bartesekas et al. , 1996 ; Tsitsiklis et al. , 2003 ; Konda et al. , 2004 ) side stepping the need for model knowledge and excessive computations . However , the convergence requires sufficient exploration of the state-action space and the optimality of the obtained policy depends primarily on the accuracy of the parameterization scheme . As a result , a good approximation of the value function is of utmost importance to the stability of the closed-loop system and it requires convergence of the unknown parameters to their optimal values . Hence , this sufficient exploration condition manifests itself as a persistence of excitation ( PE ) condition when RL is implemented online ( Mehta et al. , 2009 ; Bhasin et al. , 2013 ; Vrabie , 2010 ) which is impossible to be guaranteed a priori . Most of the traditional approaches for fuel optimization are unable to adrress the robustness issue . The methods described in the literature including those of PID ( Segura et al.,2012 ) , Model Predictive Control ( MPC ) ( Kim et al.,2007 ; Torreglosa et al. , 2014 ) and Adaptive Dynamic Programming ( Bithmead et al.,1991 ; Zhong et al. , 2014 ) as well as the simulation based RL strategies ( Bartesekas et al. , 1996 ; Tsitsiklis et al. , 2003 ; Konda et al. , 2004 ) suffer from the drawback of providing a suboptimal solution in the presence of external disturbances and noise . As a result , application of these methods for fuel optimization for hybrid electric vehicles that are plagued by various disturbances in the form of sudden charge and fuel depletion , change in the environment and in the values of the parameters like remaining useful life , internal resistance , voltage and temperature of the battery , are quite impractical . The fuel optimization problem for the hybrid electric vehicle therefore have been formulated as a fully observed stochastic Markov Decision Process ( MDP ) . Instead of using Trajectory-optimized LQG ( T-LQG ) or Model Predictive Control ( MPC ) to provide a sub-optimal solution in the presence of disturbances and noice , we propose a deep reinforcement learning-based optimization strategy using concurrent learning ( CL ) that uses the state-derivative-action-reward tuples to present a robust optimal solution . The convergence of the weight estimates of the policy and the value function to their optimal values justifies our claim . The two major contributions of the proposed approch can be therefore be summarized as follows : 1 ) The popular methods in RL literature including policy iteration and value iteration suffers from the curse of dimensionality owing to the use of a simulation based technique which requires sufficient exploration of the state space ( PE condition ) . Therefore , the proposed model-based RL scheme aims to relax the PE condition by using a concurrent learning ( CL ) -based system identifier to reduce the computational complexity . Generally , an estimate of the true controller designed using the CLbased method introduces an approximate estimation error which makes the stability analysis of the system quite intractable . The proposed method , however , has been able to establish the stability of the closed-loop system by introducing the estimation error and analyzing the augmented system trajectory obtained under the influnece of the control signal . 2 ) The proposed optimization algorithm implemented for fuel management in hybrid electric vehicles will nullify the limitations of the conventional fuel management approaches ( PID , Model Predictive Control , ECMS , PMP ) and traditional RL approaches ( Adaptive Dynamic Proagramming , DDP , DQN ) , all of which suffers from the problem of sub-optimal behaviour in the presence of external disturbances , model-uncertainties , frequent charging and discharging , change of enviroment and other noises . The H-infinity ( H∞ ) performance index defined as the ratio of the disturbance to the control energy has been established for the RL based optimization technique and compared with the traditional strategies to address the robustness issue of the proposed design scheme . The rest of the paper is organised as follows : Section 2 presents the problem formulation including the open-loop optimization and reinforcement learning-based optimal controller design which have been described in subsections 2.1 and 2.2 respectively . The parametric system identification and value function approximation have been detailed in subsections 2.2.1 and 2.2.2 . This is followed by the stability and robustness analysis ( using the H-infinity ( H∞ ) performance index ) of the closed loop system in subsection 2.2.4 . Section 3 provides the simulation results and discussion followed by the conclusion in Section 4 . 2 PROBLEM FORMULATION . Considering the fuel management system of a hybrid electric vehicle as a continous time affine non-linear dynamical system : ẋ = f ( x , w ) + g ( x ) u , y = h ( x , v ) ( 1 ) where , x ∈ Rnx , y ∈ Rny , u ∈ Rnu are the state , output and the control vectors respectively , f ( . ) denotes the drift dynamics and g ( . ) denotes the control effectivenss matrix . The functions f and h are assumed to be locally Lipschitz continuous functions such that f ( 0 ) = 0 and∇f ( x ) is continous for every bounded x ∈Rnx . The process noise w and measurement noise v are assumed to be zero-mean , uncorrelated Gausssian white noise with covariances W and V , respectively . Assumption 1 : We consider the system to be fully observed : y = h ( x , v ) = x ( 2 ) Remark 1 : This assumption is considered to provide a tractable formulation of the fuel management problem to side step the need for a complex treatment which is required when a stochastic control problem is treated as partially observed MDP ( POMDP ) . Optimal Control Problem : For a continous time system with unknown nonlinear dynamics f ( . ) , we need to find an optimal control policy πt in a finite time horizon [ 0 , t ] where πt is the control policy at time t such that πt = u ( t ) to minimize the cost function given by J = ∫ t 0 ( xTQx+uRuT ) dt+xTFx where , Q , F > 0 and R ≥ 0 . 2.1 OPEN LOOP OPTIMIZATION . Considering a noise-free non-linear stochastic dynamical system with unknown dynamics : ẋ = f ( x , 0 ) + g ( x ) u , y = h ( x , v ) = x ( 3 ) where , x0 ∈ Rnx , y ∈ Rny , u ∈ Rnu are the initial state , output and the control vectors respectively , f ( . ) have their usual meanings and the corresponding cost function is given by Jd ( x0 , ut ) =∫ t 0 ( xTQx+ uRuT ) dt+ xTFx . Remark : We have used piecewise convex function to approximate the non-convex fuel function globally which has been used to formulate the cost function for the fuel optimization . The open loop optimization problem is to find the control sequence ut such that for a given initial state x0 , ūt = arg min Jd ( x0 , ut ) , subject to ẋ = f ( x , 0 ) + g ( x ) u , y = h ( x , v ) = x . ( 4 ) The problem is solved using the gradient descent approach ( Bryson et al. , 1962 ; Gosavi et al. , 2003 ) , and the procedure is illustrated as follows : Starting from a random initial value of the control sequence U ( 0 ) = [ ut ( 0 ) ] the control policy is updated iteratively as U ( n+1 ) = U ( n ) − α∇UJd ( x0 , U ( n ) ) , ( 5 ) until the convergence is achieved upto a certain degree of accuracy where U ( n ) denotes the control value at the nth iteration and α is the step size parameter . The gradient vector is given by : ∇UJd ( x0 , U ( n ) ) = ( ∂Jd ∂u0 , ∂Jd ∂u1 , ∂Jd ∂u2 , ..... , ∂Jd ∂ut ) | ( x0 , ut ) ( 6 ) The Gradient Descent Algorithm showing the approach has been detailed in the Appendix A.1 . Remark 2 : The open loop optimization problem is thus solved using the gradient descent approach considering a black-box model of the underlying system dynamics using a sequence of input-output tests without having the perfect knowlegde about the non-linearities in the model at the time of the design . This method proves to be a very simple and useful strategy for implementation in case of complex dynamical systems with complicated cost-to-go functions and suitable for parallelization . | This work proposes a deep reinforcement learning-based optimization strategy to the fuel optimization problem for the hybrid electric vehicle. The problem has been formulated as a fully observed stochastic Markov Decision Process (MDP). A deep neural network is used to parameterize the policy and value function. A continuous time representation of the problem is also used compared to conventional techniques which mostly use a discrete time formulation. | SP:a1e2218e6943bf138aeb359e23628676b396ed66 |
Neural representation and generation for RNA secondary structures | 1 INTRODUCTION . There is an increasing interest in developing deep generative models for biochemical data , especially in the context of generating drug-like molecules . Learning generative models of biochemical molecules can facilitate the development and discovery of novel treatments for various diseases , reducing the lead time for discovering promising new therapies and potentially translating in reduced costs for drug development ( Stokes et al. , 2020 ) . Indeed , the study of generative models for molecules has become a rich and active subfield within machine learning , with standard benchmarks ( Sterling & Irwin , 2015 ) , a set of well-known baseline approaches ( Gómez-Bombarelli et al. , 2018 ; Kusner et al. , 2017 ; Liu et al. , 2018 ; Jin et al. , 2018 ) , and high-profile cases of real-world impact 1 . Prior work in this space has focused primarily on the generation of small molecules ( with less than 100 atoms ) , leaving the development of generative models for larger and more complicated biologics and biosimilar drugs ( e.g. , RNA and protein peptides ) an open area for research . Developing generative models for larger biochemicals is critical in order to expand the frontiers of automated treatment design . More generally , developing effective representation learning for such complex biochemicals will allow machine learning systems to integrate knowledge and interactions involving these biologically-rich structures . In this work , we take a first step towards the development of deep generative models for complex biomolecules , focusing on the representation and generation of RNA structures . RNA plays a crucial 1e.g . LambdaZero project for exascale search of drug-like molecules . role in protein transcription and various regulatory processes within cells which can be influenced by its structure ( Crick , 1970 ; Stefl et al. , 2005 ) , and RNA-based therapies are an increasingly active area of research ( Pardi et al. , 2018 ; Schlake et al. , 2012 ) , making it a natural focus for the development of deep generative models . The key challenge in generating RNA molecules—compared to the generation of small molecules—is that RNA involves a hierarchical , multi-scale structure , including a primary sequential structure based on the sequence of nucleic acids as well as more complex secondary and tertiary structures based on the way that the RNA strand folds onto itself . An effective generative model for RNA must be able to generate sequences that give rise to these more complex emergent structures . There have been prior works on optimizing or designing RNA sequences—using reinforcement learning or blackbox optimization—to generate particular RNA secondary structures ( Runge et al. , 2019 ; Churkin et al. , 2017 ) . However , these prior works generally focus on optimizing sequences to conform to a specific secondary structure . In contrast , our goal is to define a generative model , which can facilitate the sampling and generation of diverse RNA molecules with meaningful secondary structures , while also providing a novel avenue for targeted RNA design via search over a tractable latent space . Key contributions . We propose a series of benchmark tasks and deep generative models for the task of RNA generation , with the goal of facilitating future work on this important and challenging problem . We propose three interrelated benchmark tasks for RNA representation and generation : 1 . Unsupervised generation : Generating stable , valid , and diverse RNAs that exhibit complex secondary structures . 2 . Semi-supervised learning : Learning latent representations of RNA structure that correlate with known RNA functional properties . 3 . Targeted generation : Generating RNAs that exhibit particular functional properties . These three tasks build upon each other , with the first task only requiring the generation of stable and valid molecules , while the latter two tasks involve representing and generating RNAs that exhibit particular properties . In addition to proposing these novel benchmarks for the field , we introduce and evaluate three generative models for RNA . All three models build upon variational autoencoders ( VAEs ) ( Kingma & Welling , 2014 ) augmented with normalizing flows ( Rezende & Mohamed , 2015 ; Kingma et al. , 2016 ) , and they differ in how they represent the RNA structure . To help readers better understand RNA structures and properties , a self-contained explanation is provided in appendix B . The simplest model ( termed LSTMVAE ) learns using a string-based representation of RNA structure . The second model ( termed GraphVAE ) leverages a graph-based representation and graph neural network ( GNN ) encoder approach ( Gilmer et al. , 2017 ) . Finally , the most sophisticated model ( termed HierVAE ) introduces and leverages a novel hierarchical decomposition of the RNA structure . Extensive experiments on our newly proposed benchmarks highlight how the hierarchical approach allows more effective representation and generation of complex RNA structures , while also highlighting important challenges for future work in the area . 2 TASK DESCRIPTION . Given a dataset of RNA molecules , i.e . sequences of nucleotides and corresponding secondary structures , our goals are to : ( a ) learn to generate structurally stable , diverse , and valid RNA molecules that reflect the distribution in this training dataset ; ( b ) learn latent representations that reflect the functional properties of RNA . A key factor in both these representation and generation processes is that we seek to jointly represent and generate both the primary sequence structure as well as the secondary structure conformation . Together , these two goals lay the foundations for generating novel RNAs that satisfy certain functional properties . To meet these goals , we create two types of benchmark datasets , each one focusing on one aspect of the above mentioned goals : Unlabeled and variable-length RNA . The first dataset contains unlabeled RNA with moderate and highly-variable length ( 32-512 nts ) , obtained from the human transcriptome ( Aken et al. , 2016 ) and through which we focus on the generation aspect of structured RNA and evaluate the validity , stability and diversity of generated RNA molecules . In particular , our goal with this dataset is to jointly generate RNA sequences and secondary structures that are biochemically feasible ( i.e. , valid ) , have low free energy ( i.e. , stable ) , and are distinct from the training data ( i.e. , diverse ) . We will give an extended assessment of the generation aspect under different circumstances , e.g. , when constraining the generation procedures with explicit rules . Labeled RNA . The second dataset is pulled and processed from a previous study on in vitro RNAprotein interaction , which features labeled RNAs with shorter and uniform length ( 40 nts ) ( Cook et al. , 2017 ) . With this dataset , our objective is slightly expanded ( to include obj . a ) , so that the latent space is adequately organized and reflective of the interaction with proteins . Therefore , key assessment for the latent space includes AUROC for the classification of protein binding , which is crucial for the design of desired novel RNA molecules . Essentially , this creates slight variations in the task formulation , with the first dataset suited to unsupervised learning of a generative model , while the second datasets involves additional supervision ( e.g. , for a semi-supervised model or targeted generation ) . Our specific modeling choices , to be introduced in section 3 , are invariant to different task formulations , and flexible enough to handle different representations of RNA secondary structures . We refer readers to appendix C for detailed explanation for the dataset and evaluation metrics on the generated molecules and latent embeddings . 3 METHODS . In this section , we introduce three different generative models for RNA . All three models are based upon the variational autoencoder ( VAE ) framework , involving three key components : 1 . A probabilistic encoder network qφ ( z|x ) , which generates a distribution over latent states given an input representation of an RNA . We experiment with three different types of input encodings for RNA sequence and secondary structures ( see Figure S1 : a dot-bracket annotated string , a graph with adjacency matrix representing base-pairings , and a graph augmented with a hierarchical junction tree annotation for the secondary structure . 2 . A probabilistic decoder network pθ ( x|z ) , which defines a joint distribution over RNA sequences and secondary structures , conditioned on a latent input . As with the encoder network , we design architectures based on a linearized string decoding and a graph-based hierarchical junction-tree decoding approach . 3 . A parameterized prior pψ ( z ) , which defines a prior distribution over latent states and is learned based on a continuous normalizing flow ( CNF ) ( Chen et al. , 2018 ) . For all the approaches we propose , the model is optimized via stochastic gradient descent to minimize the evidence lower bound ( ELBO ) : L = −Eqφ ( z|x ) [ pθ ( x|z ) ] + β KL ( qφ ( z|x ) |pψ ( z ) ) where β is a term to allow KL-annealing over the strength of the prior regularization . In the following sections , we explain our three different instantiations of the encoder ( section 3.1 ) , decoder ( section 3.2 ) , as well as our procedures to structurally constrain the decoding process using domain knowledge ( section 3.3 ) and our procedures to avoid posterior collapse ( section 3.4 ) . 3.1 ENCODING RNA SECONDARY STRUCTURES . The input to the encoder is a structured RNA molecule , with its sequence given by an ordered array of nucleotides x1 . . . xL , with xi ∈ { A , C , G , U } , where L is the length of the sequence , and its secondary structure , either rep- resented as ( 1 ) a dot-bracket string S = ẋ1 . . . ẋL with ẋi ∈ { . , ( , ) } ; ( 2 ) or as a graph G with two types of edges — covalent bonds along the RNA backbone , and hydrogen bonds between the base- pairs 2 . We use xuv to denote edge features between nucleotides u and v ; ( 3 ) or as a hypergraph T — a depth-first ordered array of subgraphs Ĝ1 . . . ĜD with L ( Ĝi ) ∈ { S , H , I , M } indicating the subgraph label , and I ( Ĝi ) = { j|j ∈ { 1 . . . L } } indicating the assignment of nucleotides to each subgraph . Encoding RNA secondary structure as sequence . First , we obtain a joint encoding over the nucleotide and the dot-bracket annotation , using the joint sequence-structure vocabulary { A , C , G , U } × { . , ( , ) } . Then , these one-hot encodings are processed by a stacked bidirectional LSTM ( Hochreiter & Schmidhuber , 1997 ) , followed by a multi-head self-attention module ( Vaswani et al. , 2017 ) to weigh different positions along the RNA backbone . A global max-pooling is used to aggregate the information into hS , and then we obtain mean µS and log variance log σS from hS through linear transformations , and draw latent encoding zS from N ( µS , σS ) using the reparameterization trick ( Kingma & Welling , 2014 ) . Learning graph representation of RNA secondary structure . To encode the graph view G of an RNA secondary structure , we pass rounds of neural messages along the RNA structure , which falls into the framework of Message Passing Neural Network ( MPNN ) as originally discussed in Gilmer et al . ( 2017 ) and similarly motivated by Jin et al . ( 2018 ) . For much longer RNAs , it is conceptually beneficial to pass more rounds of messages so that a nucleotide may receive information on its broader structural context . However , this may introduce undesired effects such as training instability and over-smoothing issues . Therefor , we combine our MPNN network with gating mechanism , which is collectively referred as the G-MPNN : v̂t−1uv = σ ( W g local [ xu ||xuv ] +W g msg ∑ w∈N ( u ) vt−1wu ) ( 1 ) vtuv = GRU ( v̂ t−1 uv , v t−1 uv ) ( 2 ) where [ . . . || . . . ] denotes concatenation , σ denotes the activation function and GRU indicates the gated recurrent unit ( Cho et al. , 2014 ) . Then , after T iterations of message passing , the final nucleotide level embedding is given by : hu = σ ( W g emb [ xu || ∑ v∈N ( u ) v T vu ] ) . Before pooling the nucleotide level embeddings into the graph level , we pass h1 . . . hL through a single bidirectional LSTM layer , obtaining ĥ1 . . . ĥL at each step , and hg = max ( { ĥi|i ∈ 1 ... L } ) . The latent encoding zG is similarly obtained from hG using the reparameterization trick . Hierarchical encoding of the RNA hypergraph . To encode the junction tree T of RNA , we employ a type of GRU specifically suited to tree-like structures , which has previously been applied in works such as GGNN ( Li et al. , 2016 ) and JTVAE ( Jin et al. , 2018 ) . We refer to this tree encoding network as T-GRU , and the format of its input is shown in Figure 1 . One major distinction between our RNA junction tree and the one used for chemical compounds ( Jin et al. , 2018 ) is that an RNA subgraph assumes more variable nucleotide composition such that it is impossible to enumerate based on the observed data . Therefore , we need to dynamically compute the features for each node in an RNA junction tree based on its contained nucleotides , in a hierarchical manner to leverage the nucleotide level embeddings learnt by G-MPNN . Considering a subgraph Ĝi in the junction tree T , we initialize its node feature with : xĜi = [ L ( Ĝi ) ||maxu∈I ( Ĝi ) hu ] . Notably , maxu∈Ĝi hu is a max-pooling over all nucleotides assigned to Ĝi , and nucleotide embedding hu comes from G-MPNN . To compute and pass neural messages between adjacent subgraphs in the RNA junction tree T , we use the T-GRU network in Eq.3 vtĜi , Ĝj = T-GRU ( xĜi , { v t−1 Ĝk , Ĝi | Ĝk ∈ N ( Ĝi ) } ) ( 3 ) hĜi = σ ( W t emb [ xĜi || ∑ Ĝ∈N ( Ĝi ) hĜ ] ) ( 4 ) with details of T-GRU provided in the appendix D , and compute the embeddings for subgraphs with Eq . 4 . Further , we obtain a depth-first traversal of the subgraph embeddings hĜ1 . . . hĜD′ which is also the order for hierarchical decoding to be discussed later . This ordered array of embeddings is processed by another bi-directional LSTM , and the final tree level representation hT is again given by the max-pooling over the bi-LSTM outputs . Likewise , latent encoding zT is obtained from hT . 2We do not differentiate the number of hydrogen bonds , which can be different depending on the base-pairs . For example , G-C has three hydrogen bonds whereas A-U only contains two . | This paper proposes 3 deep generative models based on VAEs (with different encoding schemes for RNA secondary structure) for the generation of RNA secondary structures. They test each model on 3 benchmark tasks: unsupervised generation, semi-supervised learning and targeted generation. This paper has many interesting contributions — a comparison of VAE models that use different RNA secondary structure encoding schemes, including traditional dot-bracket notation and a more complex hierarchical encoding, and they also introduce various decoding schemes to encourage valid secondary structures. | SP:43e525fb3fa611df7fd44bd3bc9843e57b154c66 |
DiP Benchmark Tests: Evaluation Benchmarks for Discourse Phenomena in MT | 1 INTRODUCTION AND RELATED WORK . The advances in neural machine translation ( NMT ) systems have led to great achievements in terms of state-of-the-art performance in automatic translation tasks . There have even been claims that their translations are no worse than what an average bilingual human may produce ( Wu et al. , 2016 ) or that the translations are on par with professional translators ( Hassan et al. , 2018 ) . However , extensive studies conducting evaluations with professional translators ( Läubli et al. , 2018 ; Popel et al. , 2020 ) have shown that there is a statistically strong preference for human translations in terms of fluency and overall quality when evaluations are conducted monolingually or at the document level . Document ( or discourse ) level phenomena ( e.g. , coreference , coherence ) may not seem lexically significant , but contribute significantly to readability and understandability of the translated texts ( Guillou , 2012 ) . Targeted datasets for evaluating phenomena like coreference ( Guillou et al. , 2014 ; Guillou & Hardmeier , 2016 ; Lapshinova-Koltunski et al. , 2018 ; Bawden et al. , 2018 ; Voita et al. , 2018b ) , or ellipsis and lexical cohesion ( Voita et al. , 2019 ) , have been proposed . The NMT framework such as the Transformer ( Vaswani et al. , 2017 ) provides more flexibility to incorporate larger context . This has spurred a great deal of interest in developing context-aware NMT systems that take advantage of source or target contexts , e.g. , Miculicich et al . ( 2018 ) , Maruf & Haffari ( 2018 ) , Voita et al . ( 2018b ; 2019 ) , Xiong et al . ( 2019 ) , Wong et al . ( 2020 ) , to name a few . Most studies only report performance on specific testsets , often limited to improvements in BLEU ( Papineni et al. , 2002 ) . Despite being the standard MT evaluation metric , BLEU has been criticised for its inadequacy ; the scores are not interpretable , and are not sensitive to small improvements in lexical terms that may lead to big improvements in fluency or readability ( Reiter , 2018 ) . There is no framework for a principled comparison of MT quality beyond mere lexical matching as done in BLEU : there are no standard corpora and no agreed-upon evaluation measures . To address these shortcomings , we propose the DiP benchmark tests ( for Discourse Phenomena ) , that will enable the comparison of machine translation models across discourse task strengths and source languages . We create diagnostic testsets for four diverse discourse phenomena , and also propose automatic evaluation methods for these tasks . However , discourse phenomena in translations can be tricky to identify , let alone evaluate . A fair number of datasets proposed thus far have been manually curated , and automatic evaluation methods have often failed to agree with human judgments ( Guillou & Hardmeier , 2018 ) . To mitigate these issues , we use trained neural models for identifying and evaluating complex discourse phenomena and conduct extensive user studies to ensure agreements with human judgments . Our methods for automatically extracting testsets can be applied to multiple languages , and find cases that are difficult to translate without having to resort to synthetic data . Moreover , our testsets are extracted in a way that makes them representative of current challenges . They can be easily updated to reflect future challenges , preventing the pitfall of becoming outdated , which is a common failing of many benchmarking testsets . We also benchmark established MT models on these testsets to convey the extent of the challenges they pose . Although discourse phenomena can and do occur at the sentence-level ( e.g. , between clauses ) , we would expect MT systems that model extra-sentential context ( Voita et al. , 2018b ; Zhang et al. , 2018 ; Miculicich et al. , 2018 ) to be more successful on these tasks . However , we observe significant differences in system behavior and quality across languages and phenomena , emphasizing the need for more extensive evaluation as a standard procedure . We propose to maintain a leaderboard that tracks and highlights advances in MT quality that go beyond BLEU improvement . Our main contributions in this paper are as follows : • Benchmark testsets for four discourse phenomena : anaphora , coherence & readability , lexical consistency , and discourse connectives . • Automatic evaluation methods and agreements with human judgments . • Benchmark evaluation and analysis of four context-aware systems contrasted with baselines , for German/Russian/Chinese-English language pairs . 2 MACHINE TRANSLATION MODELS . Model Architectures . We first introduce the MT systems that we will be benchmarking on our testsets . We evaluate a selection of established models of various complexities ( simple sentencelevel to complex context-aware models ) , taking care to include both source- and target-side contextaware models . We briefly describe the model architectures here : • S2S : A standard 6-layer base Transformer model ( Vaswani et al. , 2017 ) which translates sentences independently . • CONCAT : A 6-layer base Transformer whose input is two sentences ( previous and current sentence ) merged , with a special character as a separator ( Tiedemann & Scherrer , 2017 ) . • ANAPH : Voita et al . ( 2018b ) incorporate source context by encoding it with a separate encoder , then fusing it in the last layer of a standard Transformer encoder using a gate . They claim that their model explicitly captures anaphora resolution . • TGTCON : To model target-context , we implement a version of ANAPH with an extra operation of multi-head attention in the decoder , computed between representations of the target sentence and target context . The architecture is described in detail in the Appendix ( A.5 ) . • SAN : Zhang et al . ( 2018 ) use source attention network : a separate Transformer encoder to encode source context , which is incorporated into the source encoder and target decoder using gates . • HAN : Miculicich et al . ( 2018 ) introduce a hierarchical attention network ( HAN ) into the Transformer framework to dynamically attend to the context at two levels : word and sentence . They achieve the highest BLEU when hierarchical attention is applied separately to both the encoder and decoder . Datasets and Training . The statistics for the datasets used to train the models are shown in Table 1 . We tokenize the data using Jieba1 for Zh and Moses scripts2 for the other languages , lowercase the text , and apply BPE encodings3 from Sennrich et al . ( 2016 ) . We learn the BPE encodings with the command learn-joint-bpe-and-vocab -s 40000 . The scores reported are BLEU4 , computed either through fairseq or NLTK ( Wagner , 2010 ) . Further details about dataset composition , training settings and hyperparameters can be found in the Appendix ( A.7 ) . 1https : //github.com/fxsjy/jieba 2https : //www.statmt.org/moses/ 3https : //github.com/rsennrich/subword-nmt/ BLEU scores . The BLEU scores on the WMT-14 ( De-En , Ru-En ) and on the WMT-17 ( Zh-En ) testsets for each of the six trained models are shown in Table 2 . We were unable to train HAN for Zh-En as the model was not optimized for training with large datasets . In contrast to increases in BLEU for selected language-pairs and datasets reported in published work , incorporating context within elaborate context-dependent models decreases BLEU scores for the Zh-En and De-En tasks . However , the simple concatenation-based model CONCAT performs better than S2S for De-En and Ru-En ; this shows that context knowledge is indeed helpful for improving BLEU . 3 BENCHMARK TESTSETS . We construct our benchmarking testsets based on four main principles : Selectivity . The testsets need to provide hard to translate contexts for MT models . We ensure this by looking at translation errors made by system submissions to campaigns like WMT and IWSLT . Authenticity . The testsets can not contain artificial or synthetic data but only natural text . Rather than generating testset samples using heuristics , we extract hard contexts from existing humangenerated source text . Multilinguality . The testset extraction method should be automatic and applicable to multiple languages . Our framework can be used to extract testsets for all source languages that are part of the considered MT campaigns . Adaptability . The testsets should be easy to update frequently , making them adaptable to improvements in newer systems . Since we automatically extract hard contexts based on MT errors , our testsets are easy to update ; they adapt to errors in newer ( and possibly more accurate ) systems , making the tasks harder over time . We use the system outputs released by WMT and IWSLT for the most recent years ( Nadejde et al. , 2016 ; Bojar et al. , 2017 ; 2018 ; 2019 ; Cettolo et al. , 2016 ; 2017 ) to build our testsets . For De-En , Ru-En and Zh-En , these consist of translation outputs from 68 , 41 and 47 unique systems respectively . Since the data comes from a wide variety of systems , our testsets representatively aggregate different types of errors from several ( arguably SOTA ) models . Also note that the MT models we are benchmarking are not a part of these system submissions to WMT , so there is no potential bias in the testsets . 3.1 ANAPHORA . Anaphora are references to entities that occur elsewhere in a text ; mishandling them can result in ungrammatical sentences or the reader inferring the wrong antecedent , leading to misunderstanding of the text ( Guillou , 2012 ) . We focus specifically on the aspect of incorrect pronoun translations . Testset . To obtain hard contexts for pronoun translation , we look for source texts that lead to erroneous pronoun translations in system outputs . We align the system translations with their references , and collect the cases in which the translated pronouns do not match the reference.4 Our anaphora testset is an updated version of the one proposed by Jwalapuram et al . ( 2019 ) . We filter the system translations based on their list of cases where the translations can be considered wrong , rather than acceptable variants . The corresponding source texts are extracted as a test suite for pronoun translation . This gives us a pronoun benchmark testset of 2564 samples for De-En , 2368 for Ru-En and 1540 for Zh-En . Evaluation . Targeted evaluation of pronouns in MT has been challenging as it is not fair to expect an exact match with the reference . Evaluation methods like APT ( Miculicich Werlen & PopescuBelis , 2017 ) or AutoPRF ( Hardmeier & Federico , 2010 ) are specific to language pairs or lists of pronouns , requiring extensive manual intervention . They have also been criticised for failing to produce evaluations that are consistent with human judgments ( Guillou & Hardmeier , 2018 ) . Jwalapuram et al . ( 2019 ) propose a pairwise ranking model that scores “ good '' pronoun translations ( like in the reference ) higher than “ poor '' pronoun translations ( like in the MT output ) in context , and show that their model is good at making this distinction , along with having high agreements with human judgements . However , they do not rank multiple system translations against each other , which is our main goal ; the absolute scores produced by their model are not useful since it is trained in a pairwise fashion . We devise a way to use their model to score and rank system translations in terms of pronouns . First , we re-train their model with more up-to-date WMT data ( more details in Appendix A.1 ) . We obtain a score for each benchmarked MT system ( S2S , CONCAT , etc . ) translation using the model , plus the corresponding reference sentence . We then normalize the score for each translated sentence by calculating the difference with the reference . To get an overall score for an MT system , the assigned scores are summed across all sentences in the testset . Scoresys = ∑ i ρi ( ref|θ ) − ρi ( sys|θ ) ( 1 ) where ρi ( .|θ ) denotes the score given to sentence i by the pronoun model θ . The systems are ranked based on this overall score , where a lower score indicates a better performance . We conduct a user study to confirm that the model rankings correspond with human judgments , obtaining an agreement of 0.91 between four participants who annotated 100 samples . Appendix A.1 gives details ( e.g. , interface , participants , agreement ) about the study . | This paper presents a benchmark for discourse phenomena in machine translation. Its main novelty lies in the relatively large scale, spanning three translation directions, four discourse phenomena, and 150-5000 data points per language and phenomenon. A relatively large number of systems from previous work is benchmarked on each test set, and agreement with human judgments is measured. | SP:0bd749fe44c37b521bd40f701e1428890aaa9c95 |
Private Image Reconstruction from System Side Channels Using Generative Models | 1 INTRODUCTION . Side channel analysis ( SCA ) recovers program secrets based on the victim program ’ s nonfunctional characteristics ( e.g. , its execution time ) that depend on the values of program secrets . SCA constitutes a major threat in today ’ s system and hardware security landscape . System side channels , such as CPU cache accesses and operating system ( OS ) page table accesses made by the victim software , are widely used to recover program secrets under various real-world scenarios ( Gullasch et al. , 2011 ; Aciicmez & Koc , 2006 ; Wu et al. , 2012 ; Hähnel et al. , 2017 ; Xu et al. , 2015 ; Yarom et al. , 2017 ) . To conduct SCA , attackers first conduct an online phase to log a trace of side channel data points made by the victim software ( e.g. , its accessed CPU cache lines ) . Then , attackers launch an offline phase to analyze the logged trace and infer secrets ( e.g. , private inputs ) . Enabled by advances in system research , the online phase can be performed smoothly ( Xu et al. , 2015 ) . Nevertheless , the offline phase is challenging , requiring comprehension of victim software ’ s input-relevant operations and how such operations influence side channels . The influence is program-specific and obscure ( see an example in Fig . 1 ) . Even worse , side channel data points made by real-world software are usually highly noisy . For instance , executing libjpeg ( libjpeg , 2020 ) to decompress one unknown JPEG image produces a trace of over 700K side channel data points , where only a small portion depends on the image content . Identifying such input-dependent data points from over 700K records is extremely difficult . Launching SCA to recover images processed by media software constitutes a common threat in the era of cloud computing ( Xu et al. , 2015 ; Hähnel et al. , 2017 ) , especially when machine learning as a service ( MLaaS ) is substantially offered ( e.g. , for face recognition ) . When envisioning the high ∗Corresponding Author risk of violating user privacy , there is a demanding need to understand the adversarial capability of reconstructing private images with SCA . To date , the offline inference phase of existing SCA attacks requires lots of manual efforts with heuristics ( Xu et al. , 2015 ; Hähnel et al. , 2017 ) . While some preliminary studies explore to use AI models to infer secrets ( Hospodar et al. , 2011 ; Kim et al. , 2019 ; Cagli et al. , 2017 ; Hettwer et al. , 2018 ) , their approaches are primarily driven by classification , i.e. , predicting whether a particular bit of crypto key is 0 or 1 . In contrast , reconstructing user private images requires to synthesize and enhance images from a more holistic perspective . Recent advances in generative models , such as generative adversarial network ( GAN ) and variational autoencoder ( VAE ) , have enabled a major thrust in image reconstruction , given subtle signals in even cross-modal settings , e.g. , voice-to-face or text-to-image ( Radford et al. , 2016 ; Reed et al. , 2016 ; Wen et al. , 2019 ; Hong et al. , 2018b ) . Inspired by this breakthrough , we propose an SCA framework using generative models . Given a trace of side channel data points made by image analysis software ( e.g. , libjpeg ) when processing a user input , we reconstruct an image visually similar to the input . Each logged side channel trace , containing around a million records , is first encoded into a matrix and pre-processed by a convolutional neural network ( CNN ) for feature extraction . Then , a VAE network with a learned prior ( referred to as VAE-LP ) is employed to reconstruct an image with a holistic visual appearance . We further supplement VAE-LP with a GAN model to enhance the recovered image with vivid details . The GAN generator yields the final output . Our attack exploits media libraries , libjpeg ( libjpeg , 2020 ) and uPNG ( Middleditch , 2010 ) , using two popular side channels , CPU cache line accesses and OS page table accesses . Our attack is independent of the underlying computing infrastructure ( i.e. , OS , hardware , image library implementation ) . We require enough side channel logs for training , which is consistently assumed by previous works ( Heuser & Zohner , 2012 ; Maghrebi et al. , 2016 ) . While existing attacks particularly target libjpeg and leverage domain knowledge , system hacking , and manual efforts to infer pixel values ( Xu et al. , 2015 ; Hähnel et al. , 2017 ) , we show that images with many details can be reconstructed in an end-to-end manner . We also show surprising results that enabled by our framework , side channel traces composing one-bit data read/write patterns , which prima facie seems minimally informative , suffice recovering images . We conduct qualitative and quantitative evaluations on specific and general datasets representing daily images that can violate privacy if leaked . The recovered images manifest consistent visual appearances with private inputs . The recovered images also exhibit high discriminability : each recovered image ( e.g. , a face ) can be matched to its reference input among many candidates with high accuracy . In summary , we make the following contributions : At the conceptual level , we present the first generative model-based SCA . Our novel approach learns how program inputs influence system side channels from historical side channel logs to reconstruct user private images automatically . We , for the first time , demonstrate surprisingly effective attacks toward even low-resolution side channels like one-bit data read/write access patterns . At the technical level , we design an effective framework by incorporating various design principles to facilitate image reconstruction from side channels . Our framework pipelines 2D CNN , VAE-LP , and GAN models to systematically enhance the quality of generated images . At the empirical level , our evaluations show that the proposed framework can generate images with vivid details and are closely similar to reference inputs . The reconstructed images show high discriminability , making privacy leakage attacks more practical . This is the first paper to conduct SCA with generative models , revealing new SCA opportunities and unknown threats . Our code is at https : //github.com/genSCA/genSCA . 2 BACKGROUND . To formulate SCA , let the attacked program be P and its input domain be I . For a deterministic and terminating program P , the program execution can be modeled as a mapping P : I → E where E represents program runtime behavior ( e.g. , memory access ) . As a common assumption ( Hähnel et al. , 2017 ) , program inputs are private and profitable for attackers . Since different inputs i , i′ ∈ I can likely induce different e , e′ ∈ E , using input-dependent e ∈ E enables to infer i . Modern computer architectures have primarily zeroed the possibility for adversaries to log e ∈ E. Nevertheless , an attacker ’ s view on P can be modeled as a function view : E → O that maps E to side channel observations O . Hence , the composition ( view ◦ P ) : I → O maps inputs to side channel data points that can be logged by attackers . The view indicates the attacker ’ s capability , and for typical system security scenarios , the view is formulated as view : Emem → Ocache ∪ Opage , where Emem denotes a trace of accessed memory locations when executing P with i , and Ocache andOpage represent CPU cache and OS page table side channels , respectively . Despite being unable to monitor Emem , attackers can log accessed cache lines Ocache or page table entries Opage derived from Emem . Attackers then infer Emem and recover i . We now concretize the procedure by introducing how SCA is used to exploit cloud platforms in a two-step approach as follows : Online Phase to Record O . Considering a cloud environment in Fig . 1 ( a ) , where two users , one normal and one malicious , deploy two virtual machine ( VM ) instances on the host . Private images i ∈ I uploaded by users are processed by media library P within the left VM . Modern computer design , e.g. , Intel SGX ( Intel , 2014 ) , guarantees that i ∈ I and the execution of P can not be viewed from outside the VM . However , when processing i , P usually imposes a large volume of CPU cache and page table accesses , which , as shown in Fig . 1 ( a ) , can be recorded by the co-located malicious VM or the malicious host OS in a fully automated manner ( Han et al. , 2017 ; Chiang et al. , 2015 ; Liu et al. , 2015a ; Xu et al. , 2015 ; Hähnel et al. , 2017 ) . Offline Phase to Infer i . Once side channel traces o ∈ O are collected , an offline phase is conducted to infer ( view ◦P ) −1 : O → I and recover i . Fig . 1 ( b ) presents a sample code , where depending on values of input i , different memory locations ( and cache lines ) will be visited . Fig . 1 ( c ) shows the corresponding trace of logged cache side channel records . To infer i , attackers eliminate the second record ( since it is input-independent ) , and infer i as 1 according to the first record . Attackers anticipate to 1 ) pinpointing a subset of records o∗ ⊆ o that depend on i , and to 2 ) recovering the mapping from o∗ to i . However , real-world side channel traces ( e.g. , generated by uPNG ) could contain over one million records , where only a tiny portion o∗ is input-dependent . Even worse , constructing the mapping between i and o∗ requires a deep understanding of program control flows ( e.g. , how i affects program execution and induces cache accesses in Fig . 1 ( b ) ) . To date , these tasks require either manual effort ( Xu et al. , 2015 ; Hähnel et al. , 2017 ) or formal analysis ( Doychev et al. , 2013 ; Wang et al. , 2017 ; 2019 ) , which are program-specific and error-prone with low scalability . Existing research tackles the offline phase challenge by proposing profiling-based SCA ( Maghrebi et al. , 2016 ; Hettwer et al. , 2018 ; Kim et al. , 2019 ) , where models are trained to approximate ( view◦ P ) −1 : O → I . However , existing work focuses on predicting particular bits of crypto keys from succinct side channel traces , e.g. , a few hundred records ( Hettwer et al. , 2020 ) . In contrast , this is the first work shows that by incorporating generative models , SCA can be conducted to exploit real-world media libraries and holistically reconstruct high-quality and discriminable images . 3 THE PROPOSED FRAMEWORK . A common assumption shared by SCA ( Heuser & Zohner , 2012 ; Hähnel et al. , 2017 ; Xu et al. , 2015 ) is that the attackers can profile the victim software locally or remotely with training inputs and collect corresponding side channel traces . We train a model to learn how different inputs can influence side channel traces . Then , given a side channel trace logged when processing an unknown image , our framework reconstructs an image that is visually similar to the unknown input . Our framework has two pipelined modules ( see Fig . 2 ) . Given a side channel trace Ti corresponding to processing an image i , we first encode Ti into a matrix . The encoded matrix will be fed to the VAE-LP module to generate image îtrace , and we further use GAN to denoise îtrace and yield the final output îGAN . We now elaborate on each module . More details are given in Appendix B . | The authors present a framework that uses a combination of VAE and GAN to recover private user images using Side channel analysis of memory access . A VAE-LP model first reconstructs a coarse image from side channel information which is reshaped and processed using a convolutional network. The output of the VAE-LP model is refined using a GAN to add fine details. Compelling results are demonstrated for recovery of private information and state of art metrics are reported. | SP:b2fc6ca65add04fb32bcf7622d9098de9004ca2b |
DICE: Diversity in Deep Ensembles via Conditional Redundancy Adversarial Estimation | Deep ensembles perform better than a single network thanks to the diversity among their members . Recent approaches regularize predictions to increase diversity ; however , they also drastically decrease individual members ’ performances . In this paper , we argue that learning strategies for deep ensembles need to tackle the trade-off between ensemble diversity and individual accuracies . Motivated by arguments from information theory and leveraging recent advances in neural estimation of conditional mutual information , we introduce a novel training criterion called DICE : it increases diversity by reducing spurious correlations among features . The main idea is that features extracted from pairs of members should only share information useful for target class prediction without being conditionally redundant . Therefore , besides the classification loss with information bottleneck , we adversarially prevent features from being conditionally predictable from each other . We manage to reduce simultaneous errors while protecting class information . We obtain state-of-the-art accuracy results on CIFAR-10/100 : for example , an ensemble of 5 networks trained with DICE matches an ensemble of 7 networks trained independently . We further analyze the consequences on calibration , uncertainty estimation , out-of-distribution detection and online co-distillation . 1 INTRODUCTION . Averaging the predictions of several models can significantly improve the generalization ability of a predictive system . Due to its effectiveness , ensembling has been a popular research topic ( Nilsson , 1965 ; Hansen & Salamon , 1990 ; Wolpert , 1992 ; Krogh & Vedelsby , 1995 ; Breiman , 1996 ; Dietterich , 2000 ; Zhou et al. , 2002 ; Rokach , 2010 ; Ovadia et al. , 2019 ) as a simple alternative to fully Bayesian methods ( Blundell et al. , 2015 ; Gal & Ghahramani , 2016 ) . It is currently the de facto solution for many machine learning applications and Kaggle competitions ( Hin , 2020 ) . Ensembling reduces the variance of estimators ( see Appendix E.1 ) thanks to the diversity in predictions . This reduction is most effective when errors are uncorrelated and members are diverse , i.e. , when they do not simultaneously fail on the same examples . Conversely , an ensemble of M identical networks is no better than a single one . In deep ensembles ( Lakshminarayanan et al. , 2017 ) , the weights are traditionally trained independently : diversity among members only relies on the randomness of the initialization and of the learning procedure . Figure 1 shows that the performance of this procedure quickly plateaus with additional members . To obtain more diverse ensembles , we could adapt the training samples through bagging ( Breiman , 1996 ) and bootstrapping ( Efron & Tibshirani , 1994 ) , but a reduction of training samples has a negative impact on members with multiple local minima ( Lee et al. , 2015 ) . Sequential boosting does not scale well for time-consuming deep learners that overfit their training dataset . Liu & Yao ( 1999a ; b ) ; Brown et al . ( 2005b ) explicitly quantified the diversity and regularized members into having negatively correlated errors . However , these ideas have not significantly improved accuracy when applied to deep learning ( Shui et al. , 2018 ; Pang et al. , 2019 ) : while members should predict the same target , they force disagreements among strong learners and therefore increase their bias . It highlights the main objective and challenge of our paper : finding a training strategy to reach an improved trade-off between ensemble diversity and individual accuracies ( Masegosa , 2020 ) . one input ( , ) should not share more information than features from two inputs in the same class ( , ) : i.e. , ( , - ) should not be able to differentiate ( - , ) and ( - , ) . Our core approach is to encourage all members to predict the same thing , but for different reasons . Therefore the diversity is enforced in the features space and not on predictions . Intuitively , to maximize the impact of a new member , extracted features should bring information about the target that is absent at this time so unpredictable from other members ’ features . It would remove spurious correlations , e.g . information redundantly shared among features extracted by different members but useless for class prediction . This redundancy may be caused by a detail in the image background and therefore will not be found in features extracted from other images belonging to the same class . This could make members predict badly simultaneously , as shown in Figure 2 . Our new learning framework , called DICE , is driven by Information Bottleneck ( IB ) ( Tishby , 1999 ; Alemi et al. , 2017 ) principles , that force features to be concise by forgetting the task-irrelevant factors . Specifically , DICE leverages the Minimum Necessary Information criterion ( Fischer , 2020 ) for deep ensembles , and aims at reducing the mutual information ( MI ) between features and inputs , but also information shared between features . We prevent extracted features from being redundant . As mutual information can detect arbitrary dependencies between random variables ( such as symmetry , see Figure 2 ) , we increase the distance between pairs of members : it promotes diversity by reducing predictions ’ covariance . Most importantly , DICE protects features ’ informativeness by conditioning mutual information upon the target . We build upon recent neural approaches ( Belghazi et al. , 2018 ) based on the Donsker-Varadhan representation of the KL formulation of MI . We summarize our contributions as follows : • We introduce DICE , a new adversarial learning framework to explicitly increase diversity in ensemble by minimizing the conditional redundancy between features . • We rationalize our training objective by arguments from information theory . • We propose an implementation through neural estimation of conditional redundancy . We consistently improve accuracy on CIFAR-10/100 as summarized in Figure 1 , with better uncertainty estimation and calibration . We analyze how the two components of our loss modify the accuracy-diversity trade-off . We improve out-of-distribution detection and online co-distillation . 2 DICE MODEL . Notations Given an input distribution X , a network θ is trained to extract the best possible dense features Z to model the distribution pθ ( Y |X ) over the targets , which should be close to the Dirac on the true label . Our approach is designed for ensembles with M members θi , i ∈ { 1 , . . . , M } extracting Zi . In branch-based setup , members share low-level weights to reduce computation cost . We average the M predictions in inference . We initially consider an ensemble of M = 2 members . Quick overview First , we train each member separately for classification with information bottleneck . Second , we train members together to remove spurious redundant correlations while training adversarially a discriminator . In conclusion , members learn to classify with conditionally uncorrelated features for increased diversity . Our procedure is driven by the following theoretical findings . 2.A DERIVING TRAINING OBJECTIVE 2.A.1 BASELINE : NON-CONDITIONAL OBJECTIVE The Minimum Necessary Information ( MNI ) criterion from ( Fischer , 2020 ) aims at finding minimal statistics . In deep ensembles , Z1 and Z2 should capture only minimal information from X , while preserving the necessary information about the task Y . First , we consider separately the two Markov chains Z1 ← X ↔ Y and Z2 ← X ↔ Y . As entropy measures information , entropy of Z1 and Z2 not related to Y should be minimized . We recover IB ( Alemi et al. , 2017 ) in deep ensembles : IBβib ( Z1 , Z2 ) = 1 βib [ I ( X ; Z1 ) + I ( X ; Z2 ) ] − [ I ( Y ; Z1 ) + I ( Y ; Z2 ) ] = IBβib ( Z1 ) + IBβib ( Z2 ) . Second , let ’ s consider I ( Z1 ; Z2 ) : we minimize it following the minimality constraint of the MNI . IBRβib , δr ( Z1 , Z2 ) = 1 βib Compression︷ ︸︸ ︷ [ I ( X ; Z1 ) + I ( X ; Z2 ) ] − Relevancy︷ ︸︸ ︷ [ I ( Y ; Z1 ) + I ( Y ; Z2 ) ] +δr Redundancy︷ ︸︸ ︷ I ( Z1 ; Z2 ) = IBβib ( Z1 ) + IBβib ( Z2 ) + δrI ( Z1 ; Z2 ) . ( green vertical stripes ) with no overlap with relevancy ( red stripes ) . Analysis In this baseline criterion , relevancy encouragesZ1 and Z2 to capture information about Y . Compression & redundancy ( R ) split the information from X into two compressed & independent views . The relevancy-compressionredundancy trade-off depends on the values of βib & δr . 2.A.2 DICE : CONDITIONAL OBJECTIVE The problem is that the compression and redundancy terms in IBR also reduce necessary information related to Y : it is detrimental to have Z1 and Z2 fully disentangled while training them to predict the same Y . As shown on Figure 3 , redundancy regions ( blue horizontal stripes ) overlap with relevancy regions ( red stripes ) . Indeed , the true constraints that the MNI criterion really entails are the following conditional equalities given Y : I ( X ; Z1|Y ) = I ( X ; Z2|Y ) = I ( Z1 ; Z2|Y ) = 0 . Mutual information being non-negative , we transform them into our main DICE objective : DICEβceb , δcr ( Z1 , Z2 ) = 1βceb [ I ( X ; Z1|Y ) + I ( X ; Z2|Y ) ] ︸ ︷︷ ︸ Conditional Compression − [ I ( Y ; Z1 ) + I ( Y ; Z2 ) ] ︸ ︷︷ ︸ Relevancy +δcr I ( Z1 ; Z2|Y ) ︸ ︷︷ ︸ Conditional Redundancy = CEBβceb ( Z1 ) + CEBβceb ( Z2 ) + δcrI ( Z1 ; Z2|Y ) , ( 1 ) where we recover two conditional entropy bottleneck ( CEB ) ( Fischer , 2020 ) components , CEBβceb ( Zi ) = 1 βceb I ( X ; Zi|Y ) − I ( Y ; Zi ) , with βceb > 0 and δcr > 0 . Analysis The relevancy terms force features to be informative about the task Y . But contrary to IBR , DICE bottleneck constraints only minimize irrelevant information to Y . First , the conditional compression removes in Z1 ( or Z2 ) information from X not relevant to Y . Second , the conditional redundancy ( CR ) reduces spurious correlations between members and only forces them to have independent bias , but definitely not independent features . It encourages diversity without affecting members ’ individual precision as it protects information related to the target class in Z1 and Z2 . Useless information from X to predict Y should certainly not be in Z1 or Z2 , but it is even worse if they are in Z1 and Z2 simultaneously as it would cause simultaneous errors . Even if for i ∈ { 1 , 2 } , reducing I ( Zi , X|Y ) indirectly controls I ( Z1 , Z2|Y ) ( as I ( Z1 ; Z2|Y ) ≤ I ( X ; Zi|Y ) by chain rule ) , it is more efficient to directly target this intersection region through the CR term . In a final word , DICE is to IBR for deep ensembles as CEB is to IB for a single network . We now approximate the two CEB and the CR components in DICE objective from equation 1 . 2.B APPROXIMATING DICE INTO A TRACTABLE LOSS 2.B.1 VARIATIONAL APPROXIMATION OF CONDITIONAL ENTROPY BOTTLENECK We leverage Markov assumptions in Zi ← X ↔ Y , i ∈ { 1 , 2 } and empirically estimate on the classification training dataset of N i.i.d . points D = { xn , yn } Nn=1 , yn ∈ { 1 , . . . , K } . Following Fischer ( 2020 ) , CEBβceb ( Zi ) = 1 βceb I ( X ; Zi|Y ) − I ( Y ; Zi ) is variationally upper bounded by : VCEBβceb ( { ei , bi , ci } ) = 1 N N∑ n=1 1 βceb DKL ( ei ( z|xn ) ‖bi ( z|yn ) ) − E [ log ci ( yn|ei ( xn , ) ) ] . ( 2 ) See explanation in Appendix E.4 . ei ( z|x ) is the true features distribution generated by the encoder , ci ( y|z ) is a variational approximation of true distribution p ( y|z ) by the classifier , and bi ( z|y ) is a variational approximation of true distribution p ( z|y ) by the backward encoder . This loss is applied separately on each member θi = { ei , ci , bi } , i ∈ { 1 , 2 } . Practically , we parameterize all distributions with Gaussians . The encoder ei is a traditional neural network features extractor ( e.g . ResNet-32 ) that learns distributions ( means and covariances ) rather than deterministic points in the features space . That ’ s why ei transforms an image into 2 tensors ; a features-mean eµi ( x ) and a diagonal features-covariance e σ i ( x ) each of size d ( e.g . 64 ) . The classifier ci is a dense layer that transforms a features-sample z into logits to be aligned with the target y through conditional cross entropy . z is obtained via reparameterization trick : z = ei ( x , ) = eµi ( x ) + e σ i ( x ) with ∼ N ( 0 , 1 ) . Finally , the backward encoder bi is implemented as an embedding layer of size ( K , d ) that maps the K classes to class-features-means bµi ( z|y ) of size d , as we set the class-features-covariance to 1 . The Gaussian parametrization also enables the exact computation of the DKL ( see Appendix E.3 ) , that forces ( 1 ) features-mean e µ i ( x ) to converge to the class-featuresmean bµi ( z|y ) and ( 2 ) the predicted features-covariance eσi ( x ) to be close to 1 . The advantage of VCEB versus VIB ( Alemi et al. , 2017 ) is the class conditional bµi ( z|y ) versus non-conditional bµi ( z ) which protects class information . 2.B.2 ADVERSARIAL ESTIMATION OF CONDITIONAL REDUNDANCY Theoretical Problem We now focus on estimating I ( Z1 ; Z2|Y ) , with no such Markov properties . Despite being a pivotal measure , mutual information estimation historically relied on nearest neighbors ( Singh et al. , 2003 ; Kraskov et al. , 2004 ; Gao et al. , 2018 ) or density kernels ( Kandasamy et al. , 2015 ) that do not scale well in high dimensions . We benefit from recent advances in neural estimation of mutual information ( Belghazi et al. , 2018 ) , built on optimizing Donsker & Varadhan ( 1975 ) dual representations of the KL divergence . Mukherjee et al . ( 2020 ) extended this formulation for conditional mutual information estimation . CR = I ( Z1 ; Z2|Y ) = DKL ( P ( Z1 , Z2 , Y ) ‖P ( Z1 , Y ) p ( Z2|Y ) ) = sup f Ex∼p ( z1 , z2 , y ) [ f ( x ) ] − log ( Ex∼p ( z1 , y ) p ( z2|y ) [ exp ( f ( x ) ) ] ) = Ex∼p ( z1 , z2 , y ) [ f∗ ( x ) ] − log ( Ex∼p ( z1 , y ) p ( z2|y ) [ exp ( f∗ ( x ) ) ] ) , where f∗ computes the pointwise likelihood ratio , i.e. , f∗ ( z1 , z2 , y ) = p ( z1 , z2 , y ) p ( z1 , y ) p ( z2|y ) . Empirical Neural Estimation We estimate CR ( 1 ) using the empirical data distribution and ( 2 ) replacing f∗ = w ∗ 1−w∗ by the output of a discriminator w , trained to imitate the optimal w ∗ . Let B be a batch sampled from the observed joint distribution p ( z1 , z2 , y ) = p ( e1 ( z|x ) , e2 ( z|x ) , y ) ; we select the features extracted by the two members from one input . Let Bp be sampled from the product distribution p ( z1 , y ) p ( z2|y ) = p ( e1 ( z|x ) , y ) p ( z2|y ) ; we select the features extracted by the two members from two different inputs that share the same class . We train a multi-layer network w on the binary task of distinguishing these two distributions with the standard cross-entropy loss : Lce ( w ) = − 1 |B|+ |Bp| ∑ ( z1 , z2 , y ) ∈B logw ( z1 , z2 , y ) + ∑ ( z1 , z′2 , y ) ∈Bp log ( 1− w ( z1 , z′2 , y ) ) . ( 3 ) If w is calibrated ( see Appendix B.3 ) , a consistent ( Mukherjee et al. , 2020 ) estimate of CR is : ÎCRDV = 1 |B| ∑ ( z1 , z2 , y ) ∈B log f ( z1 , z2 , y ) ︸ ︷︷ ︸ Diversity − log 1 |Bp| ∑ ( z1 , z′2 , y ) ∈Bp f ( z1 , z ′ 2 , y ) ︸ ︷︷ ︸ Fake correlations , with f = w 1− w . Intuition By training our members to minimize ÎCRDV , we force triples from the joint distribution to be indistinguishable from triples from the product distribution . Let ’ s imagine that two features are conditionally correlated , some spurious information is shared between features only when they are from the same input and not from two inputs ( from the same class ) . This correlation can be informative about a detail in the background , an unexpected shape in the image , that is rarely found in samples from this input ’ s class . In that case , the product and joint distributions are easily distinguishable by the discriminator . The first adversarial component will force the extracted features to reduce the correlation , and ideally one of the two features loses this information : it reduces redundancy and increases diversity . The second term would create fake correlations between features from different inputs . As we are not interested in a precise estimation of the CR , we get rid of this second term that , empirically , did not increase diversity , as detailed in Appendix G. L̂CRDV ( e1 , e2 ) = 1 |B| ∑ ( z1 , z2 , y ) ∈B∼p ( e1 ( z|x ) , e2 ( z|x ) , y ) log f ( z1 , z2 , y ) . ( 4 ) Summary First , we train each member for classification with VCEB from equation 2 , as shown in Step 1 from Figure 4 . Second , as shown in Step 2 from Figure 4 , the discriminator , conditioned on the class Y , learns to distinguish features sampled from one image versus features sampled from two images belonging to Y . Simultaneously , both members adversarially ( Goodfellow et al. , 2014 ) delete spurious correlations to reduce CR estimation from equation 4 with differentiable signals : it conditionally aligns features . We provide a pseudo-code in B.4 . While we derive similar losses for IBR and CEBR in Appendix E.5 , the full DICE loss is finally : LDICE ( θ1 , θ2 ) = VCEBβceb ( θ1 ) + VCEBβceb ( θ2 ) + δcrL̂CRDV ( e1 , e2 ) . ( 5 ) 2.C FULL PROCEDURE WITH M MEMBERS We expand our objective for an ensemble with M > 2 members . We only consider pairwise interactions for simplicity to keep quadratic rather than exponential growth in number of components and truncate higher order interactions , e.g . I ( Zi ; Zj , Zk|Y ) ( see Appendix F.1 ) . Driven by previous variational and neural estimations , we train θi = { ei , bi , ci } , i ∈ { 1 , . . . , M } on : LDICE ( θ1 : M ) = M∑ i=1 VCEBβceb ( θi ) + δcr ( M − 1 ) M∑ i=1 M∑ j=i+1 L̂CRDV ( ei , ej ) , ( 6 ) while training adversariallyw on Lce . Batch B is sampled from the concatenation of joint distribution p ( zi , zj , y ) where i , j ∈ { 1 , . . . , M } , i 6= j , while Bp is sampled from the product distribution , p ( zi , y ) p ( zj |y ) . We use the same discriminator w for ( M 2 ) estimates . It improves scalability by reducing the number of parameters to be learned . Indeed , an additional member in the ensemble only adds 256 ∗ d trainable weights in w , where d is the features dimension . See Appendix B.3 for additional information related to the discriminator w . | This paper proposes a method of learning ensembles that adhere to an "ensemble version" of the information bottleneck principle. Whereas the information bottleneck principle says the representation should avoid spurious correlations between the representation (Z) and the training data (X) that is not useful for predicting the labels (Y), i.e. I(X;Z) or I(X;Z|Y), this paper proposes that ensembles should additionally avoid spurious correlations between the ensemble members that aren't useful for predicting Y, i.e. I(Z_i; Z_j| Y). They show empirically that the coefficient on this term increases diversity at the expense of decreasing accuracy of individual members of the ensemble. | SP:7fb11c941e8d79248ce5ff7caa0535a466303395 |
Zero-shot Synthesis with Group-Supervised Learning | 1 INTRODUCTION . Primates perform well at generalization tasks . If presented with a single visual instance of an object , they often immediately can generalize and envision the object in different attributes , e.g. , in different 3D pose ( Logothetis et al. , 1995 ) . Primates can readily do so , as their previous knowledge allows them to be cognizant of attributes . Machines , by contrast , are most-commonly trained on sample features ( e.g. , pixels ) , not taking into consideration attributes that gave rise to those features . To aid machine cognition of visual object attributes , a class of algorithms focuses on learning disentangled representations ( Kingma & Welling , 2014 ; Higgins et al. , 2017 ; Burgess et al. , 2018 ; Kim & Mnih , 2018 ; Chen et al. , 2018 ) , which map visual samples onto a latent space that separates the information belonging to different attributes . These methods show disentanglement by interpolating between attribute values ( e.g. , interpolate pose , etc ) . However , these methods usually process one sample at a time , rather than contrasting or reasoning about a group of samples . We posit that semantic links across samples could lead to better learning . We are motivated by the visual generalization of primates . We seek a method that can synthesize realistic images for arbitrary queries ( e.g. , a particular car , in a given pose , on a given background ) , which we refer to as controlled synthesis . We design a method that enforces semantic consistency of attributes , facilitating controlled synthesis by leveraging semantic links between samples . Our method maps samples onto a disentangled latent representation space that ( i ) consists of subspaces , each encoding one attribute ( e.g. , identity , pose , ... ) , and , ( ii ) is such that two visual samples that share an attribute value ( e.g. , both have identity “ car ” ) have identical latent values in the shared attribute subspace ( identity ) , even if other attribute values ( e.g. , pose ) differ . To achieve this , we propose a general learning framework : Group Supervised Learning ( GSL , Sec . 3 ) , which provides a learner ( e.g. , neural network ) with groups of semantically-related training examples , represented as multigraph . Given a query of attributes , GSL proposes groups of training examples with attribute combinations that are useful for synthesizing a test example satisfying the query ( Fig . 1 ) . This endows the network with an envisioning capability . In addition to applications in graphics , controlled synthesis can also augment training sets for better generalization on machine learning tasks ( Sec . 6.3 ) . As an instantiation of GSL , we propose an encoder-decoder network for zero-shot synthesis : GroupSupervised Zero-Shot Synthesis Network ( GZS-Net , Sec . 4 ) . While learning ( Sec . 4.2 & 4.3 ) , we repeatedly draw a group of semantically-related examples , as informed by a multigraph created by GSL . GZS-Net encodes group examples , to obtain latent vectors , then swaps entries for one or more attributes in the latent space across examples , through multigraph edges , then decodes into an example within the group ( Sec . 4.2 ) . Our contributions are : ( i ) We propose Group-Supervised Learning ( GSL ) , explain how it casts its admissible datasets into a multigraph , and show how it can be used to express learning from semantically-related groups and to synthesize samples with controllable attributes ; ( ii ) We show one instantiation of GSL : Group-supervised Zero-shot Synthesis Network ( GZS-Net ) , trained on groups of examples and reconstruction objectives ; ( iii ) We demonstrate that GZS-Net trained with GSL outperforms state-of-the-art alternatives for controllable image synthesis on existing datasets ; ( iv ) We provide a new dataset , Fonts1 , with its generating code . It contains 1.56 million images and their attributes . Its simplicity allows rapid idea prototyping for learning disentangled representations . 2 RELATED WORK . We review research areas , that share similarities with our work , to position our contribution . Self-Supervised Learning ( e.g. , Gidaris et al . ( 2018 ) ) admits a dataset containing features of training samples ( e.g. , upright images ) and maps it onto an auxiliary task ( e.g. , rotated images ) : dataset examples are drawn and a random transformation ( e.g. , rotate 90◦ ) is applied to each . The task could be to predict the transformation ( e.g. , =90◦ ) from the transformed features ( e.g. , rotated image ) . Our approach is similar , in that it also creates auxiliary tasks , however , the tasks we create involve semantically-related group of examples , rather than from one example at a time . Disentangled Representation Learning are methods that infer latent factors given example visible features , under a generative assumption that each latent factor is responsible for generating one semantic attribute ( e.g . color ) . Following Variational Autoencoders ( VAEs , Kingma & Welling , 2014 ) , a class of models ( including , Higgins et al. , 2017 ; Chen et al. , 2018 ) achieve disentanglement implicitly , by incorporating into the objective , a distance measure e.g . KL-divergence , encouraging the latent factors to be statistically-independent . While these methods can disentangle the factors without knowing them beforehand , unfortunately , they are unable to generate novel combinations not witnessed during training ( e.g. , generating images of red car , without any in training ) . On the other hand , our method requires knowing the semantic relationships between samples ( e.g. , which objects are of same identity and/or color ) , but can then synthesize novel combinations ( e.g. , by stitching latent features of “ any car ” plus “ any red object ” ) . Conditional synthesis methods can synthesize a sample ( e.g. , image ) and some use information external to the synthesized modalities , e.g. , natural language sentence Zhang et al . ( 2017 ) ; Hong et al . 1http : //ilab.usc.edu/datasets/fonts ( 2018 ) or class label Mirza & Osindero ( 2014 ) ; Tran et al . ( 2017 ) . Ours differ , in that our “ external information ” takes the form of semantic relationships between samples . There are methods based on GAN Goodfellow et al . ( 2014 ) that also utilize semantic relationships including Motion Re-targeting ( Yang et al. , 2020 ) , which unfortunately requires domain-specific hand-engineering ( detect and track human body parts ) . On the other hand , we design and apply our method on different tasks ( including people faces , vehicles , fonts ; see Fig . 1 ) . Further , we compare against two recent GAN methods starGAN ( Choi et al. , 2018 ) and ELEGANT ( Xiao et al. , 2018 ) , as they are state-of-the-art GAN methods for amending visual attributes onto images . While they are powerful in carrying local image transformations ( within a small patch , e.g. , changing skin tone or hair texture ) . However , our method better maintains global information : when rotating the main object , the scene also rotates with it , in a semantically coherent manner . Importantly , our learning framework allows expressing simpler model network architectures , such as feed-forward auto-encoders , trained with only reconstruction objectives , as opposed to GANs , with potential difficulties such as lack of convergence guarantees . Zero-shot learning also consumes side-information . For instance , models of Lampert ( 2009 ) ; Atzmon & Chechik ( 2018 ) learn from object attributes , like our method . However , ( i ) these models are supervised to accurately predict attributes , ( ii ) they train and infer one example at a time , and ( iii ) they are concerned with classifying unseen objects . We differ in that ( i ) no learning gradients ( supervision signal ) are derived from the attributes , as ( ii ) these attributes are used to group the examples ( based on shared attribute values ) , and ( iii ) we are concerned with generation rather than classification : we want to synthesize an object in previously-unseen attribute combinations . Graph Neural Networks ( GNNs ) ( Scarselli et al. , 2009 ) are a class of models described on graph structured data . This is applicable to our method , as we propose to create a multigraph connecting training samples . In fact , our method can be described as a GNN , with message passing functions ( Gilmer et al. , 2017 ) that are aware of the latent space partitioning per attribute ( explained in Sec . 4 ) . Nonetheless , for self-containment , we introduce our method in the absence of the GNN framework . 3 GROUP-SUPERVISED LEARNING . 3.1 DATASETS ADMISSIBLE BY GSL . Formally , a dataset admissible by GSL containing n samples D = { x ( i ) } ni=1 where each example is accompanied with m attributes Da = { ( a ( i ) 1 , a ( i ) 2 , . . . a ( i ) m ) } ni=1 . Each attribute value is a member of a countable set : aj ∈ Aj . For instance , pertaining to visual scenes , A1 can denote foreground-colors A1 = { red , yellow , . . . } , A2 could denote background colors , A3 could correspond to foreground identity , A4 to ( quantized ) orientation . Such datasets have appeared in literature , e.g . in Borji et al . ( 2016 ) ; Matthey et al . ( 2017 ) ; Langner et al . ( 2010 ) ; Lai et al . ( 2011 ) . 3.2 AUXILIARY TASKS VIA MULTIGRAPHS . Given a dataset of n samples and their attributes , we define a multigraph M with node set [ 1 .. n ] . Two nodes , i , k ∈ [ 1 .. n ] with i 6= k are connected with edge labels M ( i , k ) ⊆ [ 1 .. m ] as : M ( i , k ) = { j ∣∣∣ a ( i ) j = a ( k ) j ; j ∈ [ 1 .. m ] } . In particular , M defines a multigraph , with |M ( i , k ) | denoting the number of edges connecting nodes i and k , which is equals the number of their shared attributes . Fig . 2 depicts a ( sub- ) multigraph for the Fonts dataset ( Sec . 5.1 ) . Definition 1 COVER ( S , i ) : Given node set S ⊆ [ 1 .. |Dg| ] and node i ∈ [ 1 .. |Dg| ] we say set S covers node i if every attribute value of i is in at least one member of S. Formally : COVER ( S , i ) ⇐⇒ [ 1 .. m ] = ⋃ k∈S M ( i , k ) . ( 1 ) When COVER ( S , i ) holds , there are two mutually-exclusive cases : either i ∈ S , or i /∈ S , respectively shaded as green and blue in Fig . 2 ( b ) . The first case trivially holds even for small S , e.g . COVER ( { i } , i ) holds for all i . However , we are interested in non-trivial sets where |S| > 1 , as sets with |S| = 1 would cast our proposed network ( Sec . 4 ) to a standard Auto-Encoder . The second case is crucial for zero-shot synthesis . Suppose the ( image ) features of node i ( in Fig . 2 ( b ) ) are not given , we can search for S1 , under the assumption that if COVER ( S1 , i ) holds , then S1 contains sufficient information to synthesize i ’ s features as they are not given ( i /∈ S1 ) . Until this point , we made no assumptions how the pairs ( S , i ) are extracted ( mined ) from the multigraph s.t . COVER ( S , i ) holds . In the sequel , we train with |S| = 2 and i ∈ S. We find that this particular specialization of GSL is easy to program , and we leave-out analyzing the impact of mining different kinds of cover sets for future work . | The paper proposed a new training framework, namely GSL, for novel content synthesis. And GSL enables learning of disentangled representations of tangible attributes and achieve novel image synthesis by recombining those swappable components under a zero-shot setting. The framework leverages the underlying semantic links across samples which could be instantiated as a multigraph. Cycle-consistent reconstruction loss as well as reconstruction loss are computed on synthetic samples from swapped latent representations. | SP:5561773ab024b083be4e362db079e371abf79653 |
Asymmetric self-play for automatic goal discovery in robotic manipulation | 1 INTRODUCTION . We are motivated to train a single goal-conditioned policy ( Kaelbling , 1993 ) that can solve any robotic manipulation task that a human may request in a given environment . In this work , we make progress towards this goal by solving a robotic manipulation problem in a table-top setting where the robot ’ s task is to change the initial configuration of a variable number of objects on a table to match a given goal configuration . This problem is simple in its formulation but likely to challenge a wide variety of cognitive abilities of a robot as objects become diverse and goals become complex . Motivated by the recent success of deep reinforcement learning for robotics ( Levine et al. , 2016 ; Gu et al. , 2017 ; Hwangbo et al. , 2019 ; OpenAI et al. , 2019a ) , we tackle this problem using deep reinforcement learning on a very large training distribution . An open question in this approach is how we can build a training distribution rich enough to achieve generalization to many unseen manipulation tasks . This involves defining both an environment ’ s initial state distribution and a goal distribution . The initial state distribution determines how we sample a set of objects and their configuration at the beginning of an episode , and the goal distribution defines how we sample target states given an initial state . In this work , we focus on a scalable way to define a rich goal distribution . The research community has started to explore automated ways of defining goal distributions . For example , previous works have explored learning a generative model of goal distributions ( Florensa et al. , 2018 ; Nair et al. , 2018b ; Racaniere et al. , 2020 ) and collecting teleoperated robot trajectories to identify goals ( Lynch et al. , 2020 ; Gupta et al. , 2020 ) . In this paper , we extend an alternative approach called asymmetric self-play ( Sukhbaatar et al. , 2018b ; a ) for automated goal generation . Asymmetric self-play trains two RL agents named Alice and Bob . Alice learns to propose goals that Bob is likely to fail at , and Bob , a goal-conditioned policy , learns to solve the proposed goals . Alice proposes a goal by manipulating objects and Bob has to solve the goal starting from the same initial state as Alice ’ s . By embodying these two agents into the same robotic hardware , this setup ensures that all proposed goals are provided with at least one solution : Alice ’ s trajectory . There are two main reasons why we consider asymmetric self-play to be a promising goal generation and learning method . First , any proposed goal is achievable , meaning that there exists at least one solution trajectory that Bob can follow to achieve the goal . Because of this property , we can exploit Alice ’ s trajectory to provide additional learning signal to Bob via behavioral cloning . This additional learning signal alleviates the overhead of heuristically designing a curriculum or reward shaping for learning . Second , this approach does not require labor intensive data collection . In this paper , we show that asymmetric self-play can be used to train a goal-conditioned policy for complex object manipulation tasks , and the learned policy can zero-shot generalize to many manually designed holdout tasks , which consist of either previously unseen goals , previously unseen objects , or both . To the best of our knowledge , this is the first work that presents zero-shot generalization to many previously unseen tasks by training purely with asymmetric self-play.1 2 PROBLEM FORMULATION . Our training environment for robotic manipulation consists of a robot arm with a gripper attached and a wide range of objects placed on a table surface ( Figure 1a,1b ) . The goal-conditioned policy learns to control the robot to rearrange randomly placed objects ( the initial state ) into a specified goal configuration ( Figure 1c ) . We aim to train a policy on a single training distribution and to evaluate its performance over a suite of holdout tasks which are independently designed and not explicitly present during training ( Figure 2a ) . In this work , we construct the training distribution via asymmetric self-play ( Figure 2b ) to achieve generalization to many unseen holdout tasks ( Figure 1c ) . Mathematical formulation Formally , we model the interaction between an environment and a goal-conditioned policy as a goal-augmented Markov decision process M = hS , A , P , R , Gi , where S is the state space , A is the action space , P : S ⇥ A ⇥ S 7 ! R denotes the transition probability , G ✓ S specifies the goal space and R : S ⇥ G 7 ! R is a goal-specific reward function . A goalaugmented trajectory sequence is { ( s0 , g , a0 , r0 ) , . . . , ( st , g , at , rt ) } , where the goal is provided to the policy as part of the observation at every step . We say a goal is achieved if st is sufficiently close to g ( Appendix A.2 ) . With a slightly overloaded notation , we define the goal distribution G ( g|s0 ) as the probability of a goal state g 2 G conditioned on an initial state s0 2 S . 1Asymmetric self-play is proposed in Sukhbaatar et al . ( 2018b ; a ) , but to supplement training while the majority of training is conducted on target tasks . Zero-shot generalization to unseen tasks was not evaluated . Training goal distribution A naive design of the goal distribution G ( g|s0 ) is to randomly place objects uniformly on the table , but it is unlikely to generate interesting goals , such as an object picked up and held above the table surface by a robot gripper . Another possible approach , collecting tasks and goals manually , is expensive and hard to scale . We instead sidestep these issues and automatically generate goals via training based on asymmetric self-play ( Sukhbaatar et al. , 2018b ; a ) . Asymmetric self-play involves using a policy named Alice ⇡A ( a|s ) to set goals and a goal-conditioned policy Bob ⇡B ( a|s , g ) to solve goals proposed by Alice , as illustrated in Figure 2b . We run ⇡A to generate a trajectory ⌧A = { ( s0 , a0 , r0 ) , . . . , ( sT , aT , rT ) } and the last state is labelled as a goal g for ⇡B to solve . The goal distribution G ( sT = g|s0 ) is fully determined by ⇡A and we train Bob only on this goal distribution . We therefore say zero-shot generalization when Bob generalizes to a holdout task which is not explicitly encoded into the training distribution . Evaluation on holdout tasks To assess zero-shot generalization of ⇡B ( a|s , g ) from our training setup , we hand-designed a suite of holdout tasks with goals that are never directly incorporated into the training distribution . Some holdout tasks also feature previously unseen objects . The holdout tasks are designed to either test whether a specific skill has been learned , such as the ability to pick up objects ( Figure 3 ) , or represent a semantically interesting task , such as setting a table ( Figure 1c ) . Appendix B.6 describes the list of holdout tasks that we use in our experiments . Note that none of the holdout tasks are used for training ⇡B ( a|s , g ) . 3 ASYMMETRIC SELF-PLAY . To train Alice policy ⇡A ( a|s ) and Bob policy ⇡B ( a|s , g ) , we run the following multi-goal game within one episode , as illustrated in Figure 2b : 1 . An initial state s0 is sampled from an initial state distribution . Alice and Bob are instantiated into their own copies of the environment . Alice and Bob alternate turns as follows . 2 . Alice ’ s turn . Alice interacts with its environment for a fixed number of T steps and may rearrange the objects . The state at the end of Alice ’ s turn sT will be used as a goal g for Bob . If the proposed goal is invalid ( e.g . if Alice has not moved any objects , or if an object has fallen off the table ) , the episode terminates . 3 . Bob ’ s turn . Bob receives reward if it successfully achieves the goal g in its environment . Bob ’ s turn ends when it succeeds at achieving the goal or reaches a timeout . If Bob ’ s turn ends in a failure , its remaining turns are skipped and treated as failures , while we let Alice to keep generating goals . 4 . Alice receives reward if Bob fails to solve the goal that Alice proposed . Steps 2–3 are repeated until 5 goals are set by Alice or Alice proposes an invalid goal , and then the episode terminates . The competition created by this game encourages Alice to propose goals that are increasingly challenging to Bob , while Bob is forced to solve increasingly complex goals . The multi-goal setup was chosen to allow Bob to take advantage of environmental information discovered earlier in the episode to solve its remaining goals , which OpenAI et al . ( 2019a ) found to be important for transfer to physical systems . Note however that in this work we focus on solving goals in simulation only . To improve stability and avoid forgetting , we have Alice and Bob play against past versions of their respective opponent in 20 % of games . More details about the game structure and pseudocode for training with asymmetric self-play are available in Appendix A . 3.1 REWARD STRUCTURE . For Bob , we assign sparse goal-conditioned rewards . We measure the positional and rotational distance between an object and its goal state as the Euclidean distance and the Euler angle rotational distance , respectively . Whenever both distance metrics are below a small error ( the success threshold ) , this object is deemed to be placed close enough to the goal state and Bob receives 1 reward immediately . But if this object is moved away from the goal state that it has arrived at in past steps , Bob obtains -1 reward such that the sum of per-object reward is at most 1 during a given turn . When all of the objects are in their goal state , Bob receives 5 additional reward and its turn is over . For Alice , we assign a reward after Bob has attempted to solve the goal : 5 reward if Bob failed at solving the goal , and 0 if Bob succeeded . We shape Alice ’ s reward slightly by adding 1 reward if it has set a valid goal , defined to be when no object has fallen off the table and any object has been moved more than the success threshold . An additional penalty of 3 reward is introduced when Alice sets a goal with objects outside of the placement area , defined to be a fixed 3D volume within the view of the robot ’ s camera . More details are discussed in Appendix A.2 . 3.2 ALICE BEHAVIORAL CLONING ( ABC ) . One of the main benefits of using asymmetric self-play is that the generated goals come with at least one solution to achieve it : Alice ’ s trajectory . Similarly to Sukhbaatar et al . ( 2018a ) , we exploit this property by training Bob with Behavioral Cloning ( BC ) from Alice ’ s trajectory , in addition to the reinforcement learning ( RL ) objective . We call this learning mechanism Alice Behavioral Cloning ( ABC ) . We propose several improvements over the original formulation in Sukhbaatar et al . ( 2018a ) . Demonstration trajectory filtering Compared to BC from expert demonstrations , using Alice ’ s trajectory needs extra care . Alice ’ s trajectory is likely to be suboptimal for solving the goal , as Alice might arrive at the final state merely by accident . Therefore , we only consider trajectories with goals that Bob failed to solve as demonstrations , to avoid distracting Bob with suboptimal examples . Whenever Bob fails , we relabel Alice ’ s trajectory ⌧A to be a goal-augmented version ⌧BC = { ( s0 , sT , a0 , r0 ) , . . . , ( sT , sT , aT , rT ) } as a demonstration for BC , where sT is the goal . PPO-style BC loss clipping The objective for training Bob is L = LRL + Labc , where LRL is an RL objective and Labc is the ABC loss . is a hyperparameter controlling the relative importance of the BC loss . We set = 0.5 throughout the whole experiment . A naive BC loss is to minimize the negative log-likelihood of demonstrated actions , E ( st , gt , at ) 2DBC ⇥ log ⇡B ( at|st , gt ; ✓ ) ⇤ where DBC is a mini-batch of demonstration data and ⇡B is parameterized by ✓ . We found that overly-aggressive policy changes triggered by BC sometimes led to learning instabilities . To prevent the policy from changing too drastically , we introduce PPO-style loss clipping ( Schulman et al. , 2017 ) on the BC loss by setting the advantage  = 1 in the clipped surrogate objective : Labc = E ( st , gt , at ) 2DBC clip ⇣ ⇡B ( at|st , gt ; ✓ ) ⇡B ( at|st , gt ; ✓old ) , 1 ✏ , 1 + ✏ ⌘ where ⇡B ( at|st , gt ; ✓ ) is Bob ’ s likelihood on a demonstration based on the parameters that we are optimizing , and ⇡B ( at|st , gt ; ✓old ) is the likelihood based on Bob ’ s behavior policy ( at the time of demonstration collection ) evaluated on a demonstration . This behavior policy is identical to the policy that we use to collect RL trajectories . By setting  = 1 , this objective optimizes the naive BC loss , but clips the loss whenever ⇡B ( at|st , gt ; ✓ ) ⇡B ( at|st , gt ; ✓old ) is bigger than 1 + ✏ , to prevent the policy from changing too much . ✏ is a clipping threshold and we use ✏ = 0.2 in all the experiments . | This paper presents an approach to learn goal conditioned policies by relying on self-play which sets the goals and discovers a curriculum of tasks for learning. Alice and Bob are the agents. Alice's task is to set a goal by following a number of steps in the environment and she is rewarded when the goal is too challenging for Bob to solve. Bob's task is to solve the task by trying to reproduce the end state of Alice's demonstration. As a result, the learned policy performs various tasks and can work in zero-shot settings. | SP:9f70871f0111b58783f731748d8750c635998f32 |
Transfer Learning of Graph Neural Networks with Ego-graph Information Maximization | 1 Introduction . Graph neural networks ( GNNs ) have been intensively studied recently [ 29 , 26 , 39 , 68 ] , due to their established performance towards various real-world tasks [ 15 , 69 , 53 ] , as well as close connections to spectral graph theory [ 12 , 9 , 16 ] . While most GNN architectures are not very complicated , the training of GNNs can still be costly regarding both memory and computation resources on real-world large-scale graphs [ 10 , 63 ] . Moreover , it is intriguing to transfer learned structural information across different graphs and even domains in settings like few-shot learning [ 56 , 44 , 25 ] . Therefore , several very recent studies have been conducted on the transferability of GNNs [ 21 , 23 , 22 , 59 , 31 , 3 , 47 ] . However , it is unclear in what situations the models will excel or fail especially when the pre-training and fine-tuning tasks are different . To provide rigorous analysis and guarantee on the transferability of GNNs , we focus on the setting of direct-transfering between the source and target graphs , under an analogous setting of “ domain adaptation ” [ 7 , 59 ] . In this work , we establish a theoretically grounded framework for the transfer learning of GNNs , and leverage it to design a practically transferable GNN model . Figure 1 gives an overview of our framework . It is based on a novel view of a graph as samples from the joint distribution of its k-hop ego-graph structures and node features , which allows us to define graph information and similarity , ∗These two authors contribute equally . 1Code and processed data are available at https : //github.com/GentleZhu/EGI . 35th Conference on Neural Information Processing Systems ( NeurIPS 2021 ) , Online . so as to analyze GNN transferability ( §3 ) . This view motivates us to design EGI , a novel GNN training objective based on ego-graph information maximization , which is effective in capturing the graph information as we define ( §3.1 ) . Then we further specify the requirement on transferable node features and analyze the transferability of EGI that is dependent on the local graph Laplacians of source and target graphs ( §3.2 ) . All of our theoretical conclusions have been directly validated through controlled synthetic experiments ( Table 1 ) , where we use structural-equivalent role identification in an direct-transfering setting to analyze the impacts of different model designs , node features and source-target structure similarities on GNN transferability . In §4 , we conduct real-world experiments on multiple publicly available network datasets . On the Airport and Gene graphs ( §4.1 ) , we closely follow the settings of our synthetic experiments and observe consistent but more detailed results supporting the design of EGI and the utility of our theoretical analysis . On the YAGO graphs ( §4.2 ) , we further evaluate EGI on the more generalized and practical setting of transfer learning with task-specific fine-tuning . We find our theoretical insights still indicative in such scenarios , where EGI consistently outperforms state-of-the-art GNN representation and transfer learning frameworks with significant margins . 2 Related Work . Representation learning on graphs has been studied for decades , with earlier spectral-based methods [ 6 , 46 , 52 ] theoretically grounded but hardly scaling up to graphs with over a thousand of nodes . With the emergence of neural networks , unsupervised network embedding methods based on the Skip-gram objective [ 37 ] have replenished the field [ 51 , 14 , 42 , 45 , 66 , 62 , 65 ] . Equipped with efficient structural sampling ( random walk , neighborhood , etc . ) and negative sampling schemes , these methods are easily parallelizable and scalable to graphs with thousands to millions of nodes . However , these models are essentially transductive as they compute fully parameterized embeddings only for nodes seen during training , which are impossible to be transfered to unseen graphs . More recently , researchers introduce the family of graph neural networks ( GNNs ) that are capable of inductive learning and generalizing to unseen nodes given meaningful node features [ 29 , 12 , 15 , 67 ] . Yet , most existing GNNs require task-specific labels for training in a semi-supervised fashion to achieve satisfactory performance [ 29 , 15 , 53 , 64 ] , and their usage is limited to single graphs where the downstream task is fixed . To this end , several unsupervised GNNs are presented , such as the auto-encoder-based ones like VGAE [ 28 ] and GNFs [ 35 ] , as well as the deep-infomax-based ones like DGI [ 54 ] and InfoGraph [ 50 ] . Their potential in the transfer learning of GNN remains unclear when the node features and link structures vary across different graphs . Although the architectures of popular GNNs such as GCN [ 29 ] may not be very complicated compared with heavy vision and language models , training a dedicated GNN for each graph can still be cumbersome [ 10 , 63 ] . Moreover , as pre-training neural networks are proven to be successful in other domains [ 13 , 18 ] , the idea is intriguing to transfer well-trained GNNs from relevant source graphs to improve the modeling of target graphs or enable few-shot learning [ 59 , 31 , 3 ] when labeled data are scarce . In light of this , pioneering works have studied both generative [ 22 ] and discriminative [ 21 , 23 ] GNN pre-training schemes . Though Graph Contrastive Coding [ 43 ] shares the most similar view towards graph structures as us , it utilizes contrastive learning across all graphs instead of focusing on the transfer learning between any specific pairs . On the other hand , unsupervised domain adaptive GCNs [ 59 ] study the domain adaption problem only when the source and target tasks are homogeneous . Most previous pre-training and self-supervised GNNs lack a rigorous analysis towards their transferability and thus have unpredictable effectiveness . The only existing theoretical work on GNN transferability studies the performance of GNNs across different permutations of a single original graph [ 33 , 34 ] and the tradeoff between discriminability and transferability of GNNs [ 47 ] . We , instead , are the first to rigorously study the more practical setting of transferring GNNs across pairs of different source and target graphs . 3 Transferable Graph Neural Networks . In this paper , we design a more transferable training objective for GNN ( EGI ) based on our novel view of essential graph information ( §3.1 ) . We then analyze its transferability as the gap between its abilities to model the source and target graphs , based on their local graph Laplacians ( §3.2 ) . Based on the connection between GNN and spectral graph theory [ 29 ] , we describe the output of a GNN as a combination of its input node features X , fixed graph Laplacian L and learnable graph filters Ψ . The goal of training a GNN is then to improve its utility by learning the graph filters that are compatible with the other two components towards specific tasks . In the graph transfer learning setting where downstream tasks are often unknown during pre-training , we argue that the general utility of a GNN should be optimized and quantified w.r.t . its ability of capturing the essential graph information in terms of the joint distribution of its topology structures and node features , which motivates us to design a novel ego-graph information maximization model ( EGI ) ( §3.1 ) . The general transferability of a GNN is then quantified by the gap between its abilities to model the source and target graphs . Under reasonable requirements such as using structurerespecting node features as the GNN input , we analyze this gap for EGI based on the structural difference between two graphs w.r.t . their local graph Laplacians ( §3.2 ) . 3.1 Transferable GNN via Ego-graph Information Maximization . In this work , we focus on the direct-transfering setting where a GNN is pre-trained on a source graph Ga in an unsupervised fashion and applied on a target graph Gb without fine-tuning.2 Consider a graph G = { V , E } , where the set of nodes V are associated with certain features X and the set of edges E form graph structures . Intuitively , the transfer learning will be successful only if both the features and structures of Ga and Gb are similar in some ways , so that the graph filters of a GNN learned on Ga are compatible with the features and structures of Gb . Graph kernels [ 57 , 8 , 30 , 38 ] are well-known for their capability of measuring similarity between pair of graphs . Motivated by k-hop subgraph kernels [ 4 ] , we introduce a novel view of a graph as samples from the joint distribution of its k-hop ego-graph structures and node features . Since GNN essentially encodes such k-hop ego graph samples , this view allows us to give concrete definitions towards structural information of graphs in the transfer learning setting , which facilitates the measuring of similarity ( difference ) among graphs . Yet , none of the existing GNN training objectives are capable of recovering such distributional signals of ego graphs . To this end , we design Ego-Graph Information maximization ( EGI ) , which alternatively reconstructs the k-hop ego-graph of each center node via mutual information maximization [ 20 ] . Definition 3.1 ( K-hop ego-graph ) . We call a graph gi = { V ( gi ) , E ( gi ) } a k-hop ego-graph centered at node vi if it has a k-layer centroid expansion [ 4 ] such that the greatest distance between vi and 2In the experiments , we show our model to be generalizable to the more practical settings with task-specific pre-training and fine-tuning , while the study of rigorous bound in such scenarios is left as future work . any other nodes in the ego-graph is k , i.e . ∀vj ∈ V ( gi ) , |d ( vi , vj ) | ≤ k , where d ( vi , vj ) is the graph distance between vi and vj . In this paper , we use directed k-hop ego-graph and its direction is decided by whether it is composed of incoming or outgoing edges to the center node , i.e. , gi and g̃i . The results apply trivially to undirected graphs with gi = g̃i . Definition 3.2 ( Structural information ) . Let G be a topological space of sub-graphs , we view a graph G as samples of k-hop ego-graphs { gi } ni=1 drawn i.i.d . from G with probability µ , i.e. , gi i.i.d.∼ µ ∀i = 1 , · · · , n. The structural information of G is then defined to be the set of k-hop ego-graphs of { gi } ni=1 and their empirical distribution . As shown in Figure 1 , three graphs G0 , G1 and G2 are characterized by a set of 1-hop ego-graphs and their empirical distributions , which allows us to quantify the structural similarity among graphs as shown in §3.2 ( i.e. , G0 is more similar to G1 than G2 under such characterization ) . In practice , the nodes in a graph G are characterized not only by their k-hop ego-graph structures but also their associated node features . Therefore , G should be regarded as samples { ( gi , xi ) } drawn from the joint distribution P on the product space of G and a node feature space X . Ego-Graph Information Maximization . Given a set of ego-graphs { ( gi , xi ) } i drawn from an empirical joint distribution ( gi , xi ) ∼ P. We aim to train an GNN encoder Ψ to maximize the mutual informaion ( MI ( gi , Ψ ( gi , xi ) ) ) between the defined structural information gi3 ( i.e . k-hop ego-graph ) and node embedding zi = Ψ ( gi , xi ) . To maximize the MI , another discriminator D ( gi , zi ) : E ( gi ) × zi → R+ is introduced to compute the probability of an edge e belongs to the given ego-graph gi . We use the Jensen-Shannon MI estimator [ 20 ] in the EGI objective , LEGI = −MI ( JSD ) ( G , Ψ ) = 1N N∑ i=1 [ sp ( D ( gi , z′i ) ) + sp ( −D ( gi , zi ) ) ] , ( 1 ) where sp ( x ) = log ( 1+ex ) is the softplus function and ( gi , z′i ) is randomly drawn from the product of marginal distributions , i.e . z′i = Ψ ( gi′ , xi′ ) , ( gi′ , xi′ ) ∼ P , i′ 6= i . In general , we can also randomly draw negative g′i in the topological space , while enumerating all possible graphs gi′ leads to high computation cost . In Eq . 1 , the computation of D on E ( gi ) depends on the node orders . Following the common practice in graph generation [ 70 ] , we characterize the decision process of D with a fixed graph ordering , i.e. , the BFS-ordering π over edges E ( gi ) . D = f ◦ Φ is composed by another GNN encoder Φ and scoring function f over an edge sequence Eπ : { e1 , e2 , ... , en } , which makes predictions on the BFS-ordered edges . 3Later in section 3.2 , we will discuss the equivalence between MI ( gi , zi ) and MI ( ( gi , xi ) , zi ) when node feature is structure-respecting . Recall our previous definition on the direction of k-hop ego-graph , the center node encoder Ψ receives pairs of ( gi , xi ) while the neighbor node encoder Φ in discriminator D receives ( g̃i , xi ) . Both encoders are parameterized as GNNs , Ψ ( gi , xi ) = GNNΨ ( Ai , Xi ) , Φ ( g̃i , xi ) = GNNΦ ( A′i , Xi ) , where Ai , A′i is the adjacency matrix with self-loops of gi and g̃i , respectively . The self-loops are added following the common design of GNNs , which allows the convolutional node embeddings to always incorporate the influence of the center node . Ai = A′i ᵀ . The output of Ψ , i.e. , zi ∈ Rn , is the center node embedding , while Φ outputs representation H ∈ R|gi|×n for neighbor nodes in the ego-graph . Once node representation H is computed , we now describe the scoring function f . For each of the node pair ( p , q ) ∈ Eπ , hp is the source node representation from Φ , xq is the destination node features . The scoring function is , f ( hp , xq , zi ) = σ ( UT · τ ( WT [ hp||xq||zi ] ) ) , ( 2 ) where σ and τ are Sigmoid and ReLU activation functions . Thus , the discriminator D is asked to distinguish a positive ( ( p , q ) , zi ) and negative pair ( ( p , q ) , z′i ) ) for each edge in gi . D ( gi , zi ) = ∑ ( p , q ) ∈Eπ log f ( hp , xq , zi ) , D ( gi , z′i ) = Eπ∑ ( p , q ) log f ( hp , xq , z ′ i ) . ( 3 ) There are two types of edges ( p , q ) in our consideration of node orders , type-a - the edges across different hops ( from the center node ) , and type-b - the edges within the same hop ( from the center node ) . The aforementioned BFS-based node ordering guarantees that Eq . 3 is sensitive to the ordering of type-a edges , and invariant to the ordering of type-b edges , which is consistent with the requirement of our theoretical analysis on ∆D . Due to the fact that the output of a k-layer GNN only depends on a k-hop ego-graph for both encoders Ψ and Φ , EGI can be trained in parallel by sampling batches of gi ’ s . Besides , the training objective of EGI is transferable as long as ( gi , xi ) across source graph Ga and Gb satisfies the conditions given in §3.2 . More model details in Appendix §B and source code in the Supplementary Materials . Connection with existing work . To provide more insights into the EGI objective , we also present it as a dual problem of ego-graph reconstruction . Recall our definition of ego-graph mutual information MI ( gi , Ψ ( gi , xi ) ) . It can be related to an ego-graph reconstruction loss R ( gi|Ψ ( gi , xi ) ) as max MI ( gi , Ψ ( gi , xi ) ) = H ( gi ) −H ( gi|Ψ ( gi , xi ) ) ≤ H ( gi ) −R ( gi|Ψ ( gi , xi ) ) . ( 4 ) When EGI is maximizing the mutual information , it simultaneously minimizes the upper error bound of reconstructing an ego-graph gi . In this view , the key difference between EGI and VGAE [ 28 ] is they assume each edge in a graph to be observed independently during the reconstruction . While in EGI , edges in an ego-graph are observed jointly during the GNN decoding . Moreover , existing mutual information based GNNs such as DGI [ 54 ] and GMI [ 41 ] explicitly measure the mutual information between node features x and GNN output Ψ . In this way , they tend to capture node features instead of graph structures , which we deem more essential in graph transfer learning as discussed in §3.2 . Use cases of EGI framework . In this paper , we focus on the classical domain adaption ( directtransferring ) setting [ 7 ] , where no target domain labels are available and transferability is measured by the performance discrepancy without fine-tuning . In this setting , the transferability of EGI is theoretically guaranteed by Theorem 3.1 . In §4.1 , we validated this with the airport datasets . Beyond direct-transferring , EGI is also useful in the more generalized and practical setting of transfer learning with fine-tuning , which we introduced in §4.2 and validated with the YAGO datasets . In this setting , the transferability of EGI is not rigorously studied yet , but is empirically shown promising . Supportive observations . In the first three columns of our synthetic experimental results ( Table 1 ) , in both cases of transfering GNNs between similar graphs ( F-F ) and dissimilar graphs ( B-F ) , EGI significantly outperforms all competitors when using node degree one-hot encoding as transferable node features . In particular , the performance gains over the untrained GIN show the effectiveness of training and transfering , and our gains are always larger than the two state-of-the-art unsupervised GNNs . Such results clearly indicate advantageous structure preserving capability and transferability of EGI . | The paper introduces a theoretical framework for analyzing GNN transferability. The main idea is to view a graph as subgraph samples with the information of both the connections and the features. Based on this view, the authors define EGI score of a graph as a learnable function that needs to be optimized by maximizing the mutual information between the subgraph and the GNN output embedding of the center node. Then, the authors give an upper bound for the difference of EGI scores of two graphs based on the difference of eigenvalues of the graph Laplacian of the subgraph samples from the two graphs. The implication is that if the difference of the eigenvalues is small, then the EGI scores are similar, which means the GNN has a similar ability to encode the structure of the two graphs. | SP:038a1d3066f8273977337262e975d7a7aab5002f |
Information Lattice Learning | 1 INTRODUCTION . With rapid progress in AI , there is an increasing desire for general AI ( Goertzel & Pennachin , 2007 ; Chollet , 2019 ) and explainable AI ( Adadi & Berrada , 2018 ; Molnar , 2019 ) , which exhibit broad , human-like cognitive capacities . One common pursuit is to move away from “ black boxes ” designed for specific tasks to achieve broad generalization through strong abstractions made from only a few examples , with neither unlimited priors nor unlimited data ( “ primitive priors ” & “ small data ” instead ) . In this pursuit , we present a new , task-nonspecific framework—Information Lattice Learning ( ILL ) — to learn representations akin to human-distilled rules , e.g. , producing much of a standard music theory curriculum as well as new rules in a form directly interpretable by students ( shown at the end ) . The term information lattice was first defined by Shannon ( 1953 ) , but remains largely conceptual and unexplored . In the context of abstraction and representation learning , we independently develop representation lattices that coincide with Shannon ’ s information lattice when restricted to his context . Instead of inventing a new name , we adopt Shannon ’ s . However , we not only generalize the original definition—an information lattice here is a hierarchical distribution of representations—but we also bring learning into the lattice , yielding the name ILL. ILL explains a signal ( e.g. , a probability distribution ) by disentangled representations , called rules . A rule explains some but not all aspects of the signal , but together the collection of rules aims to capture a large part of the signal . ILL is specially designed to address the core question “ what makes X an X ” or “ what makes X different from Y ” , emphasizing the what rather than generating X or predicting labels X , Y in order to facilitate effective , rule-based explanations designed to help human learners understand . A music AI classifying concertos , or generating one that mimics the masters , does not necessarily produce human insight about what makes a concerto a concerto or the best rules a novice composer might employ to write one . Our focus represents a shift from much representation-learning work ( Bengio et al. , 2013 ) that aim to find the best representation for solving a specific task ( e.g. , classification ) rather than strong concern for explainability . Instead of optimizing a task-specific objective function ( e.g. , classification error ) , ILL balances more general objectives that favor fewer , simpler rules for interpretability , and more essential rules for effectiveness—all formalized later . One intuition behind ILL is to break the whole into simple pieces , similar to breaking a signal into a Fourier series . Yet , rather than decomposition via projection to orthonormal basis and synthesis via weighted sum , we decompose a signal in a hierarchical space called a lattice . Another intuition behind ILL is feature selection . Yet , rather than features , we use partitions to mimic human concepts and enable structured search in a partition lattice to mimic human learning . The goal is to restore human-like , hierarchical rule abstraction-and-realization through signal decomposition-and-synthesis in a lattice ( called projection-and-lifting , Figure 1 : left ) , resulting in more than a sum of parts . ILL comprises two phases : ( a ) lattice construction ; ( b ) learning ( i.e. , searching ) in the lattice . This is similar to many machine learning ( ML ) models comprising ( a ) function class specification then ( b ) learning in the function class , e.g. , constructing a neural network then learning—finding optimal parameters via back-propagation—in the network . ILL ’ s construction phase is prior-efficient : it builds in universal priors that resemble human innate cognition ( cf . the Core Knowledge priors ( Spelke & Kinzler , 2007 ) ) , then grows a lattice of abstractions . The priors can be customized , however , to cater to a particular human learner , or facilitate more exotic knowledge discovery . ILL ’ s learning phase is data-efficient : it learns from “ small data ” encoded by a signal , but searches for rich explanations of the signal via rule learning , wherein abstraction is key to “ making small data large ” . Notably , the construction phase is prior-driven , not data-driven—data comes in only at the learning phase . Hence , the same construction may be reused in different learning phases for different data sets or even data on different topics ( Figure 1 : right ) . Featuring these two phases , ILL is thus a hybrid model that threads the needle between a full data-driven model and a full prior-driven model , echoing the notion of “ starting like a baby ; learning like a child ” ( Hutson , 2018 ) . ILL is related to many research areas . It draws ideas and approaches from lattice theory , information theory , group theory , and optimization . It shares algorithmic similarity with a range of techniques including MaxEnt , data compression , autoencoders , and compressed sensing , but with a much greater focus on achieving human-like explainability and generalizability . Below , we broadly compares ILL to prominent , related models , leaving more comparisons to the Appendix for most similar ones . Compared to ILL is deep learning a “ white-box ” model balancing human-explainability and task performance Bayesian inference modeling human reasoning with widely shared , common priors and few , simple rules rather than using probabilistic inference as the driving force tree-like models structurally more general : a tree ( e.g. , decision tree or hierarchical clustering ) is essentially a linear lattice ( called a chain formally ) depicting a unidirectional refinement or coarsening process concept lattice in FCA ( Ganter & Wille , 2012 ) conceptually more general and may include both known and unknown concepts ; ILL does not require but discovers domain knowledge ( more details in Appendix A ) We illustrate ILL applications by learning music theory from scores , chemical laws from compounds , and show how ILL ’ s common priors facilitate mutual interpretation between the two subjects . To begin , imagine Tom and Jerry are playing two 12-key pianos simultaneously , one note at a time ( Figure 1 : right ) . The frequency of the played two-note chords gives a 2D signal plotted as a 12× 12 grayscale heatmap . Inspecting this heatmap , what might be the underlying rules that govern their co-play ? ( Check : all grey pixels have a larger “ Jerry-coordinate ” and project to a black key along the “ Tom-axis ” . ) We now elaborate on ILL and use it to distill rules for complex , realistic cases . 2 INFORMATION LATTICE : ABSTRACTIONS AND RULES OF A SIGNAL . Signal . A signal is a function ξ : X → R. For notational brevity and computational reasons , assume ξ is non-negative and X ⊆ Rn is finite ( not a limitation : see Appendix B ) . For example , a signal ξ : { 1 , . . . , 6 } → R being a probability mass function ( pmf ) of a dice roll , or a signal ξ : { 0 , . . . , 27 } 2 → R being a 28× 28 grayscale image . We denote the set of all signals on X by SX . Partition / abstraction . We use a partition P of a set X to denote an abstraction of X ; we call a cell C ∈ P an ( abstracted ) concept . The intuition is simple : a partition of a set renders a “ coarse-grained view ” of the set , or more precisely , an equivalence relation on the set . In this view , we identify equivalence classes of elements ( concepts ) instead of individual elements . For example , the partition P = { { 1 , 3 , 5 } , { 2 , 4 , 6 } } of the six outcomes of the roll of a die identify two concepts ( odd , even ) . Rule / representation . A rule of a signal ξ : X → R is a “ coarsened ” signal rξ : P → R defined on a partition P of X with rξ ( C ) : = ∑ x∈C ξ ( x ) for any C ∈ P . In this paper , a rule of a signal is what we mean by a representation of a signal . If the signal is a grayscale image , a rule can be a special type of blurring or downsampling of the image ; if the signal is a probability distribution , a rule can be a pmf of the “ orbits ” of the distribution for lifted inference algorithms ( Holtzen et al. , 2019 ; Kersting , 2012 ) . More generally , we define a rule ( regardless of any signal ) over a set X by any signal on any partition of X ; accordingly , we denote the set of all rules over X byRX : = ∪P∈ { all partitions of X } SP . Partition lattice . Abstractions are hierarchical : one coarse-grained view can be coarser than another . Let the partition lattice ( PX , ) of a setX be the partially ordered set ( poset ) containing all partitions of X equipped with the partial order coarser than ( ) , or finer than ( ) , defined in the standard way . Let P : = { { x } | x ∈ X } and P : = { X } denote the finest and the coarsest partition , respectively . Per general lattice theory ( Davey & Priestley , 2002 ) , PX is a complete lattice : every subset P ⊆ PX has a unique supremum ∨P and a unique infimum ∧P , where ∨P is called the join of P denoting its coarsest common refinement and ∧P is called the meet of P denoting its finest common coarsening . Information lattice . The information lattice ( Rξ , ⇐ ) of a signal ξ : X → R is the poset of all rules of ξ equipped with the partial order more general than : for any two rules r , r′ ∈ Rξ , we say r is more general than r′ ( or r′ is more specific ) , denoted r ⇐ r′ , if domain ( r ) domain ( r′ ) . Notably , Rξ ⊆ RX andRξ is isomorphic to the underlying partition lattice via projection defined below . Projection and lifting . For any signal ξ ∈ SX , we define the projection operator ↓ξ : PX → Rξ by letting ↓ξ ( P ) be the rule of ξ on P . One can check that ↓ξ : ( PX , ) → ( Rξ , ⇐ ) is an isomorphism . Conversely , we define the general lifting operator ⇑X : RX → 2SX by letting ⇑X ( r ) denote the set of all signals that satisfy the rule r , i.e. , ⇑X ( r ) : = { ξ ∈ SX | ↓ξ ( domain ( r ) ) = r } ⊆ SX . To make lifting unique and per Principles of Indifference ( Eva , 2019 ) , we introduce a special lifting ↑X ( r ) to pick the most “ uniform ” signal in ⇑X ( r ) . Formally , define ‖ · ‖q : SX → R by ‖ξ‖q : = ( ∑ x∈X ξ ( x ) q ) 1/q . For any ξ , ξ′ ∈ SX satisfying ‖ξ‖1 = ‖ξ′‖1 , we say that ξ is more uniform than ξ′ ( or ξ′ is more deterministic ) if ‖ξ‖2 ≤ ‖ξ′‖2 . We define the ( special ) lifting operator ↑X : RX → SX by ↑X ( r ) : = argminξ∈⇑X ( r ) ‖ξ‖2 ( can be computed by simply averaging ) . Notation here follows the convention as to function projections to quotient spaces ( Kondor & Trivedi , 2018 ) . Lifting a single rule to the signal domain can be extended in two ways : ( a ) lift to a finer rule domain P instead of X , i.e. , ⇑P ( r ) or ↑P ( r ) ; ( b ) lift more than one rules . Accordingly , we write ⇑ : = ⇑X and ↑ : = ↑X as defaults , write R = ↓ξ ( P ) : = { ↓ξ ( P ) | P ∈ P } ⊆ Rξ to denote a rule set , and write ⇑ ( R ) : = ∩r∈R ⇑ ( r ) = { η ∈ SX | ↓η ( P ) = R } and ↑ ( R ) : = argminη∈⇑ ( R ) ‖η‖2 to denote signals that satisfy all rules in R ( general lifting ) and the most uniform one ( special lifting ) , respectively . More computational details on lifting and its intimate relation to join are in Appendix C . | The authors perform a descriptive analysis of data by attempting to identify elements in the partial ordering of all partitions on the data which admit a compact definition. Compact definitions are those that are formed by composition of a small number of predefined (prior) set of mathematical operations. Projection and lifting operations are defined to relate descriptions of partition cells to one another through rules. The quality of a description is measured by the divergence between the data and the (special) lifting of the rule set, under the constraint that rules satisfy an upper bound on their entropy. | SP:40cba7b6c04d7e44709baed351382c27fa89a129 |
Don't be picky, all students in the right family can learn from good teachers | 1 INTRODUCTION . Recently-developed deep learning models have achieved remarkable performance in a variety of tasks . However , breakthroughs leading to state-of-the-art ( SOTA ) results often rely on very large models : GPipe , Big Transfer and GPT-3 use 556 million , 928 million and 175 billion parameters , respectively ( Huang et al. , 2019 ; Kolesnikov et al. , 2020 ; Brown et al. , 2020 ) . Deploying these models on user devices ( e.g . smartphones ) is currently impractical as they require large amounts of memory and computation ; and even when large devices are an option ( e.g . GPU clusters ) , the cost of large-scale deployment ( e.g . continual inference ) can be very high ( Cheng et al. , 2017 ) . Additionally , target hardware does not always natively or efficiently support all operations used by SOTA architectures . The applicability of these architectures is , therefore , severely limited , and workarounds using smaller or simplified models lead to a performance gap between the technology available at the frontier of deep learning research and that usable in industry applications . In order to bridge this gap , Knowledge Distillation ( KD ) emerges as a potential solution , allowing small student models to learn from , and emulate the performance of , large teacher models ( Hinton et al. , 2015a ) . The student model can be constrained in its size and type of operations used , so that it will satisfy the requirements of the target computational environment . Unfortunately , successfully achieving this in practice is extremely challenging , requiring extensive human expertise . For example , while we know that the architecture of the student is important for distillation ( Liu et al. , 2019b ) , it remains unclear how to design the optimal network given some hardware constraints . With Neural Architecture Search ( NAS ) it is possible to discover an optimal student architecture . NAS automates the choice of neural network architecture for a specific task and dataset , given a search space of architectures and a search strategy to navigate that space ( Pham et al. , 2018 ; Real et al. , 2017 ; Liu et al. , 2019a ; Carlucci et al. , 2019 ; Zela et al. , 2018 ; Ru et al. , 2020 ) . One im- portant limitation of most NAS approaches is that the search space is very restricted , with a high proportion of resources spent on evaluating very similar architectures , thus rendering the approach limited in its effectiveness ( Yang et al. , 2020 ) . This is because traditional NAS approaches have no tools for distinguishing between architectures that are similar and architectures that are very different ; as a consequence , computational resources are needed to compare even insignificant changes in the model . Conversely , properly exploring a large space requires huge computational resources : for example , recent work by Liu et al . ( 2019b ) investigating how to find the optimal student requires evaluating 10 , 000 models . By focusing on the comparison between distributions we ensure to use computational resources only on meaningful differences , thus performing significantly more efficiently : we evaluate 33× less architectures than the most related work to ours ( Liu et al. , 2019b ) . To overcome these limitations , we propose an automated approach to knowledge distillation , in which we look for a family of good students rather than a specific model . We find that even though our method , AutoKD , does not output one specific architecture , all architectures sampled from the optimal family of students perform well when trained with KD . This reformulation of the NAS problem provides a more expressive search space containing very diverse architectures , thus increasing the effectiveness of the search procedure in finding good student networks . Our contributions are as follows : ( A ) a framework for combining KD with NAS and effectively emulate large models while using a fraction of the memory and of the parameters ; ( B ) By searching for an optimal student family , rather than for specific architectures , our algorithm is up to 20x more sample efficient than alternative NAS-based KD solutions ; ( C ) We significantly outperform advanced KD methods on a benchmark of vision datasets , despite using the traditional KD loss , showcasing the efficacy of our found students . 2 RELATED WORK . Model compression has been studied since the beginning of the machine learning era , with multiple solutions being proposed ( Choudhary et al. , 2020 ; Cheng et al. , 2017 ) . Pruning based methods allow the removal of non-essential parameters from the model , with little-to-none drop in final performance . The primary motive of these approaches was to reduce the storage requirement , but they can also be used to speed up the model ( LeCun et al. , 1990 ; Han et al. , 2015 ; Li et al. , 2016a ) . The idea behind quantization methods is to reduce the number of bits used to represent the weights and the activations in a model ; depending on the specific implementation this can lead to reduced storage , reduced memory consumption and a general speed-up of the network ( Fiesler et al. , 1990 ; Soudry et al. , 2014 ; Rastegari et al. , 2016 ; Zhu et al. , 2016 ) . In low rank factorization approaches , a given weight matrix is decomposed into the product of smaller ones , for example using singular value decomposition . When applied to fully connected layers this leads to reduced storage , while when applied to convolutional filters , it leads to faster inference ( Choudhary et al. , 2020 ) . All the above mentioned techniques can successfully reduce the complexity of a given model , but are not designed to substitute specific operations . For example , specialized hardware devices might only support a small subset of all the operations offered by modern deep learning frameworks . In Knowledge Distillation approaches , a large model ( the teacher ) distills its knowledge into a smaller student architecture ( Hinton et al. , 2015b ) . This knowledge is assumed to be represented in the neural network ’ s output distribution , hence in the standard KD framework , the output distribution of a student ’ s network is optimized to match the teacher ’ s output distribution for all the training data ( Yun et al. , 2020 ; Ahn et al. , 2019 ; Yuan et al. , 2020 ; Tian et al. , 2020 ; Tung & Mori , 2019 ) . The work of Liu et al . ( 2019b ) shows that the architecture of a student network is a contributing factor in its ability to learn from a given teacher . The authors propose combining KD with a traditional NAS pipeline , based on Reinforcement Learning , to find the optimal student . While this setup leads to good results , it does so at a huge computational cost , requiring over 5 days on 200 TPUs . Similarly , Gu & Tresp ( 2020 ) also look for the optimal student architecture , but do so by searching for a subgraph of the original teacher ; therefore , it can not be used to substitute unsupported operations . Orthogonal approaches , looking at how KD can improve NAS , are explored by Trofimov et al . ( 2020 ) and Li et al . ( 2020 ) . The first establishes that KD improves the correlation between different budgets in multi-fidelity methods , while the second uses the teacher supervision to search the architecture in a blockwise fashion . 3 SEARCHING FOR THE OPTIMAL STUDENT NETWORK GENERATOR . The AutoKD framework ( Fig . 1 ) combines Bayesian Optimization ( BO ) , Neural Architecture Search ( NAS ) and Knowledge Distillation ( KD ) . AutoKD defines a family of random network generators G ( θ ) parameterized by a hyperparameter θ , from where student networks are sampled . BO uses a surrogate model to propose generator hyperparameters , while students from these generators are trained with KD using a state-of-the-art teacher network . The student performances are evaluated and provided as feedback to update the BO surrogate model . To improve our BO surrogate model , the search procedure is iterated , until the best family of student networks G ( θ∗ ) is selected . In this section we specify all components of AutoKD . See also Fig . 1 and Algorithm 1 for an overview . 3.1 KNOWLEDGE DISTILLATION . Knowledge Distillation ( KD ; Hinton et al. , 2015b ) is a method to transfer , or distill , knowledge from one model to another—usually from a large model to small one—such that the small student model learns to emulate the performance of the large teacher model . KD can be formalized as minimizing the objective function : LKD = ∑ xi∈X l ( fT ( xi ) , fS ( xi ) ) ( 1 ) where l is the loss function that measures the difference in performance between the teacher fT and the student fS , xi is the ith input , yi is the ith target . The conventional loss function l used in practice is a linear combination of the traditional cross entropy loss LCE and the Kullback–Leibler divergence LKL of the pre-softmax outputs for fT and fS : l = ( 1− α ) LCE + αLKL ( σ ( fT ( xi ) /τ ) , σ ( fS ( xi ) /τ ) ) ( 2 ) where σ is the softmax function σ ( x ) = 1/ ( 1 + exp ( −x ) ) , and τ is the softmax temperature . Hinton et al . ( 2015b ) propose “ softening ” the probabilities using temperature scaling with τ ≥ 1 . The parameter α represents the weight trade-off between the KL loss and the cross entropy loss LCE . The LKD loss is characterized by the hyper-parameters : α and τ ; popular choices are τ ∈ { 3 , 4 , 5 } and α = 0.9 ( Huang & Wang , 2017 ; Zagoruyko & Komodakis , 2016 ; Zhu et al. , 2018 ) . Numerous other methods ( Polino et al. , 2018 ; Huang & Wang , 2017 ; Tung & Mori , 2019 ) can be formulated as a form of Equation ( 2 ) , but in this paper we use the conventional loss function l. Traditionally in KD , both the teacher and the student network have predefined architectures . In contrast , AutoKD defines a search space of student network architectures and finds the optimal student by leveraging neural architecture search , as detailed below . 3.2 STUDENT SEARCH VIA GENERATOR OPTIMIZATION . Most NAS method for vision tasks employ a cell-based search space , where networks are built by stacking building blocks ( cells ) and the operations inside the cell are searched ( Pham et al. , 2018 ; Real et al. , 2017 ; Liu et al. , 2019a ) . This results in a single architecture being output by the NAS procedure . In contrast , more flexible search spaces have recently been proposed that are based on Algorithm 1 : AutoKD 1 : Input : Network generator G , BOHB hyperparameters ( η , training budget bmin and bmax ) , Evaluation function fKD ( θ , b ) which assesses the validation performance of a generator hyperparameterθ by sampling an architecture from G ( θ ) and training it with the KD loss LKD ( equations 1 and 2 ) for b epochs . 2 : smax = blogη bmaxbmin c ; 3 : for s ∈ { smax , smax − 1 , . . . , 0 } do 4 : Sample M = d smax+1s+1 · η se generator hyperparameters Θ = { θj } Mj=1 which maximises the raito of kernel density estimators ; . ( Falkner et al. , 2018 , Algorithm 2 ) 5 : Initialise b = ηs · bmax ; . Run Successive Halving ( Li et al. , 2016b ) 6 : while b ≤ bmax do 7 : L = { fKD ( θ , b ) : θ ∈ Θ } ; 8 : Θ = top k ( Θ , L , b|Θ|/ηc ) ; 9 : b = η · b ; 10 : end while 11 : end for 12 : Obtain the best performing configuration θ∗ for the student network generator . 13 : Sample k architectures from G ( θ∗ ) , train them to completion , and obtain test performance . neural network generators ( Xie et al. , 2019 ; Ru et al. , 2020 ) . The generator hyperparameters define the characteristics of the family of networks being generated . NAGO optimizes an architecture generator instead of a single architecture and proposes a hierarchical graph-based space which is highly expressive yet low-dimensional ( Ru et al. , 2020 ) . Specifically , the search space of NAGO comprises three levels of graphs ( where the node in the higher level is a lower-level graph ) . The top level is a graph of cells ( Gtop ) and each cell is itself a graph of middlelevel modules ( Gmid ) . Each module further corresponds to a graph of bottom-level operation units ( Gbottom ) such as a relu-conv3×3-bn triplet . NAGO adopts three random graph generators to define the connectivity/topology of Gtop , Gmid and Gbottom respectively , and thus is able to produce a wide variety of architectures with only a few generator hyperparameters . AutoKD employs NAGO as the NAS backbone for finding the optimal student family . Our pipeline consists of two phases . In the first phase ( search ) , a multi-fidelity Bayesian optimisation technique , BOHB ( Falkner et al. , 2018 ) , is employed to optimise the low-dimensional search space . BOHB uses partial evaluations with smaller-than-full budget to exclude bad configurations early in the search process , thus saving resources to evaluate more promising configurations . Given the same time constraint , BOHB evaluates many more configurations than conventional BO which evaluates all configurations with full budget . As Ru et al . ( 2020 ) empirically observe that good generator hyperparameters lead to a tight distribution of well-performing architectures ( small performance standard deviation ) , we similarly assess the performance of a particular generator hyperparameter value with only one architecture sample . In the second phase ( retrainA ) , AutoKD uniformly samples multiple architectures from the optimal generator found during the search phase and evaluates them with longer training budgets to obtain the best architecture performance . Instead of the traditionally used cross-entropy loss , AutoKD uses the KD loss in equation 2 to allow the sampled architecture to distill knowledge from its teacher . The KD hyperparameters temperature τ and loss weight α are included in the search space and optimized simultaneously with the architecture to ensure that the student architectures can efficiently distill knowledge both from the designated teacher and the data distribution . A full overview of the framework is shown in Fig . 1 . | This paper proposes searching for an architecture generator that outputs good student architectures for a given teacher. The authors claim that by learning the parameters of the generator instead of relying directly on the search space, it is possible to explore the search space of architectures more effectively, increasing the diversity of the architectures explored. They show that this approach combined with the standard knowledge distillation loss is able to learn good student architectures requiring substantially less samples and achieving competitive performances when comparing to other knowledge distillation algorithms. | SP:1ee00313e354c4594bbf6cf8bdbe33e3ec8df62f |
End of preview. Expand
in Dataset Viewer.
MuP - Multi Perspective Scientific Document Summarization
Generating summaries of scientific documents is known to be a challenging task. Majority of existing work in summarization assumes only one single best gold summary for each given document. Having only one gold summary negatively impacts our ability to evaluate the quality of summarization systems as writing summaries is a subjective activity. At the same time, annotating multiple gold summaries for scientific documents can be extremely expensive as it requires domain experts to read and understand long scientific documents. This shared task will enable exploring methods for generating multi-perspective summaries. We introduce a novel summarization corpus, leveraging data from scientific peer reviews to capture diverse perspectives from the reader's point of view.
- Downloads last month
- 53