paper_name stringlengths 11 170 | text stringlengths 8.07k 307k | summary stringlengths 152 6.16k | paper_id stringlengths 43 43 |
|---|---|---|---|
Generating Symbolic Reasoning Problems with Transformer GANs | 1 INTRODUCTION . Deep learning is increasingly applied to more untraditional domains that involve complex symbolic reasoning . Examples include the application of deep neural network architectures to SAT ( Selsam et al. , 2019 ; Selsam & Bjørner , 2019 ; Ozolins et al. , 2021 ) , SMT ( Balunovic et al. , 2018 ) , temporal specifications in verification ( Hahn et al. , 2021 ; Schmitt et al. , 2021 ) , symbolic mathematics ( Lample & Charton , 2020 ) , or theorem proving ( Loos et al. , 2017 ; Bansal et al. , 2019 ; Huang et al. , 2019 ; Urban & Jakubuv , 2020 ) . The acquisition of training data for symbolic reasoning domains , however , is a challenge . Existing instances , such as benchmarks in competitions ( Biere & Claessen , 2010 ; Froleyks et al. , 2021 ; Jacobs et al. , 2017 ) are typically hand-crafted , for example , in a “ bring your own benchmarks ” setting ( Balyo et al. , 2017 ) . Since the instances are too few to be trained on , training data is , thus , typically generated synthetically . For example by random sampling ( Selsam et al. , 2019 ; Lample & Charton , 2020 ) , or by randomly re-combining parts of existing instances ( Schmitt et al. , 2021 ) . Although these data generation methods already lead to good results , training on randomly generated data carries the risk of training on meaningless data or the risk of introducing unwanted biases . In this paper , we study the generation of symbolic reasoning problems with Generative Adversarial Networks ( GANs ) ( Goodfellow et al. , 2014 ) and show that they can be used to construct large amounts of meaningful training data from a significantly smaller data source . GANs , however , can not immediately be applied : Symbolic reasoning problems reside typically in a discontinuous domain and , additionally , training data is typically sequential and of variable length . We show that training directly in the one-hot encoding space is possible when adding Gaussian noise to each position . We , furthermore , use a Transformer ( Vaswani et al. , 2017 ) encoder to cope with the sequential form of the data and the variable length of the problem instances . We provide experiments to show the usefulness of a GAN approach for the generation of reasoning problems . The experiments are based around two symbolic reasoning domains where recent studies on the applicability of deep learning relied on large amounts of artificially generated data : symbolic mathematics and linear-time temporal logic ( LTL ) specifications in verification . We report our experimental results in three sections . We first provide details on how to achieve a stable training of a standard GAN and a Wasserstein GAN ( Arjovsky et al. , 2017 ) both equipped with Transformer encoders . We analyze the particularities of their training behavior , such as the effects of adding different amounts of noise to the one hot embeddings . Secondly , we show for an LTL satisfiability classifier that the generated data can be used as a substitute for real training data , and , especially , that training data can be generated from a real dataset that is too small to be trained on directly . In particular , we show that out of 10K real training instances , a dataset consisting of 400K instances can be generated , on which a classifier can successfully be trained on . Lastly , we show that generating symbolic reasoning problems in a GAN setting has a specialty : We can alter the target distribution by adding a classifier uncertainty part to the generator objective . By doing this , we show that we can obtain a dataset that is even harder to solve than the original dataset which has been used to generate the data from . The remainder of this paper is structured as follows . In Section 2 , we give a short introduction to the problem domains considered in this paper and describe how the origin training data has been constructed . In Section 3 , we present our Transformer GAN architecture ( s ) , before providing experimental results in Section 4 . We give an overview over related work in Section 5 before concluding in Section 6 . 2 PROBLEM DOMAIN AND BASE DATASETS . In this section , we introduce the two problem domains on which we base our experiments on : satisfiability of temporal specifications for formal verification and function integration and ordinary differential equations ( ODEs ) for symbolic mathematics . We furthermore give an overview over the data generation processes of these base datasets . 2.1 HARDWARE SPECIFICATIONS IN LINEAR-TIME TEMPORAL LOGIC ( LTL ) . Linear-time Temporal Logic ( LTL ) ( Pnueli , 1977 ) is the basis for industrial hardware specification languages like the IEEE standard PSL ( IEEE-Commission et al. , 2005 ) . It is an extension of propositional logic with temporal modalities , such as the Next-operator ( ) and the Until-operator ( U ) . There also exist derived operators , such as “ eventually ” ϕ ( ≡ true U ϕ ) and “ globally ” ϕ ( ≡ ¬ ¬ϕ ) . For example , mutual exclusion can be expressed as the following specification : ( ¬ ( accessp0 ∧ accessp1 ) , stating that processes p0 and p1 should have no access to a shared resource at the same time . The base problem of any logic is its satisfiability problem . It is the problem to decide whether there exists a solution to a given formula . The satisfiability problem of LTL is a hard problem , in fact , it is PSPACE-hard Sistla & Clarke ( 1982 ) . The full syntax , semantics and additional information on the satisfiability problem can be found in Appendix A . So far , the construction of datasets for LTL formulas has been done in two ways ( Hahn et al. , 2021 ) : Either by obtaining LTL formulas from a fully random generation process , which likely results in unrealistic formulas , or by sampling conjunctions of LTL specification patterns ( Dwyer et al. , 1999 ) . To obtain a healthy amount of unsatisfiable and satisfiable instances in this artificial generation process , we slightly refined the pattern-based generation method with two operations . Details can be found in Appendix B . Since the formula length correlates to unsatisfiability , we filter for equal proportions of classes per formula length . We restrict the tree size of the formulas to 50 . We call this dataset LTLbase . 2.2 SYMBOLIC MATHEMATICS . Lample & Charton ( 2020 ) showed that Transformer models perform surprisingly well on symbolic mathematics . More precisely , they applied the models to function integration and ordinary differential equations ( ODEs ) . We consider the function integration problem and use the forward generated dataset ( https : //github.com/facebookresearch/SymbolicMathematics ) . Random functions with up to n operators are generated and their integrals are calculated with computer algebra systems . Functions that the system can not integrate are discarded . Mathematical expressions are generated randomly . The dataset is cleaned , with equation simplification , coefficients simplification , and filtering out invalid expressions ( Lample & Charton , 2020 ) . We restrict the tree size to 50 . 3 ARCHITECTURE . The Transformer GAN architecture for generating symbolic reasoning problems ( TGAN-SR ) is depicted in Figure 1 . It consists of two Transformer encoders as discriminator/critic and generator , respectively . The inner layers of the encoders are largely identical to standard transformers ( Vaswani et al. , 2017 ) , but their input and output processing is adjusted to the GAN setting . We use an embedding dimension of demb = 128 , nh = 8 attention heads , and a feed-forward network dimension of dFF = 1024 for both encoders as default . The generator ’ s input is a real scalar random value with uniform distribution [ 0 , 1 ] for each position in the sequence . It is mapped to demb by an affine transformation before being processed by the first layer . The position-wise padding mask is copied from the real data during training , so the lengths of real and generated formulas at the same position in a batch are always identical . During inference , the lengths can either be sampled randomly or copied from an existing dataset similar to training . Either way , the generator encoder ’ s padding mask is predetermined so it has to adequately populate the unmasked positions . With V being the vocabulary , and |V | being the size of the vocabulary , an affine transformation to dimensionality |V | and a softmax is applied after the last layer . The generator ’ s output lies , thus , in the same space as one-hot encoded tokens . We use nlG = 6 layers for our default model ’ s generator . A GAN discriminator and WGAN critic are virtually identical in terms of their architecture . The only difference is that a critic outputs a real scalar value where a discriminator is limited to the range [ 0 , 1 ] , which we achieve by applying an additional logistic sigmoid in the end . To honor their differences regarding the training scheme , we use both terms when referring to exchangeable properties and make no further distinctions between them . For input processing , their |V |-dimensional ( per position ) input is mapped to demb by an affine transformation . After the last layer , the final embeddings are aggregated over the sequence by averaging and a linear projection to a scalar value ( the prediction logit ) is applied . Our default model uses nlD = 4 layers . We achieved best results with slightly more generator than discriminator/critic layers . A full hyperparameter study can be found in AppendixC.2 . Working in the |V |-sized one-hot domain poses harsh constraints on the generator ’ s output . Contrary to continuous domains were GANs are usually employed , each component of a real one-hot vector is , by definition , either 0 or 1 . If the generator were to identify this distribution and use it as criterion to tell real and generated instances apart , this would pose a serious difficulty for training . We therefore sample a |V |-sized vector of Gaussian noise N ( 0 , σ2real ) for each position ( see Figure 1 ) . We add it to the real samples ’ one-hot encoding and re-normalize it to sum 1 before handing them to the discriminator/critic . By default , we use a value of σreal = 0.1 for all models to get comparable results . We study the effect of different amounts of noise more closely in Section 4.1.2 . 4 EXPERIMENTS . In this section , we report our experimental findings . We structure our results in three sections . We first report on the performance of the TGAN-SR architecture in constructing syntactically correct instances of temporal specifications and mathematical expressions . Secondly , we show , exemplary for LTL formulas , that the newly generated dataset can be used as a substitute for the origin dataset . Lastly , we show , by altering the target distribution , that the network can generate a dataset that is harder to solve for a classifier . We trained the models on an NVIDIA DGX A100 system for around 8 hours . We begin each subsection with a short preamble on the training setting . 4.1 PRODUCING SYNTACTICALLY CORRECT SYMBOLIC REASONING PROBLEMS . The goal of the experiments in this section is to asses the generator ’ s capability in creating valid symbolic reasoning problems as objectively as possible . If not stated otherwise , in plots and tables , we report results from our default model averaged across three runs and with an exponential smoothing ( α = 0.95 ) applied . For temporal specifications , we use LTLbase as training set and for symbolic math the dataset described in section 2.2 . | This paper aims to generate training data for symbolic reasoning by training GANs based on Transformers. Specifically, the paper explores two methods --- standard GAN and Wasserstein GAN --- which has a Transformer as an encoder and a decoder, respectively. Training these models on symbolic reasoning data that is randomly generated --- LTL and Symbolic mathematics --- is found to generate high quality formulas. | SP:92073001584698ae0358e53e22f0603606f37602 |
Generating Symbolic Reasoning Problems with Transformer GANs | 1 INTRODUCTION . Deep learning is increasingly applied to more untraditional domains that involve complex symbolic reasoning . Examples include the application of deep neural network architectures to SAT ( Selsam et al. , 2019 ; Selsam & Bjørner , 2019 ; Ozolins et al. , 2021 ) , SMT ( Balunovic et al. , 2018 ) , temporal specifications in verification ( Hahn et al. , 2021 ; Schmitt et al. , 2021 ) , symbolic mathematics ( Lample & Charton , 2020 ) , or theorem proving ( Loos et al. , 2017 ; Bansal et al. , 2019 ; Huang et al. , 2019 ; Urban & Jakubuv , 2020 ) . The acquisition of training data for symbolic reasoning domains , however , is a challenge . Existing instances , such as benchmarks in competitions ( Biere & Claessen , 2010 ; Froleyks et al. , 2021 ; Jacobs et al. , 2017 ) are typically hand-crafted , for example , in a “ bring your own benchmarks ” setting ( Balyo et al. , 2017 ) . Since the instances are too few to be trained on , training data is , thus , typically generated synthetically . For example by random sampling ( Selsam et al. , 2019 ; Lample & Charton , 2020 ) , or by randomly re-combining parts of existing instances ( Schmitt et al. , 2021 ) . Although these data generation methods already lead to good results , training on randomly generated data carries the risk of training on meaningless data or the risk of introducing unwanted biases . In this paper , we study the generation of symbolic reasoning problems with Generative Adversarial Networks ( GANs ) ( Goodfellow et al. , 2014 ) and show that they can be used to construct large amounts of meaningful training data from a significantly smaller data source . GANs , however , can not immediately be applied : Symbolic reasoning problems reside typically in a discontinuous domain and , additionally , training data is typically sequential and of variable length . We show that training directly in the one-hot encoding space is possible when adding Gaussian noise to each position . We , furthermore , use a Transformer ( Vaswani et al. , 2017 ) encoder to cope with the sequential form of the data and the variable length of the problem instances . We provide experiments to show the usefulness of a GAN approach for the generation of reasoning problems . The experiments are based around two symbolic reasoning domains where recent studies on the applicability of deep learning relied on large amounts of artificially generated data : symbolic mathematics and linear-time temporal logic ( LTL ) specifications in verification . We report our experimental results in three sections . We first provide details on how to achieve a stable training of a standard GAN and a Wasserstein GAN ( Arjovsky et al. , 2017 ) both equipped with Transformer encoders . We analyze the particularities of their training behavior , such as the effects of adding different amounts of noise to the one hot embeddings . Secondly , we show for an LTL satisfiability classifier that the generated data can be used as a substitute for real training data , and , especially , that training data can be generated from a real dataset that is too small to be trained on directly . In particular , we show that out of 10K real training instances , a dataset consisting of 400K instances can be generated , on which a classifier can successfully be trained on . Lastly , we show that generating symbolic reasoning problems in a GAN setting has a specialty : We can alter the target distribution by adding a classifier uncertainty part to the generator objective . By doing this , we show that we can obtain a dataset that is even harder to solve than the original dataset which has been used to generate the data from . The remainder of this paper is structured as follows . In Section 2 , we give a short introduction to the problem domains considered in this paper and describe how the origin training data has been constructed . In Section 3 , we present our Transformer GAN architecture ( s ) , before providing experimental results in Section 4 . We give an overview over related work in Section 5 before concluding in Section 6 . 2 PROBLEM DOMAIN AND BASE DATASETS . In this section , we introduce the two problem domains on which we base our experiments on : satisfiability of temporal specifications for formal verification and function integration and ordinary differential equations ( ODEs ) for symbolic mathematics . We furthermore give an overview over the data generation processes of these base datasets . 2.1 HARDWARE SPECIFICATIONS IN LINEAR-TIME TEMPORAL LOGIC ( LTL ) . Linear-time Temporal Logic ( LTL ) ( Pnueli , 1977 ) is the basis for industrial hardware specification languages like the IEEE standard PSL ( IEEE-Commission et al. , 2005 ) . It is an extension of propositional logic with temporal modalities , such as the Next-operator ( ) and the Until-operator ( U ) . There also exist derived operators , such as “ eventually ” ϕ ( ≡ true U ϕ ) and “ globally ” ϕ ( ≡ ¬ ¬ϕ ) . For example , mutual exclusion can be expressed as the following specification : ( ¬ ( accessp0 ∧ accessp1 ) , stating that processes p0 and p1 should have no access to a shared resource at the same time . The base problem of any logic is its satisfiability problem . It is the problem to decide whether there exists a solution to a given formula . The satisfiability problem of LTL is a hard problem , in fact , it is PSPACE-hard Sistla & Clarke ( 1982 ) . The full syntax , semantics and additional information on the satisfiability problem can be found in Appendix A . So far , the construction of datasets for LTL formulas has been done in two ways ( Hahn et al. , 2021 ) : Either by obtaining LTL formulas from a fully random generation process , which likely results in unrealistic formulas , or by sampling conjunctions of LTL specification patterns ( Dwyer et al. , 1999 ) . To obtain a healthy amount of unsatisfiable and satisfiable instances in this artificial generation process , we slightly refined the pattern-based generation method with two operations . Details can be found in Appendix B . Since the formula length correlates to unsatisfiability , we filter for equal proportions of classes per formula length . We restrict the tree size of the formulas to 50 . We call this dataset LTLbase . 2.2 SYMBOLIC MATHEMATICS . Lample & Charton ( 2020 ) showed that Transformer models perform surprisingly well on symbolic mathematics . More precisely , they applied the models to function integration and ordinary differential equations ( ODEs ) . We consider the function integration problem and use the forward generated dataset ( https : //github.com/facebookresearch/SymbolicMathematics ) . Random functions with up to n operators are generated and their integrals are calculated with computer algebra systems . Functions that the system can not integrate are discarded . Mathematical expressions are generated randomly . The dataset is cleaned , with equation simplification , coefficients simplification , and filtering out invalid expressions ( Lample & Charton , 2020 ) . We restrict the tree size to 50 . 3 ARCHITECTURE . The Transformer GAN architecture for generating symbolic reasoning problems ( TGAN-SR ) is depicted in Figure 1 . It consists of two Transformer encoders as discriminator/critic and generator , respectively . The inner layers of the encoders are largely identical to standard transformers ( Vaswani et al. , 2017 ) , but their input and output processing is adjusted to the GAN setting . We use an embedding dimension of demb = 128 , nh = 8 attention heads , and a feed-forward network dimension of dFF = 1024 for both encoders as default . The generator ’ s input is a real scalar random value with uniform distribution [ 0 , 1 ] for each position in the sequence . It is mapped to demb by an affine transformation before being processed by the first layer . The position-wise padding mask is copied from the real data during training , so the lengths of real and generated formulas at the same position in a batch are always identical . During inference , the lengths can either be sampled randomly or copied from an existing dataset similar to training . Either way , the generator encoder ’ s padding mask is predetermined so it has to adequately populate the unmasked positions . With V being the vocabulary , and |V | being the size of the vocabulary , an affine transformation to dimensionality |V | and a softmax is applied after the last layer . The generator ’ s output lies , thus , in the same space as one-hot encoded tokens . We use nlG = 6 layers for our default model ’ s generator . A GAN discriminator and WGAN critic are virtually identical in terms of their architecture . The only difference is that a critic outputs a real scalar value where a discriminator is limited to the range [ 0 , 1 ] , which we achieve by applying an additional logistic sigmoid in the end . To honor their differences regarding the training scheme , we use both terms when referring to exchangeable properties and make no further distinctions between them . For input processing , their |V |-dimensional ( per position ) input is mapped to demb by an affine transformation . After the last layer , the final embeddings are aggregated over the sequence by averaging and a linear projection to a scalar value ( the prediction logit ) is applied . Our default model uses nlD = 4 layers . We achieved best results with slightly more generator than discriminator/critic layers . A full hyperparameter study can be found in AppendixC.2 . Working in the |V |-sized one-hot domain poses harsh constraints on the generator ’ s output . Contrary to continuous domains were GANs are usually employed , each component of a real one-hot vector is , by definition , either 0 or 1 . If the generator were to identify this distribution and use it as criterion to tell real and generated instances apart , this would pose a serious difficulty for training . We therefore sample a |V |-sized vector of Gaussian noise N ( 0 , σ2real ) for each position ( see Figure 1 ) . We add it to the real samples ’ one-hot encoding and re-normalize it to sum 1 before handing them to the discriminator/critic . By default , we use a value of σreal = 0.1 for all models to get comparable results . We study the effect of different amounts of noise more closely in Section 4.1.2 . 4 EXPERIMENTS . In this section , we report our experimental findings . We structure our results in three sections . We first report on the performance of the TGAN-SR architecture in constructing syntactically correct instances of temporal specifications and mathematical expressions . Secondly , we show , exemplary for LTL formulas , that the newly generated dataset can be used as a substitute for the origin dataset . Lastly , we show , by altering the target distribution , that the network can generate a dataset that is harder to solve for a classifier . We trained the models on an NVIDIA DGX A100 system for around 8 hours . We begin each subsection with a short preamble on the training setting . 4.1 PRODUCING SYNTACTICALLY CORRECT SYMBOLIC REASONING PROBLEMS . The goal of the experiments in this section is to asses the generator ’ s capability in creating valid symbolic reasoning problems as objectively as possible . If not stated otherwise , in plots and tables , we report results from our default model averaged across three runs and with an exponential smoothing ( α = 0.95 ) applied . For temporal specifications , we use LTLbase as training set and for symbolic math the dataset described in section 2.2 . | Generating symbolic reasoning training data using transformer GANs. Use classifier uncertainty in the generator objective to generate samples that are harder for the classifier to solve than the original data. The problem is very interesting, but the empirical results could be improved. | SP:92073001584698ae0358e53e22f0603606f37602 |
Generating Symbolic Reasoning Problems with Transformer GANs | 1 INTRODUCTION . Deep learning is increasingly applied to more untraditional domains that involve complex symbolic reasoning . Examples include the application of deep neural network architectures to SAT ( Selsam et al. , 2019 ; Selsam & Bjørner , 2019 ; Ozolins et al. , 2021 ) , SMT ( Balunovic et al. , 2018 ) , temporal specifications in verification ( Hahn et al. , 2021 ; Schmitt et al. , 2021 ) , symbolic mathematics ( Lample & Charton , 2020 ) , or theorem proving ( Loos et al. , 2017 ; Bansal et al. , 2019 ; Huang et al. , 2019 ; Urban & Jakubuv , 2020 ) . The acquisition of training data for symbolic reasoning domains , however , is a challenge . Existing instances , such as benchmarks in competitions ( Biere & Claessen , 2010 ; Froleyks et al. , 2021 ; Jacobs et al. , 2017 ) are typically hand-crafted , for example , in a “ bring your own benchmarks ” setting ( Balyo et al. , 2017 ) . Since the instances are too few to be trained on , training data is , thus , typically generated synthetically . For example by random sampling ( Selsam et al. , 2019 ; Lample & Charton , 2020 ) , or by randomly re-combining parts of existing instances ( Schmitt et al. , 2021 ) . Although these data generation methods already lead to good results , training on randomly generated data carries the risk of training on meaningless data or the risk of introducing unwanted biases . In this paper , we study the generation of symbolic reasoning problems with Generative Adversarial Networks ( GANs ) ( Goodfellow et al. , 2014 ) and show that they can be used to construct large amounts of meaningful training data from a significantly smaller data source . GANs , however , can not immediately be applied : Symbolic reasoning problems reside typically in a discontinuous domain and , additionally , training data is typically sequential and of variable length . We show that training directly in the one-hot encoding space is possible when adding Gaussian noise to each position . We , furthermore , use a Transformer ( Vaswani et al. , 2017 ) encoder to cope with the sequential form of the data and the variable length of the problem instances . We provide experiments to show the usefulness of a GAN approach for the generation of reasoning problems . The experiments are based around two symbolic reasoning domains where recent studies on the applicability of deep learning relied on large amounts of artificially generated data : symbolic mathematics and linear-time temporal logic ( LTL ) specifications in verification . We report our experimental results in three sections . We first provide details on how to achieve a stable training of a standard GAN and a Wasserstein GAN ( Arjovsky et al. , 2017 ) both equipped with Transformer encoders . We analyze the particularities of their training behavior , such as the effects of adding different amounts of noise to the one hot embeddings . Secondly , we show for an LTL satisfiability classifier that the generated data can be used as a substitute for real training data , and , especially , that training data can be generated from a real dataset that is too small to be trained on directly . In particular , we show that out of 10K real training instances , a dataset consisting of 400K instances can be generated , on which a classifier can successfully be trained on . Lastly , we show that generating symbolic reasoning problems in a GAN setting has a specialty : We can alter the target distribution by adding a classifier uncertainty part to the generator objective . By doing this , we show that we can obtain a dataset that is even harder to solve than the original dataset which has been used to generate the data from . The remainder of this paper is structured as follows . In Section 2 , we give a short introduction to the problem domains considered in this paper and describe how the origin training data has been constructed . In Section 3 , we present our Transformer GAN architecture ( s ) , before providing experimental results in Section 4 . We give an overview over related work in Section 5 before concluding in Section 6 . 2 PROBLEM DOMAIN AND BASE DATASETS . In this section , we introduce the two problem domains on which we base our experiments on : satisfiability of temporal specifications for formal verification and function integration and ordinary differential equations ( ODEs ) for symbolic mathematics . We furthermore give an overview over the data generation processes of these base datasets . 2.1 HARDWARE SPECIFICATIONS IN LINEAR-TIME TEMPORAL LOGIC ( LTL ) . Linear-time Temporal Logic ( LTL ) ( Pnueli , 1977 ) is the basis for industrial hardware specification languages like the IEEE standard PSL ( IEEE-Commission et al. , 2005 ) . It is an extension of propositional logic with temporal modalities , such as the Next-operator ( ) and the Until-operator ( U ) . There also exist derived operators , such as “ eventually ” ϕ ( ≡ true U ϕ ) and “ globally ” ϕ ( ≡ ¬ ¬ϕ ) . For example , mutual exclusion can be expressed as the following specification : ( ¬ ( accessp0 ∧ accessp1 ) , stating that processes p0 and p1 should have no access to a shared resource at the same time . The base problem of any logic is its satisfiability problem . It is the problem to decide whether there exists a solution to a given formula . The satisfiability problem of LTL is a hard problem , in fact , it is PSPACE-hard Sistla & Clarke ( 1982 ) . The full syntax , semantics and additional information on the satisfiability problem can be found in Appendix A . So far , the construction of datasets for LTL formulas has been done in two ways ( Hahn et al. , 2021 ) : Either by obtaining LTL formulas from a fully random generation process , which likely results in unrealistic formulas , or by sampling conjunctions of LTL specification patterns ( Dwyer et al. , 1999 ) . To obtain a healthy amount of unsatisfiable and satisfiable instances in this artificial generation process , we slightly refined the pattern-based generation method with two operations . Details can be found in Appendix B . Since the formula length correlates to unsatisfiability , we filter for equal proportions of classes per formula length . We restrict the tree size of the formulas to 50 . We call this dataset LTLbase . 2.2 SYMBOLIC MATHEMATICS . Lample & Charton ( 2020 ) showed that Transformer models perform surprisingly well on symbolic mathematics . More precisely , they applied the models to function integration and ordinary differential equations ( ODEs ) . We consider the function integration problem and use the forward generated dataset ( https : //github.com/facebookresearch/SymbolicMathematics ) . Random functions with up to n operators are generated and their integrals are calculated with computer algebra systems . Functions that the system can not integrate are discarded . Mathematical expressions are generated randomly . The dataset is cleaned , with equation simplification , coefficients simplification , and filtering out invalid expressions ( Lample & Charton , 2020 ) . We restrict the tree size to 50 . 3 ARCHITECTURE . The Transformer GAN architecture for generating symbolic reasoning problems ( TGAN-SR ) is depicted in Figure 1 . It consists of two Transformer encoders as discriminator/critic and generator , respectively . The inner layers of the encoders are largely identical to standard transformers ( Vaswani et al. , 2017 ) , but their input and output processing is adjusted to the GAN setting . We use an embedding dimension of demb = 128 , nh = 8 attention heads , and a feed-forward network dimension of dFF = 1024 for both encoders as default . The generator ’ s input is a real scalar random value with uniform distribution [ 0 , 1 ] for each position in the sequence . It is mapped to demb by an affine transformation before being processed by the first layer . The position-wise padding mask is copied from the real data during training , so the lengths of real and generated formulas at the same position in a batch are always identical . During inference , the lengths can either be sampled randomly or copied from an existing dataset similar to training . Either way , the generator encoder ’ s padding mask is predetermined so it has to adequately populate the unmasked positions . With V being the vocabulary , and |V | being the size of the vocabulary , an affine transformation to dimensionality |V | and a softmax is applied after the last layer . The generator ’ s output lies , thus , in the same space as one-hot encoded tokens . We use nlG = 6 layers for our default model ’ s generator . A GAN discriminator and WGAN critic are virtually identical in terms of their architecture . The only difference is that a critic outputs a real scalar value where a discriminator is limited to the range [ 0 , 1 ] , which we achieve by applying an additional logistic sigmoid in the end . To honor their differences regarding the training scheme , we use both terms when referring to exchangeable properties and make no further distinctions between them . For input processing , their |V |-dimensional ( per position ) input is mapped to demb by an affine transformation . After the last layer , the final embeddings are aggregated over the sequence by averaging and a linear projection to a scalar value ( the prediction logit ) is applied . Our default model uses nlD = 4 layers . We achieved best results with slightly more generator than discriminator/critic layers . A full hyperparameter study can be found in AppendixC.2 . Working in the |V |-sized one-hot domain poses harsh constraints on the generator ’ s output . Contrary to continuous domains were GANs are usually employed , each component of a real one-hot vector is , by definition , either 0 or 1 . If the generator were to identify this distribution and use it as criterion to tell real and generated instances apart , this would pose a serious difficulty for training . We therefore sample a |V |-sized vector of Gaussian noise N ( 0 , σ2real ) for each position ( see Figure 1 ) . We add it to the real samples ’ one-hot encoding and re-normalize it to sum 1 before handing them to the discriminator/critic . By default , we use a value of σreal = 0.1 for all models to get comparable results . We study the effect of different amounts of noise more closely in Section 4.1.2 . 4 EXPERIMENTS . In this section , we report our experimental findings . We structure our results in three sections . We first report on the performance of the TGAN-SR architecture in constructing syntactically correct instances of temporal specifications and mathematical expressions . Secondly , we show , exemplary for LTL formulas , that the newly generated dataset can be used as a substitute for the origin dataset . Lastly , we show , by altering the target distribution , that the network can generate a dataset that is harder to solve for a classifier . We trained the models on an NVIDIA DGX A100 system for around 8 hours . We begin each subsection with a short preamble on the training setting . 4.1 PRODUCING SYNTACTICALLY CORRECT SYMBOLIC REASONING PROBLEMS . The goal of the experiments in this section is to asses the generator ’ s capability in creating valid symbolic reasoning problems as objectively as possible . If not stated otherwise , in plots and tables , we report results from our default model averaged across three runs and with an exponential smoothing ( α = 0.95 ) applied . For temporal specifications , we use LTLbase as training set and for symbolic math the dataset described in section 2.2 . | The authors apply (W)GANs with transformer encoders for data-augmentation in two symbolic domains: LTL and function integration. There are many interesting findings, three of which stand out. First, in both domains, the network learns to generate syntactically-correct examples roughly 30% of the time. Second, for LTL, a GAN trained on a dataset of size 10k can produce a much larger dataset, such that training on the new dataset is almost as good as training on the original distribution (when evaluating on the original distribution). Third, by also rewarding the generator for confusing a classifier, they can generate new problems that are harder to classify than those in the original distribution. | SP:92073001584698ae0358e53e22f0603606f37602 |
HyperCGAN: Text-to-Image Synthesis with HyperNet-Modulated Conditional Generative Adversarial Networks | 1 INTRODUCTION . Humans have the innate ability to connect what they visualize with language or textual descriptions . Text-to-image ( T2I ) synthesis , an AI task inspired by this ability , aims to correctly generate an image conditioned on a textual input description . Compared to other possible inputs in the conditional generation literature , sentences are an intuitive and flexible way to express visual content that we may want to generate . The main challenge in traditional T2I synthesis lies in learning from the unstructured description and in encoding and learning the different statistical properties of vision and language inputs . This field has seen significant progress in recent years in the quality of generated images , the size and complexity of datasets used , and in image-text alignment ( Xu et al. , 2018 ; Li et al. , 2019a ; Zhu et al. , 2019 ; Tao et al. , 2020 ; Zhang et al. , 2021 ; Ramesh et al. , 2021b ) . Existing methods for T2I can be broadly categorized based on the architecture innovations developed to condition on text . Models that condition on a single caption input include stacked architectures ( Zhang et al. , 2017 ) , attention mechanisms ( Xu et al. , 2018 ) ] , Siamese architectures ( Yin et al. , 2019 ) , cycle consistency approaches ( Qiao et al. , 2019 ) , and dynamic memory networks ( Zhu et al. , 2019 ) . A parallel line of work ( Yuan & Peng , 2019 ; Souza et al. , 2020 ; Wang et al. , 2020 ) looks at adapting unconditional models for T2I synthesis . In this work , we propose the HyperCGAN — a single-stage pipeline and general framework for T2I generation , which can efficiently generate both standard and continuous images from text . We show the generality of our method using the INR-GAN ( Skorokhodov et al. , 2021a ) backbone for generating continuous images and the StyleGAN2 ( Karras et al. , 2020 ) backbone for generating discrete pixel-based images . StyleGAN2 is a state-of-the-art model for discrete image generation and automatically learns and separates the highlevel attributes of and stochastic variations in the generated images , while INR-GAN is a recently introduced unconditional continuous image generator that significantly reduces the gap between continuous image GANs and pixel-based ones . Figure 10 shows generated discrete and continuous images on two datasets using the HyperCGAN framework . What is HyperCGAN ? Contrary to the prevailing T2I methods that condition their model on text embeddings c by updating a hidden representation h , we follow a different paradigm in HyperCGAN , and explore hypernetworks ( Ha et al. , 2016 ) that condition the model on textual information c by modulating the model weights . Such a procedure can be seen as creating a different instance of the model for each conditioning vector c and was recently shown ( Galanti & Wolf , 2020 ) to be a significantly more expressive mechanism than the embedding-based conditioning approaches prevalent in existing T2I literature . A traditional hypernetwork ( Chang et al. , 2020 ) generates the entire parameter vector θ from the conditioning signal c ie . θ = F ( c ) , but this quickly becomes infeasible as the number of parameters scale . In modern neural networks , |θ| easily spans millions of parameters . Thus we develop a general approach of altering a convolutional weight tensor W with a modulating hypernetwork F ( c ) . Our hypernetwork produces a modulation F ( c ) = M of the same size as the weight tensor W in a tensor-decomposed form . This tensor is then used to alter W via an elementwise multiplication operation Wc = W ⊙M ( c ) . The proposed approach is universal : we use exactly the same mechanism for both the generator and the discriminator , for continuous and discrete image generators and for conditioning on sentence-level or word-level signals . Typically , T2I models like AttnGAN ( Xu et al. , 2018 ) , ControlGAN ( Li et al. , 2019a ) , XMC-GAN ( Zhang et al. , 2021 ) , use vastly different architecture-specific ways to provide text information depending on whether it is the generator or the discriminator that is being conditioned , often along with additional text-matching losses . By comparison , the hyperconditioning mechanism in our approach is architecture agnostic . Our idea can be seen as a generalization of the mechanism used by StyleGAN2 to input noise information : in their work , the authors multiply the generator convolution weights W along the input channel dimension with scales γ corresponding to the input feature maps . In our model , 1 ) we use rich textual conditioning to modulate both G and D and 2 ) we develop a universal conditioning mechanism and demonstrate that sentence and attention based word level modulation , as well as continuous and discrete pixel-based generators can be effectively conditioned using our approach.3 ) HyperCGAN leverages word-level information with a novel language-guided tensor self-attention operator that modulates convolutional filters at the word level . Contributions . ( 1 ) We propose a general framework , named , HyperCGAN , for synthesizing photorealistic discrete and continuous images from text descriptions . The model is augmented with a novel language-guided mechanism that modulates convolutional filters at the word level . ( 2 ) We perform extensive qualitative and quantitative experiments validating our design choices and show the influence of the different components of our hypernetwork based language-guided modulation . ( 3 ) We show that our method has the ability to meaningfully extrapolate outside the image boundaries , and can outperform existing methods on COCO and ArtEmis datasets , including stacked generators and single generator methods . ( 4 ) We establish a strong baseline on a new affective T2I benchmark based on the recently proposed ArtEmis dataset ( Achlioptas et al. , 2021 ) , which has 455,000 affective utterances collected on more than 80K artworks . ArtEmis contains captions that explain emotions elicited by a visual stimulus , learning leverages learning that can lead to more human cognition-aware T2I synthesis generation models . 2 RELATED WORK . Text-to-Image Generation . T2I synthesis has been an active area of research since at least Mansimov et al . ( 2015 ) and Reed et al . ( 2016a ) proposed a DRAW-based ( Gregor et al. , 2015 ) model to generate images from captions . Reed et al . ( 2016a ) first demonstrated improved fidelity of the generated images from text using Generative Adversarial Networks ( GAN ) ( Goodfellow et al. , 2014 ) . Several GAN-based approaches for T2I synthesis have emerged since . StackGAN ( Zhang et al. , 2017 ) proposed decomposing the T2I generation into two stages - a coarse to fine approach generating a 64 × 64 image first and then the 256 × 256 image . They also proposed using conditional augmentation of the conditioning text . Later , AttnGAN ( Xu et al. , 2018 ) extended StackGAN to three stages and adopted cross-modal attention mechanisms for improved visual-semantic alignment and grounding . ControlGAN ( Li et al. , 2019a ) improved on AttnGAN by using a channel-wise attention-driven generator to disentangle different visual attributes , allowing the model to better focus on manipulating subregions corresponding to the most relevant words . Zhu et al . ( 2019 ) proposed DM-GAN , using a memory module on the AttnGAN stacked architecture . The memory module dynamically modulates fuzzy image contents when the initial images are not well generated . AttnGAN , ControlGAN , and DM-GAN are stacked architectures augmented with the Deep Attentional Multimodal Similarity Model ( DAMSM ) . The DAMSM loss aligns the text-image semantic based on word-region pairs . Tao et al . ( 2020 ) introduced DF-GAN that incorporates a Deep text-image Fusion block and Matching-Aware Gradient Penalty loss to encourage the visual semantic alignment . In this work we show that our hypernetwork based conditioning can beat the AttnGAN , ControlGAN , DM-GAN and DF-GAN baselines on image quality and image-text alignment . DALL-E ( Ramesh et al. , 2021a ) is 12-billion parameter version of GPT-3 ( Brown et al. , 2020 ) trained for T2I synthesis on large scale data . Their focus is on zero-shot generation with scale and can not be directly compared with our work . XMC-GAN ( Zhang et al. , 2021 ) recently used multiple contrastive losses to maximize the mutual information between image and text . They report significantly better FID scores , but we were unable to reproduce these scores using their repository . As a result , we do not include it as a baseline . There are non-GAN based works in T2I , e.g . ( Reed et al. , 2016b ; 2017 ) which try to synthesize images condition on text information in autoregressive fashion , and ( Mahajan et al. , 2020 ) which uses an invertible-neural network for solving tasks like image captioning and T2I synthesis . Art generation . Synthetically generating realistic artwork with conditional GAN is challenging due to the multiplicity of objects and unstructured-shapes in art as well as its abstract and metaphoric nature . It is less understood how capable neural representations are to learn these concepts about artistic evolution . Elgammal et al . ( 2018 ) , showed that high-level internal representations of a CNN ( LeCun et al. , 1995 ) trained for art style classification can learn the Wö ] lfflin principles of artwork . Art style is often recognized ( Lecoutre et al. , 2017 ; Tan et al. , 2016 ) as the most challenging class to grasp and several works have explored learning artistic style representations . ArtGAN ( Tan et al. , 2017 ; 2018 ) ] trained a conditional GAN on artist , genre , and style labels . Odena et al . ( 2017 ) ] proposed an emotion to art ( Alvarez-Melis & Amores , 2017 ) generative model by training an ACGAN on ten classes of emotions . Another line of work includes CAN ( Elgammal et al. , 2017 ) and later H-CAN ( Sbai et al. , 2018 ) , which are modified versions of GAN capable of generating creative art by learning about styles and deviating from style norms . Compared to these GANs , the hypernetwork-based conditioning we introduce in this paper can be applied to any GAN . We extend prior work in art generation by applying our conditioning to the novel text-to-continuous-image generation task . In this work , we also benchmark our model on the challenging ArtEmis ( Achlioptas et al. , 2021 ) dataset that contains captions explaining the emotions elicited by the corresponding art images . By using HyperCGAN to generate artistic images in our while being conditioned on the corresponding verbal explanations , we hope to better learn the relationship between symbolic and abstract components in human cognition aware T2I synthesis . Connection to HyperNetworks . Hypernetworks are models that generate parameters for other models . Generative Hypernetworks , also called implicit generators ( Skorokhodov et al. , 2021a ; Anokhin et al. , 2021 ) were recently shown to rival StyleGAN2 ( Karras et al. , 2020 ) . Hypernet- works have also been applied to several tasks in architecture search ( Zhang et al. , 2019 ) , few-shot learning ( Bertinetto et al. , 2016 ) , and continual learning ( von Oswald et al. , 2020 ) . Our HyperCGAN can generate continuous images conditioned on text using two types of Hypernetworks : ( 1 ) Image generator Hypernetworks , which produces an image represented by its implicit neural representation ( INR ) , a neural network Fθ ( x , y ) that predicts an RGB pixel value given its ( x , y ) coordinate . ( 2 ) Text controlling Hypernetworks guides the learning mechanism of the image generator Hypernetwork with the input text . Despite the progress on unconditional INR-based decoders ( e.g. , Lin et al . ( 2019 ) ; Skorokhodov et al . ( 2021a ) ; Anokhin et al . ( 2021 ) ; Skorokhodov et al . ( 2021b ) ) , generation high-quality continuous images conditioned on text is less studied compared to discrete image generators . Our Hypernetworks augmented modulation approach facilitates conditioning the continuous image generator on text while preserving the desired INR properties ( e.g. , out-of-the-box-super resolution , extrapolation outside image boundaries ) . | Authors explore the application of hypernetworks for text-to-image generation. Given the input text description, the hypernetworks learn the weights of convolution. Instead of directly leveraging hypernetworks, author propose to modulate the convolutional weights by the generated weights. To validate the generalization of the proposed method, authors perform experiments on two generation architecture: StyleGAN and INR-GAN. Furthermore, since hypernetworks lead to memory-intensive problem when using it to generate the weights for each block, authors introduce new method to address this issue. The quantitative and qualitative results support the effectiveness of the proposed method. | SP:6ba32b095cf7d8ce985903e81de0af1a0a43a7b8 |
HyperCGAN: Text-to-Image Synthesis with HyperNet-Modulated Conditional Generative Adversarial Networks | 1 INTRODUCTION . Humans have the innate ability to connect what they visualize with language or textual descriptions . Text-to-image ( T2I ) synthesis , an AI task inspired by this ability , aims to correctly generate an image conditioned on a textual input description . Compared to other possible inputs in the conditional generation literature , sentences are an intuitive and flexible way to express visual content that we may want to generate . The main challenge in traditional T2I synthesis lies in learning from the unstructured description and in encoding and learning the different statistical properties of vision and language inputs . This field has seen significant progress in recent years in the quality of generated images , the size and complexity of datasets used , and in image-text alignment ( Xu et al. , 2018 ; Li et al. , 2019a ; Zhu et al. , 2019 ; Tao et al. , 2020 ; Zhang et al. , 2021 ; Ramesh et al. , 2021b ) . Existing methods for T2I can be broadly categorized based on the architecture innovations developed to condition on text . Models that condition on a single caption input include stacked architectures ( Zhang et al. , 2017 ) , attention mechanisms ( Xu et al. , 2018 ) ] , Siamese architectures ( Yin et al. , 2019 ) , cycle consistency approaches ( Qiao et al. , 2019 ) , and dynamic memory networks ( Zhu et al. , 2019 ) . A parallel line of work ( Yuan & Peng , 2019 ; Souza et al. , 2020 ; Wang et al. , 2020 ) looks at adapting unconditional models for T2I synthesis . In this work , we propose the HyperCGAN — a single-stage pipeline and general framework for T2I generation , which can efficiently generate both standard and continuous images from text . We show the generality of our method using the INR-GAN ( Skorokhodov et al. , 2021a ) backbone for generating continuous images and the StyleGAN2 ( Karras et al. , 2020 ) backbone for generating discrete pixel-based images . StyleGAN2 is a state-of-the-art model for discrete image generation and automatically learns and separates the highlevel attributes of and stochastic variations in the generated images , while INR-GAN is a recently introduced unconditional continuous image generator that significantly reduces the gap between continuous image GANs and pixel-based ones . Figure 10 shows generated discrete and continuous images on two datasets using the HyperCGAN framework . What is HyperCGAN ? Contrary to the prevailing T2I methods that condition their model on text embeddings c by updating a hidden representation h , we follow a different paradigm in HyperCGAN , and explore hypernetworks ( Ha et al. , 2016 ) that condition the model on textual information c by modulating the model weights . Such a procedure can be seen as creating a different instance of the model for each conditioning vector c and was recently shown ( Galanti & Wolf , 2020 ) to be a significantly more expressive mechanism than the embedding-based conditioning approaches prevalent in existing T2I literature . A traditional hypernetwork ( Chang et al. , 2020 ) generates the entire parameter vector θ from the conditioning signal c ie . θ = F ( c ) , but this quickly becomes infeasible as the number of parameters scale . In modern neural networks , |θ| easily spans millions of parameters . Thus we develop a general approach of altering a convolutional weight tensor W with a modulating hypernetwork F ( c ) . Our hypernetwork produces a modulation F ( c ) = M of the same size as the weight tensor W in a tensor-decomposed form . This tensor is then used to alter W via an elementwise multiplication operation Wc = W ⊙M ( c ) . The proposed approach is universal : we use exactly the same mechanism for both the generator and the discriminator , for continuous and discrete image generators and for conditioning on sentence-level or word-level signals . Typically , T2I models like AttnGAN ( Xu et al. , 2018 ) , ControlGAN ( Li et al. , 2019a ) , XMC-GAN ( Zhang et al. , 2021 ) , use vastly different architecture-specific ways to provide text information depending on whether it is the generator or the discriminator that is being conditioned , often along with additional text-matching losses . By comparison , the hyperconditioning mechanism in our approach is architecture agnostic . Our idea can be seen as a generalization of the mechanism used by StyleGAN2 to input noise information : in their work , the authors multiply the generator convolution weights W along the input channel dimension with scales γ corresponding to the input feature maps . In our model , 1 ) we use rich textual conditioning to modulate both G and D and 2 ) we develop a universal conditioning mechanism and demonstrate that sentence and attention based word level modulation , as well as continuous and discrete pixel-based generators can be effectively conditioned using our approach.3 ) HyperCGAN leverages word-level information with a novel language-guided tensor self-attention operator that modulates convolutional filters at the word level . Contributions . ( 1 ) We propose a general framework , named , HyperCGAN , for synthesizing photorealistic discrete and continuous images from text descriptions . The model is augmented with a novel language-guided mechanism that modulates convolutional filters at the word level . ( 2 ) We perform extensive qualitative and quantitative experiments validating our design choices and show the influence of the different components of our hypernetwork based language-guided modulation . ( 3 ) We show that our method has the ability to meaningfully extrapolate outside the image boundaries , and can outperform existing methods on COCO and ArtEmis datasets , including stacked generators and single generator methods . ( 4 ) We establish a strong baseline on a new affective T2I benchmark based on the recently proposed ArtEmis dataset ( Achlioptas et al. , 2021 ) , which has 455,000 affective utterances collected on more than 80K artworks . ArtEmis contains captions that explain emotions elicited by a visual stimulus , learning leverages learning that can lead to more human cognition-aware T2I synthesis generation models . 2 RELATED WORK . Text-to-Image Generation . T2I synthesis has been an active area of research since at least Mansimov et al . ( 2015 ) and Reed et al . ( 2016a ) proposed a DRAW-based ( Gregor et al. , 2015 ) model to generate images from captions . Reed et al . ( 2016a ) first demonstrated improved fidelity of the generated images from text using Generative Adversarial Networks ( GAN ) ( Goodfellow et al. , 2014 ) . Several GAN-based approaches for T2I synthesis have emerged since . StackGAN ( Zhang et al. , 2017 ) proposed decomposing the T2I generation into two stages - a coarse to fine approach generating a 64 × 64 image first and then the 256 × 256 image . They also proposed using conditional augmentation of the conditioning text . Later , AttnGAN ( Xu et al. , 2018 ) extended StackGAN to three stages and adopted cross-modal attention mechanisms for improved visual-semantic alignment and grounding . ControlGAN ( Li et al. , 2019a ) improved on AttnGAN by using a channel-wise attention-driven generator to disentangle different visual attributes , allowing the model to better focus on manipulating subregions corresponding to the most relevant words . Zhu et al . ( 2019 ) proposed DM-GAN , using a memory module on the AttnGAN stacked architecture . The memory module dynamically modulates fuzzy image contents when the initial images are not well generated . AttnGAN , ControlGAN , and DM-GAN are stacked architectures augmented with the Deep Attentional Multimodal Similarity Model ( DAMSM ) . The DAMSM loss aligns the text-image semantic based on word-region pairs . Tao et al . ( 2020 ) introduced DF-GAN that incorporates a Deep text-image Fusion block and Matching-Aware Gradient Penalty loss to encourage the visual semantic alignment . In this work we show that our hypernetwork based conditioning can beat the AttnGAN , ControlGAN , DM-GAN and DF-GAN baselines on image quality and image-text alignment . DALL-E ( Ramesh et al. , 2021a ) is 12-billion parameter version of GPT-3 ( Brown et al. , 2020 ) trained for T2I synthesis on large scale data . Their focus is on zero-shot generation with scale and can not be directly compared with our work . XMC-GAN ( Zhang et al. , 2021 ) recently used multiple contrastive losses to maximize the mutual information between image and text . They report significantly better FID scores , but we were unable to reproduce these scores using their repository . As a result , we do not include it as a baseline . There are non-GAN based works in T2I , e.g . ( Reed et al. , 2016b ; 2017 ) which try to synthesize images condition on text information in autoregressive fashion , and ( Mahajan et al. , 2020 ) which uses an invertible-neural network for solving tasks like image captioning and T2I synthesis . Art generation . Synthetically generating realistic artwork with conditional GAN is challenging due to the multiplicity of objects and unstructured-shapes in art as well as its abstract and metaphoric nature . It is less understood how capable neural representations are to learn these concepts about artistic evolution . Elgammal et al . ( 2018 ) , showed that high-level internal representations of a CNN ( LeCun et al. , 1995 ) trained for art style classification can learn the Wö ] lfflin principles of artwork . Art style is often recognized ( Lecoutre et al. , 2017 ; Tan et al. , 2016 ) as the most challenging class to grasp and several works have explored learning artistic style representations . ArtGAN ( Tan et al. , 2017 ; 2018 ) ] trained a conditional GAN on artist , genre , and style labels . Odena et al . ( 2017 ) ] proposed an emotion to art ( Alvarez-Melis & Amores , 2017 ) generative model by training an ACGAN on ten classes of emotions . Another line of work includes CAN ( Elgammal et al. , 2017 ) and later H-CAN ( Sbai et al. , 2018 ) , which are modified versions of GAN capable of generating creative art by learning about styles and deviating from style norms . Compared to these GANs , the hypernetwork-based conditioning we introduce in this paper can be applied to any GAN . We extend prior work in art generation by applying our conditioning to the novel text-to-continuous-image generation task . In this work , we also benchmark our model on the challenging ArtEmis ( Achlioptas et al. , 2021 ) dataset that contains captions explaining the emotions elicited by the corresponding art images . By using HyperCGAN to generate artistic images in our while being conditioned on the corresponding verbal explanations , we hope to better learn the relationship between symbolic and abstract components in human cognition aware T2I synthesis . Connection to HyperNetworks . Hypernetworks are models that generate parameters for other models . Generative Hypernetworks , also called implicit generators ( Skorokhodov et al. , 2021a ; Anokhin et al. , 2021 ) were recently shown to rival StyleGAN2 ( Karras et al. , 2020 ) . Hypernet- works have also been applied to several tasks in architecture search ( Zhang et al. , 2019 ) , few-shot learning ( Bertinetto et al. , 2016 ) , and continual learning ( von Oswald et al. , 2020 ) . Our HyperCGAN can generate continuous images conditioned on text using two types of Hypernetworks : ( 1 ) Image generator Hypernetworks , which produces an image represented by its implicit neural representation ( INR ) , a neural network Fθ ( x , y ) that predicts an RGB pixel value given its ( x , y ) coordinate . ( 2 ) Text controlling Hypernetworks guides the learning mechanism of the image generator Hypernetwork with the input text . Despite the progress on unconditional INR-based decoders ( e.g. , Lin et al . ( 2019 ) ; Skorokhodov et al . ( 2021a ) ; Anokhin et al . ( 2021 ) ; Skorokhodov et al . ( 2021b ) ) , generation high-quality continuous images conditioned on text is less studied compared to discrete image generators . Our Hypernetworks augmented modulation approach facilitates conditioning the continuous image generator on text while preserving the desired INR properties ( e.g. , out-of-the-box-super resolution , extrapolation outside image boundaries ) . | The paper proposes a hyper-network based conditional approach for text-to-image synthesis. A hypernetwork takes as input the text representation and outputs a 4-D variable. This modulates the convolutions of both the generator and discriminator of the Generative Adversarial Network pointwise. Since predicting a 4-D Tensor is impractical, the hypernetwork predicts a low-rank decomposition, from which the 4-D variable can be constructed via tensor products. The authors showcase this approach on a StyleGAN v2 backbone for discrete image synthesis and INR-GAN backbone for continuous image synthesis on COCO, CUB and ArtEmis Dataset. | SP:6ba32b095cf7d8ce985903e81de0af1a0a43a7b8 |
HyperCGAN: Text-to-Image Synthesis with HyperNet-Modulated Conditional Generative Adversarial Networks | 1 INTRODUCTION . Humans have the innate ability to connect what they visualize with language or textual descriptions . Text-to-image ( T2I ) synthesis , an AI task inspired by this ability , aims to correctly generate an image conditioned on a textual input description . Compared to other possible inputs in the conditional generation literature , sentences are an intuitive and flexible way to express visual content that we may want to generate . The main challenge in traditional T2I synthesis lies in learning from the unstructured description and in encoding and learning the different statistical properties of vision and language inputs . This field has seen significant progress in recent years in the quality of generated images , the size and complexity of datasets used , and in image-text alignment ( Xu et al. , 2018 ; Li et al. , 2019a ; Zhu et al. , 2019 ; Tao et al. , 2020 ; Zhang et al. , 2021 ; Ramesh et al. , 2021b ) . Existing methods for T2I can be broadly categorized based on the architecture innovations developed to condition on text . Models that condition on a single caption input include stacked architectures ( Zhang et al. , 2017 ) , attention mechanisms ( Xu et al. , 2018 ) ] , Siamese architectures ( Yin et al. , 2019 ) , cycle consistency approaches ( Qiao et al. , 2019 ) , and dynamic memory networks ( Zhu et al. , 2019 ) . A parallel line of work ( Yuan & Peng , 2019 ; Souza et al. , 2020 ; Wang et al. , 2020 ) looks at adapting unconditional models for T2I synthesis . In this work , we propose the HyperCGAN — a single-stage pipeline and general framework for T2I generation , which can efficiently generate both standard and continuous images from text . We show the generality of our method using the INR-GAN ( Skorokhodov et al. , 2021a ) backbone for generating continuous images and the StyleGAN2 ( Karras et al. , 2020 ) backbone for generating discrete pixel-based images . StyleGAN2 is a state-of-the-art model for discrete image generation and automatically learns and separates the highlevel attributes of and stochastic variations in the generated images , while INR-GAN is a recently introduced unconditional continuous image generator that significantly reduces the gap between continuous image GANs and pixel-based ones . Figure 10 shows generated discrete and continuous images on two datasets using the HyperCGAN framework . What is HyperCGAN ? Contrary to the prevailing T2I methods that condition their model on text embeddings c by updating a hidden representation h , we follow a different paradigm in HyperCGAN , and explore hypernetworks ( Ha et al. , 2016 ) that condition the model on textual information c by modulating the model weights . Such a procedure can be seen as creating a different instance of the model for each conditioning vector c and was recently shown ( Galanti & Wolf , 2020 ) to be a significantly more expressive mechanism than the embedding-based conditioning approaches prevalent in existing T2I literature . A traditional hypernetwork ( Chang et al. , 2020 ) generates the entire parameter vector θ from the conditioning signal c ie . θ = F ( c ) , but this quickly becomes infeasible as the number of parameters scale . In modern neural networks , |θ| easily spans millions of parameters . Thus we develop a general approach of altering a convolutional weight tensor W with a modulating hypernetwork F ( c ) . Our hypernetwork produces a modulation F ( c ) = M of the same size as the weight tensor W in a tensor-decomposed form . This tensor is then used to alter W via an elementwise multiplication operation Wc = W ⊙M ( c ) . The proposed approach is universal : we use exactly the same mechanism for both the generator and the discriminator , for continuous and discrete image generators and for conditioning on sentence-level or word-level signals . Typically , T2I models like AttnGAN ( Xu et al. , 2018 ) , ControlGAN ( Li et al. , 2019a ) , XMC-GAN ( Zhang et al. , 2021 ) , use vastly different architecture-specific ways to provide text information depending on whether it is the generator or the discriminator that is being conditioned , often along with additional text-matching losses . By comparison , the hyperconditioning mechanism in our approach is architecture agnostic . Our idea can be seen as a generalization of the mechanism used by StyleGAN2 to input noise information : in their work , the authors multiply the generator convolution weights W along the input channel dimension with scales γ corresponding to the input feature maps . In our model , 1 ) we use rich textual conditioning to modulate both G and D and 2 ) we develop a universal conditioning mechanism and demonstrate that sentence and attention based word level modulation , as well as continuous and discrete pixel-based generators can be effectively conditioned using our approach.3 ) HyperCGAN leverages word-level information with a novel language-guided tensor self-attention operator that modulates convolutional filters at the word level . Contributions . ( 1 ) We propose a general framework , named , HyperCGAN , for synthesizing photorealistic discrete and continuous images from text descriptions . The model is augmented with a novel language-guided mechanism that modulates convolutional filters at the word level . ( 2 ) We perform extensive qualitative and quantitative experiments validating our design choices and show the influence of the different components of our hypernetwork based language-guided modulation . ( 3 ) We show that our method has the ability to meaningfully extrapolate outside the image boundaries , and can outperform existing methods on COCO and ArtEmis datasets , including stacked generators and single generator methods . ( 4 ) We establish a strong baseline on a new affective T2I benchmark based on the recently proposed ArtEmis dataset ( Achlioptas et al. , 2021 ) , which has 455,000 affective utterances collected on more than 80K artworks . ArtEmis contains captions that explain emotions elicited by a visual stimulus , learning leverages learning that can lead to more human cognition-aware T2I synthesis generation models . 2 RELATED WORK . Text-to-Image Generation . T2I synthesis has been an active area of research since at least Mansimov et al . ( 2015 ) and Reed et al . ( 2016a ) proposed a DRAW-based ( Gregor et al. , 2015 ) model to generate images from captions . Reed et al . ( 2016a ) first demonstrated improved fidelity of the generated images from text using Generative Adversarial Networks ( GAN ) ( Goodfellow et al. , 2014 ) . Several GAN-based approaches for T2I synthesis have emerged since . StackGAN ( Zhang et al. , 2017 ) proposed decomposing the T2I generation into two stages - a coarse to fine approach generating a 64 × 64 image first and then the 256 × 256 image . They also proposed using conditional augmentation of the conditioning text . Later , AttnGAN ( Xu et al. , 2018 ) extended StackGAN to three stages and adopted cross-modal attention mechanisms for improved visual-semantic alignment and grounding . ControlGAN ( Li et al. , 2019a ) improved on AttnGAN by using a channel-wise attention-driven generator to disentangle different visual attributes , allowing the model to better focus on manipulating subregions corresponding to the most relevant words . Zhu et al . ( 2019 ) proposed DM-GAN , using a memory module on the AttnGAN stacked architecture . The memory module dynamically modulates fuzzy image contents when the initial images are not well generated . AttnGAN , ControlGAN , and DM-GAN are stacked architectures augmented with the Deep Attentional Multimodal Similarity Model ( DAMSM ) . The DAMSM loss aligns the text-image semantic based on word-region pairs . Tao et al . ( 2020 ) introduced DF-GAN that incorporates a Deep text-image Fusion block and Matching-Aware Gradient Penalty loss to encourage the visual semantic alignment . In this work we show that our hypernetwork based conditioning can beat the AttnGAN , ControlGAN , DM-GAN and DF-GAN baselines on image quality and image-text alignment . DALL-E ( Ramesh et al. , 2021a ) is 12-billion parameter version of GPT-3 ( Brown et al. , 2020 ) trained for T2I synthesis on large scale data . Their focus is on zero-shot generation with scale and can not be directly compared with our work . XMC-GAN ( Zhang et al. , 2021 ) recently used multiple contrastive losses to maximize the mutual information between image and text . They report significantly better FID scores , but we were unable to reproduce these scores using their repository . As a result , we do not include it as a baseline . There are non-GAN based works in T2I , e.g . ( Reed et al. , 2016b ; 2017 ) which try to synthesize images condition on text information in autoregressive fashion , and ( Mahajan et al. , 2020 ) which uses an invertible-neural network for solving tasks like image captioning and T2I synthesis . Art generation . Synthetically generating realistic artwork with conditional GAN is challenging due to the multiplicity of objects and unstructured-shapes in art as well as its abstract and metaphoric nature . It is less understood how capable neural representations are to learn these concepts about artistic evolution . Elgammal et al . ( 2018 ) , showed that high-level internal representations of a CNN ( LeCun et al. , 1995 ) trained for art style classification can learn the Wö ] lfflin principles of artwork . Art style is often recognized ( Lecoutre et al. , 2017 ; Tan et al. , 2016 ) as the most challenging class to grasp and several works have explored learning artistic style representations . ArtGAN ( Tan et al. , 2017 ; 2018 ) ] trained a conditional GAN on artist , genre , and style labels . Odena et al . ( 2017 ) ] proposed an emotion to art ( Alvarez-Melis & Amores , 2017 ) generative model by training an ACGAN on ten classes of emotions . Another line of work includes CAN ( Elgammal et al. , 2017 ) and later H-CAN ( Sbai et al. , 2018 ) , which are modified versions of GAN capable of generating creative art by learning about styles and deviating from style norms . Compared to these GANs , the hypernetwork-based conditioning we introduce in this paper can be applied to any GAN . We extend prior work in art generation by applying our conditioning to the novel text-to-continuous-image generation task . In this work , we also benchmark our model on the challenging ArtEmis ( Achlioptas et al. , 2021 ) dataset that contains captions explaining the emotions elicited by the corresponding art images . By using HyperCGAN to generate artistic images in our while being conditioned on the corresponding verbal explanations , we hope to better learn the relationship between symbolic and abstract components in human cognition aware T2I synthesis . Connection to HyperNetworks . Hypernetworks are models that generate parameters for other models . Generative Hypernetworks , also called implicit generators ( Skorokhodov et al. , 2021a ; Anokhin et al. , 2021 ) were recently shown to rival StyleGAN2 ( Karras et al. , 2020 ) . Hypernet- works have also been applied to several tasks in architecture search ( Zhang et al. , 2019 ) , few-shot learning ( Bertinetto et al. , 2016 ) , and continual learning ( von Oswald et al. , 2020 ) . Our HyperCGAN can generate continuous images conditioned on text using two types of Hypernetworks : ( 1 ) Image generator Hypernetworks , which produces an image represented by its implicit neural representation ( INR ) , a neural network Fθ ( x , y ) that predicts an RGB pixel value given its ( x , y ) coordinate . ( 2 ) Text controlling Hypernetworks guides the learning mechanism of the image generator Hypernetwork with the input text . Despite the progress on unconditional INR-based decoders ( e.g. , Lin et al . ( 2019 ) ; Skorokhodov et al . ( 2021a ) ; Anokhin et al . ( 2021 ) ; Skorokhodov et al . ( 2021b ) ) , generation high-quality continuous images conditioned on text is less studied compared to discrete image generators . Our Hypernetworks augmented modulation approach facilitates conditioning the continuous image generator on text while preserving the desired INR properties ( e.g. , out-of-the-box-super resolution , extrapolation outside image boundaries ) . | The paper proposes a novel approach for text-to-image synthesis. Instead of training the weights of a GAN directly the approach is to train a HyperNet which modulates the GAN's weights based on the text condition. The approach is evaluated for both StyleGAN2 and INR-GAN (a continuous GAN) and obtains good results compared to current baselines. | SP:6ba32b095cf7d8ce985903e81de0af1a0a43a7b8 |
A Rate-Distortion Approach to Domain Generalization | Domain generalization deals with the difference in the distribution between the training and testing datasets , i.e. , the domain shift problem . A principled approach to domain generalization is by extracting domain-invariant features . In this paper , we propose an information-theoretic approach for domain generalization . We first establish the domain transformation model , mapping a domain-free latent image into a domain . Then , we cast the domain generalization as a rate-distortion problem , and use the information bottleneck penalty to measure how well the domain-free latent image is reconstructed from a compressed representation of a domain-specific image compared to its direct prediction from the domain-specific image itself . We prove that the information bottleneck penalty guarantees that domain-invariant features can be learned . Lastly , we draw links of our proposed method with selfsupervised contrastive learning without negative data pairs . Our empirical study on two different tasks verifies the improvement over recent baselines . 1 INTRODUCTION . Deep neural networks ( DNNs ) are highly expressive models that reach state-of-the-art performance in challenging tasks , such as speech and visual recognition ( Devlin et al. , 2018 ; He et al. , 2016 ) , by capturing complex correlations among input elements , e.g. , pixels of an image . However , the correlations might also contain spurious features that hurt the generalization performance of DNNs on out-of-distribution samples ( Szegedy et al. , 2013 ; Beery et al. , 2018 ; Alcorn et al. , 2019 ) . Unfortunately , real-world applications often encounter such out-of-distribution samples , e.g. , when the training domain does not match the testing domain . A prominent example is deblurring , where models are trained on simulated blurs which differ substantially to real-world blurring ( Koh et al. , 2021 ) . In other words , generalization across domains is a critical task before deploying DNNs to real-world application . Learning features that are invariant across multiple training domains , and using those features for out-of-distribution generalization has emerged as a significant topic in domain generalization . In domain generalization , multiple source domains are accessible during training , but the target domains are not ( Blanchard et al. , 2011 ; Muandet et al. , 2013 ) . Invariant risk minimization ( IRM ) ( Arjovsky et al. , 2019 ) is a prominent approach for learning domain invariant features . However , IRM suffers from the case when the invariant features contains full information about the label ( Ahuja et al. , 2020 ) . To deal with this shortcoming , Ahuja et al . ( 2021 ) introduce the information bottleneck theory on neural networks ( Tishby & Zaslavsky , 2015 ) , and show that their method will be guaranteed to converge to the invariant features . On the empirical side , a series of works align source domain distributions for domain-invariant representation learning by either direct construct auxiliary penalty ( Duan et al. , 2012 ; Sun & Saenko , 2016 ; Li et al. , 2018b ; c ; 2017 ; Niu et al. , 2015 ) , or meta learning ( Li et al. , 2019 ; Balaji et al. , 2018 ; Li et al. , 2018a ) . There are also series of work do not rely on invariant features . They can be categorized as ( 1 ) domainspecific method : Domain2Vec ( D2V ) ( Deshmukh et al. , 2018 ) learns domain-specific embedding , DMG ( Chattopadhyay et al. , 2020 ) aims to learn domain specific masks ; and ( 2 ) augmentation method : ( Volpi et al. , 2018 ) augments the dataset adversarially , L2A-OT ( Zhou et al. , 2020 ) augments data with image information . Despite their success , there is no guarantee that empirical methods can solve the task across different environments . In this paper , we use an information-theoretic approach to tackle domain generalization . We assume there is a domain-free latent instance ( e.g. , an image ) that captures the invariant features we want to extract . We define a domain transformation model that maps the domain-free latent instance into a domain and then we apply the rate distortion theory to obtain a domain-invariant representation . The proposed method , called Twins , is guaranteed to converge to the invariant feature under the linear classification structural equation model ( Ahuja et al. , 2021 ) . We evaluate our method on linear unit tests ( Aubin et al. , 2021 ) and variants of MNIST dataset ( LeCun & Cortes , 2010 ; Xiao et al. , 2017 ; Clanuwat et al. , 2018 ) , which validates the theoretical analysis and demonstrates how the proposed method can outperform the previous ones . Our contributions can be summarized as follows : • We cast domain generalization as a rate distortion problem and prove how the proposed method can converge . • We illustrate how the proposed method extends previous results on domain generalization , and draw links to self-supervised contrastive learning . We demystify the success of contrastive learning by giving a contrastive learning based domain generalization algorithm with theoretical guarantee . • We evaluate our method on two datasets and observe consistent improvement over existing baselines . 2 PRELIMINARY ON DOMAIN GENERALIZATION . Assume that the instance-label pair ( X , Y ) is sampled from an unknown distribution P ( X , Y ) . The objective of standard supervised learning is to learn a predictor f that is able to predict the labels Y of corresponding instances X for each ( X , Y ) ∼ P ( X , Y ) , given the finite training samples drawn from the underlying distribution P ( X , Y ) . Unlike the standard supervised learning tasks , in domain generalization , we can not sample directly from the distribution P ( X , Y ) . Instead , we can only observe ( X , Y ) under different domains e ∈ Eall , denoted as ( Xe , Y e ) ∼ Pe ( Xe , Y e ) . We also assume that e ∈ Eall is distributed as e ∼ Pe . Given samples from a finite subset Etrain ( Eall of all the domains , the goal of the domain generalization problem is to learn a predictor f that generalizes across all possible domains . This can be summarized as follows : Problem 2.1 ( Domain generalization ) . Let Etrain ( Eall be a finite subset of training domains . We have access to the data for each training domain etrain ∈ Etrain , but have no access to the data for each test domain etest ∈ Eall\Etrain . Given a function classF and a loss function ` , our goal is to learn a predictor f ∈ F using the data from the training domain such that f minimizes the worst-case risk over Eall . Define the risk of the predictor f on the domain e as Re ( f ) : = EPe ( Xe , Y e ) ` ( f ( Xe ) , Y e ) . We want to solve the following min-max optimization problem : minimize f∈F max e∈Eall Re ( f ) . ( DG ) We establish the domain transformation model to characterize the relation between domain-aware instance Xe and the domain-invariant latent instance X in the Assumption 1 , which first appears in Robey et al . ( 2021 ) . Assumption 1 ( Domain transformation model ) . Let δe denote a Dirac distribution for e ∈ Eall . We assume that there exists a measurable function G : X × Eall → X , which we refer to as a domain transformation model , that parameterizes the inter-domain covariate shift via Pe ( X ) =d G # ( P ( X ) × δe ) ∀e ∈ Eall , ( 1 ) where # denotes the push-forward measure and =d denotes equality in distribution . The Assumption 1 can somewhat reflect the generation of domain specific instances . For example , the multiple different views of a 3D object ( Niu et al. , 2015 ) , different angles of the image ( Rotated MNIST ( Worrall et al. , 2017 ) ) . Besides , the MUNIT architecture ( Huang et al. , 2018 ) can effectively distangle the domain-free latent instance X and the specific environment e , and thus can be used as the domain transformation model G ( Robey et al. , 2021 ) . Let Φ denote the feature representation mapping , w denote the classifier and w ◦ Φ denote the full predictor . The regret of the network on the domain e is denoted as Re ( w ◦ Φ ) . Next , we define standard properties related to the datasets used in the domain generalization literature ( Ahuja et al. , 2021 ) . For each e ∈ Eall , the distribution ( Xe , Y e ) ∼ Pe satisfies the following properties : ( 1 ) ∃ a map Φ∗ , which we call an invariant feature map , such that E [ Y e ∣∣Φ∗ ( Xe ) ] is the same for all e ∈ Eall and Y e 6⊥ Φ∗ ( Xe ) , where ⊥ means mutual independence . ( 2 ) ∃ a map Ψ∗ , which we call spurious feature map , such that E [ Y e ∣∣Ψ∗ ( Xe ) ] is not the same for all e ∈ Eall and Y e 6⊥ Ψ∗ ( Xe ) for some domains . Ψ∗ often hinders learning predictors that only rely on Φ∗ . For example , in the CMNIST dataset , the Φ ? extracts the underlying digit and Ψ ? extracts background color . The baseline algorithm for domain generalization Equation ( DG ) is the Empirical Risk Minimization , i.e . directly minimizing the empirical risk on the training domains : min w , Φ 1 |Etrain| ∑ e∈Etrain Re ( w ◦ Φ ) , ( 2 ) where |Etrain| denotes the number of training domains . We say that a data representation Φ elicits an invariant predictor across the set of training domains Etrain if there is a predictor w that simultaneously achieves the minimum risk , i.e . w ∈ arg minw′ Re ( w′ ◦ Φ ) , ∀e ∈ Etrain . Using this notation , the main objective of Invariant Risk Minimization ( IRM ) is stated as : min w , Φ 1 |Etrain| ∑ e∈Etrain Re ( w ◦ Φ ) , s.t . w ∈ arg min w′ Re ( w′ ◦ Φ ) , ∀e ∈ Etrain . ( 3 ) Lastly , we rely on the notion of ‘ informativeness ’ about the datasets ( Ahuja et al. , 2021 ) . There are two such categories of informativeness . In the first case , the invariant features Φ∗ ( Xe ) are partially informative about the label , i.e . Y 6⊥ Xe|Φ∗ ( Xe ) , and color contains information about label not contained in the uncolored digit . In the second case , invariant features are fully informative about the label , i.e. , Y ⊥ Xe|Φ∗ ( Xe ) , i.e. , they contain all the information about the label that is contained in input Xe . Many real-world image datasets have fully informative invariant features , the labels are a deterministic function of the domain-invariant features and domain-aware spurious features do not affect the label . 3 METHOD . 3.1 RATE DISTORTION & INFORMATION BOTTLENECK PRINCIPLE . Given a domain-free latent instance X ∈ RdX , its observation in a domain e is denoted as Xe : = G ( X , e ) . We want to learn the feature Ze = Φ ( Xe ) ∈ RdZ which is informative about the domainfree variable X , but invariant ( i.e . uninformative ) to the specific domain e. We use rate–distortion theory ( Davisson , 1972 ; Blau & Michaeli , 2019 ) to formulate our domain generalization problem . Rate–distortion theory is a major branch of information theory which provides the theoretical foundations for lossy data compression . An encoder Φ encodes domain-aware instances Xe . We want the representation Ze = Φ ( Xe ) to be domain-invariant , so we feed Ze into a decoder which outputs domain-invariant X . We minimize the distortion between the original domain-aware instance Xe and the reconstructed domain-free instance X . The distortion function measures how well X is predicted from a compressed representation Ze compared to its direct prediction from Xe . This trade-off is captured by the following loss function : LIB ( θ , e ) = EX∼PX , e∼PeI ( Ze ; Xe ) − βI ( Ze ; X ) IB objective ( 4 ) where I denotes the mutual information , θ is the parameter of the representation function Φ , and β is a constant . In the following , we consider two cases : discrete and continuous variables , owing to their different definition of entropy . Discrete case : Since the representation function is deterministic with respect to θ , we can rewrite Equation ( 4 ) through a classical identity of mutual information : I ( X ; Y ) = H ( X ) − H ( X|Y ) , where H denotes the Shannon entropy for discrete variables , as follows : LIB ( θ , e ) = EX , eI ( Ze ; Xe ) − βI ( Ze ; X ) = EX , eH ( Ze ) −H ( Ze|Xe ) − β ( H ( Ze ) −H ( Ze|X ) ) = EX , eH ( Ze|X ) + 1− β β H ( Ze ) , ( 5 ) where in the last equality we omit the overall scaling factor of the loss function . If 0 ≤ β ≤ 1 , since H ( · ) is bounded below by 0 , setting Φ to be constant will clearly minimize the penalty , which is uninformative about the representations we want to learn . Hence , we set β > 1 , and replace 1−ββ with −λ , where 0 ≤ λ < 1 . The IB objective can be rewritten as LIB ( θ , e ) = EX , eH ( Ze|X ) − λH ( Ze ) . ( 6 ) Continuous case : In terms of continuous variables , the differential entropy h ( · ) is not bounded below , which hinders our analysis . To overcome this , we can define the lower bounded differential entropy ĥ ( X ) : = h ( X + ε ) , where ε is the independent bounded zero-entropy noise ε ∼ Uniform ( 0 , 1 ) . Thus , ĥ ( X ) ≥ h ( ε ) = 0 . We can replace the Shannon entropy H ( · ) with lower bounded differential entropy ĥ ( · ) in Equation ( 6 ) : LIB ( θ , e ) = EX , eĥ ( Ze|X ) − λĥ ( Ze ) . ( 7 ) For simplicity , we define H to be the Shannon entropy for the discrete variables , or lower bounded entropy ĥ for continuous variables in the main text . We define He ( f ) : = EXe∼PeH ( f ( Xe ) ) . We can extend the Empirical Risk Minimization ( ERM ) algorithm to include the IB Penalty , and the resulting algorithm , denoted as Twins-ERM method , is the following : min w , Φ ∑ e∈Etrain He ( Φ ∣∣X ) − λHe ( Φ ) s.t . 1 |Etrain| ∑ e∈Etrain Re ( w ◦ Φ ) ≤ r ( 8 ) where r is the threshold on the empirical risk on the training domains . In addition to ERM , another popular minimization framework is the invariant risk minimization ( Arjovsky et al. , 2019 ) . The proposed penalty can be readily incorporated into the IRM framework , we call the resulting algorithm Twins-IRM : min w , Φ ∑ e∈Etrain He ( Φ ∣∣X ) − λHe ( Φ ) , s.t . 1 |Etrain| ∑ e∈Etrain Re ( w ◦ Φ ) ≤ r , w ∈ arg min w̃ Re ( w̃ ◦ Φ ) , ∀e ∈ Etrain . ( 9 ) | The paper proposes a method for domain generalization. They formulate the problem as a rate-distortion problem and introduce the information bottleneck penalty. Specifically, they realize the objective as a contrastive loss that encourges embeddings across domains to be similar if they share the same label. In the experiments, the method improves the corresponding baselines in several toy datasets. | SP:cb0575b48467a88eaef38cf9af20c76148c3b04d |
A Rate-Distortion Approach to Domain Generalization | Domain generalization deals with the difference in the distribution between the training and testing datasets , i.e. , the domain shift problem . A principled approach to domain generalization is by extracting domain-invariant features . In this paper , we propose an information-theoretic approach for domain generalization . We first establish the domain transformation model , mapping a domain-free latent image into a domain . Then , we cast the domain generalization as a rate-distortion problem , and use the information bottleneck penalty to measure how well the domain-free latent image is reconstructed from a compressed representation of a domain-specific image compared to its direct prediction from the domain-specific image itself . We prove that the information bottleneck penalty guarantees that domain-invariant features can be learned . Lastly , we draw links of our proposed method with selfsupervised contrastive learning without negative data pairs . Our empirical study on two different tasks verifies the improvement over recent baselines . 1 INTRODUCTION . Deep neural networks ( DNNs ) are highly expressive models that reach state-of-the-art performance in challenging tasks , such as speech and visual recognition ( Devlin et al. , 2018 ; He et al. , 2016 ) , by capturing complex correlations among input elements , e.g. , pixels of an image . However , the correlations might also contain spurious features that hurt the generalization performance of DNNs on out-of-distribution samples ( Szegedy et al. , 2013 ; Beery et al. , 2018 ; Alcorn et al. , 2019 ) . Unfortunately , real-world applications often encounter such out-of-distribution samples , e.g. , when the training domain does not match the testing domain . A prominent example is deblurring , where models are trained on simulated blurs which differ substantially to real-world blurring ( Koh et al. , 2021 ) . In other words , generalization across domains is a critical task before deploying DNNs to real-world application . Learning features that are invariant across multiple training domains , and using those features for out-of-distribution generalization has emerged as a significant topic in domain generalization . In domain generalization , multiple source domains are accessible during training , but the target domains are not ( Blanchard et al. , 2011 ; Muandet et al. , 2013 ) . Invariant risk minimization ( IRM ) ( Arjovsky et al. , 2019 ) is a prominent approach for learning domain invariant features . However , IRM suffers from the case when the invariant features contains full information about the label ( Ahuja et al. , 2020 ) . To deal with this shortcoming , Ahuja et al . ( 2021 ) introduce the information bottleneck theory on neural networks ( Tishby & Zaslavsky , 2015 ) , and show that their method will be guaranteed to converge to the invariant features . On the empirical side , a series of works align source domain distributions for domain-invariant representation learning by either direct construct auxiliary penalty ( Duan et al. , 2012 ; Sun & Saenko , 2016 ; Li et al. , 2018b ; c ; 2017 ; Niu et al. , 2015 ) , or meta learning ( Li et al. , 2019 ; Balaji et al. , 2018 ; Li et al. , 2018a ) . There are also series of work do not rely on invariant features . They can be categorized as ( 1 ) domainspecific method : Domain2Vec ( D2V ) ( Deshmukh et al. , 2018 ) learns domain-specific embedding , DMG ( Chattopadhyay et al. , 2020 ) aims to learn domain specific masks ; and ( 2 ) augmentation method : ( Volpi et al. , 2018 ) augments the dataset adversarially , L2A-OT ( Zhou et al. , 2020 ) augments data with image information . Despite their success , there is no guarantee that empirical methods can solve the task across different environments . In this paper , we use an information-theoretic approach to tackle domain generalization . We assume there is a domain-free latent instance ( e.g. , an image ) that captures the invariant features we want to extract . We define a domain transformation model that maps the domain-free latent instance into a domain and then we apply the rate distortion theory to obtain a domain-invariant representation . The proposed method , called Twins , is guaranteed to converge to the invariant feature under the linear classification structural equation model ( Ahuja et al. , 2021 ) . We evaluate our method on linear unit tests ( Aubin et al. , 2021 ) and variants of MNIST dataset ( LeCun & Cortes , 2010 ; Xiao et al. , 2017 ; Clanuwat et al. , 2018 ) , which validates the theoretical analysis and demonstrates how the proposed method can outperform the previous ones . Our contributions can be summarized as follows : • We cast domain generalization as a rate distortion problem and prove how the proposed method can converge . • We illustrate how the proposed method extends previous results on domain generalization , and draw links to self-supervised contrastive learning . We demystify the success of contrastive learning by giving a contrastive learning based domain generalization algorithm with theoretical guarantee . • We evaluate our method on two datasets and observe consistent improvement over existing baselines . 2 PRELIMINARY ON DOMAIN GENERALIZATION . Assume that the instance-label pair ( X , Y ) is sampled from an unknown distribution P ( X , Y ) . The objective of standard supervised learning is to learn a predictor f that is able to predict the labels Y of corresponding instances X for each ( X , Y ) ∼ P ( X , Y ) , given the finite training samples drawn from the underlying distribution P ( X , Y ) . Unlike the standard supervised learning tasks , in domain generalization , we can not sample directly from the distribution P ( X , Y ) . Instead , we can only observe ( X , Y ) under different domains e ∈ Eall , denoted as ( Xe , Y e ) ∼ Pe ( Xe , Y e ) . We also assume that e ∈ Eall is distributed as e ∼ Pe . Given samples from a finite subset Etrain ( Eall of all the domains , the goal of the domain generalization problem is to learn a predictor f that generalizes across all possible domains . This can be summarized as follows : Problem 2.1 ( Domain generalization ) . Let Etrain ( Eall be a finite subset of training domains . We have access to the data for each training domain etrain ∈ Etrain , but have no access to the data for each test domain etest ∈ Eall\Etrain . Given a function classF and a loss function ` , our goal is to learn a predictor f ∈ F using the data from the training domain such that f minimizes the worst-case risk over Eall . Define the risk of the predictor f on the domain e as Re ( f ) : = EPe ( Xe , Y e ) ` ( f ( Xe ) , Y e ) . We want to solve the following min-max optimization problem : minimize f∈F max e∈Eall Re ( f ) . ( DG ) We establish the domain transformation model to characterize the relation between domain-aware instance Xe and the domain-invariant latent instance X in the Assumption 1 , which first appears in Robey et al . ( 2021 ) . Assumption 1 ( Domain transformation model ) . Let δe denote a Dirac distribution for e ∈ Eall . We assume that there exists a measurable function G : X × Eall → X , which we refer to as a domain transformation model , that parameterizes the inter-domain covariate shift via Pe ( X ) =d G # ( P ( X ) × δe ) ∀e ∈ Eall , ( 1 ) where # denotes the push-forward measure and =d denotes equality in distribution . The Assumption 1 can somewhat reflect the generation of domain specific instances . For example , the multiple different views of a 3D object ( Niu et al. , 2015 ) , different angles of the image ( Rotated MNIST ( Worrall et al. , 2017 ) ) . Besides , the MUNIT architecture ( Huang et al. , 2018 ) can effectively distangle the domain-free latent instance X and the specific environment e , and thus can be used as the domain transformation model G ( Robey et al. , 2021 ) . Let Φ denote the feature representation mapping , w denote the classifier and w ◦ Φ denote the full predictor . The regret of the network on the domain e is denoted as Re ( w ◦ Φ ) . Next , we define standard properties related to the datasets used in the domain generalization literature ( Ahuja et al. , 2021 ) . For each e ∈ Eall , the distribution ( Xe , Y e ) ∼ Pe satisfies the following properties : ( 1 ) ∃ a map Φ∗ , which we call an invariant feature map , such that E [ Y e ∣∣Φ∗ ( Xe ) ] is the same for all e ∈ Eall and Y e 6⊥ Φ∗ ( Xe ) , where ⊥ means mutual independence . ( 2 ) ∃ a map Ψ∗ , which we call spurious feature map , such that E [ Y e ∣∣Ψ∗ ( Xe ) ] is not the same for all e ∈ Eall and Y e 6⊥ Ψ∗ ( Xe ) for some domains . Ψ∗ often hinders learning predictors that only rely on Φ∗ . For example , in the CMNIST dataset , the Φ ? extracts the underlying digit and Ψ ? extracts background color . The baseline algorithm for domain generalization Equation ( DG ) is the Empirical Risk Minimization , i.e . directly minimizing the empirical risk on the training domains : min w , Φ 1 |Etrain| ∑ e∈Etrain Re ( w ◦ Φ ) , ( 2 ) where |Etrain| denotes the number of training domains . We say that a data representation Φ elicits an invariant predictor across the set of training domains Etrain if there is a predictor w that simultaneously achieves the minimum risk , i.e . w ∈ arg minw′ Re ( w′ ◦ Φ ) , ∀e ∈ Etrain . Using this notation , the main objective of Invariant Risk Minimization ( IRM ) is stated as : min w , Φ 1 |Etrain| ∑ e∈Etrain Re ( w ◦ Φ ) , s.t . w ∈ arg min w′ Re ( w′ ◦ Φ ) , ∀e ∈ Etrain . ( 3 ) Lastly , we rely on the notion of ‘ informativeness ’ about the datasets ( Ahuja et al. , 2021 ) . There are two such categories of informativeness . In the first case , the invariant features Φ∗ ( Xe ) are partially informative about the label , i.e . Y 6⊥ Xe|Φ∗ ( Xe ) , and color contains information about label not contained in the uncolored digit . In the second case , invariant features are fully informative about the label , i.e. , Y ⊥ Xe|Φ∗ ( Xe ) , i.e. , they contain all the information about the label that is contained in input Xe . Many real-world image datasets have fully informative invariant features , the labels are a deterministic function of the domain-invariant features and domain-aware spurious features do not affect the label . 3 METHOD . 3.1 RATE DISTORTION & INFORMATION BOTTLENECK PRINCIPLE . Given a domain-free latent instance X ∈ RdX , its observation in a domain e is denoted as Xe : = G ( X , e ) . We want to learn the feature Ze = Φ ( Xe ) ∈ RdZ which is informative about the domainfree variable X , but invariant ( i.e . uninformative ) to the specific domain e. We use rate–distortion theory ( Davisson , 1972 ; Blau & Michaeli , 2019 ) to formulate our domain generalization problem . Rate–distortion theory is a major branch of information theory which provides the theoretical foundations for lossy data compression . An encoder Φ encodes domain-aware instances Xe . We want the representation Ze = Φ ( Xe ) to be domain-invariant , so we feed Ze into a decoder which outputs domain-invariant X . We minimize the distortion between the original domain-aware instance Xe and the reconstructed domain-free instance X . The distortion function measures how well X is predicted from a compressed representation Ze compared to its direct prediction from Xe . This trade-off is captured by the following loss function : LIB ( θ , e ) = EX∼PX , e∼PeI ( Ze ; Xe ) − βI ( Ze ; X ) IB objective ( 4 ) where I denotes the mutual information , θ is the parameter of the representation function Φ , and β is a constant . In the following , we consider two cases : discrete and continuous variables , owing to their different definition of entropy . Discrete case : Since the representation function is deterministic with respect to θ , we can rewrite Equation ( 4 ) through a classical identity of mutual information : I ( X ; Y ) = H ( X ) − H ( X|Y ) , where H denotes the Shannon entropy for discrete variables , as follows : LIB ( θ , e ) = EX , eI ( Ze ; Xe ) − βI ( Ze ; X ) = EX , eH ( Ze ) −H ( Ze|Xe ) − β ( H ( Ze ) −H ( Ze|X ) ) = EX , eH ( Ze|X ) + 1− β β H ( Ze ) , ( 5 ) where in the last equality we omit the overall scaling factor of the loss function . If 0 ≤ β ≤ 1 , since H ( · ) is bounded below by 0 , setting Φ to be constant will clearly minimize the penalty , which is uninformative about the representations we want to learn . Hence , we set β > 1 , and replace 1−ββ with −λ , where 0 ≤ λ < 1 . The IB objective can be rewritten as LIB ( θ , e ) = EX , eH ( Ze|X ) − λH ( Ze ) . ( 6 ) Continuous case : In terms of continuous variables , the differential entropy h ( · ) is not bounded below , which hinders our analysis . To overcome this , we can define the lower bounded differential entropy ĥ ( X ) : = h ( X + ε ) , where ε is the independent bounded zero-entropy noise ε ∼ Uniform ( 0 , 1 ) . Thus , ĥ ( X ) ≥ h ( ε ) = 0 . We can replace the Shannon entropy H ( · ) with lower bounded differential entropy ĥ ( · ) in Equation ( 6 ) : LIB ( θ , e ) = EX , eĥ ( Ze|X ) − λĥ ( Ze ) . ( 7 ) For simplicity , we define H to be the Shannon entropy for the discrete variables , or lower bounded entropy ĥ for continuous variables in the main text . We define He ( f ) : = EXe∼PeH ( f ( Xe ) ) . We can extend the Empirical Risk Minimization ( ERM ) algorithm to include the IB Penalty , and the resulting algorithm , denoted as Twins-ERM method , is the following : min w , Φ ∑ e∈Etrain He ( Φ ∣∣X ) − λHe ( Φ ) s.t . 1 |Etrain| ∑ e∈Etrain Re ( w ◦ Φ ) ≤ r ( 8 ) where r is the threshold on the empirical risk on the training domains . In addition to ERM , another popular minimization framework is the invariant risk minimization ( Arjovsky et al. , 2019 ) . The proposed penalty can be readily incorporated into the IRM framework , we call the resulting algorithm Twins-IRM : min w , Φ ∑ e∈Etrain He ( Φ ∣∣X ) − λHe ( Φ ) , s.t . 1 |Etrain| ∑ e∈Etrain Re ( w ◦ Φ ) ≤ r , w ∈ arg min w̃ Re ( w̃ ◦ Φ ) , ∀e ∈ Etrain . ( 9 ) | This paper studies the problem of domain generalization via invariant feature learning studied from the lens of information theory. The motivation is to use rate distortion theory to obtain a domain-invariant representation. The authors propose an algorithm titled Twins that uses the aforementioned rate distortion theory coupled with a multivariate Gaussian assumption to provide an additional penalty based on cross-correlation, i.e., minimize the distances between pairs of points belonging to different domains but the same label. The authors demonstrate, that under suitable assumptions, this approach will recover the invariant feature representation. The authors construct several hand-crafted problems where indeed this assumption (and the proposed algorithm) work well, and also provide some experiments on MNIST-type data. | SP:cb0575b48467a88eaef38cf9af20c76148c3b04d |
A Rate-Distortion Approach to Domain Generalization | Domain generalization deals with the difference in the distribution between the training and testing datasets , i.e. , the domain shift problem . A principled approach to domain generalization is by extracting domain-invariant features . In this paper , we propose an information-theoretic approach for domain generalization . We first establish the domain transformation model , mapping a domain-free latent image into a domain . Then , we cast the domain generalization as a rate-distortion problem , and use the information bottleneck penalty to measure how well the domain-free latent image is reconstructed from a compressed representation of a domain-specific image compared to its direct prediction from the domain-specific image itself . We prove that the information bottleneck penalty guarantees that domain-invariant features can be learned . Lastly , we draw links of our proposed method with selfsupervised contrastive learning without negative data pairs . Our empirical study on two different tasks verifies the improvement over recent baselines . 1 INTRODUCTION . Deep neural networks ( DNNs ) are highly expressive models that reach state-of-the-art performance in challenging tasks , such as speech and visual recognition ( Devlin et al. , 2018 ; He et al. , 2016 ) , by capturing complex correlations among input elements , e.g. , pixels of an image . However , the correlations might also contain spurious features that hurt the generalization performance of DNNs on out-of-distribution samples ( Szegedy et al. , 2013 ; Beery et al. , 2018 ; Alcorn et al. , 2019 ) . Unfortunately , real-world applications often encounter such out-of-distribution samples , e.g. , when the training domain does not match the testing domain . A prominent example is deblurring , where models are trained on simulated blurs which differ substantially to real-world blurring ( Koh et al. , 2021 ) . In other words , generalization across domains is a critical task before deploying DNNs to real-world application . Learning features that are invariant across multiple training domains , and using those features for out-of-distribution generalization has emerged as a significant topic in domain generalization . In domain generalization , multiple source domains are accessible during training , but the target domains are not ( Blanchard et al. , 2011 ; Muandet et al. , 2013 ) . Invariant risk minimization ( IRM ) ( Arjovsky et al. , 2019 ) is a prominent approach for learning domain invariant features . However , IRM suffers from the case when the invariant features contains full information about the label ( Ahuja et al. , 2020 ) . To deal with this shortcoming , Ahuja et al . ( 2021 ) introduce the information bottleneck theory on neural networks ( Tishby & Zaslavsky , 2015 ) , and show that their method will be guaranteed to converge to the invariant features . On the empirical side , a series of works align source domain distributions for domain-invariant representation learning by either direct construct auxiliary penalty ( Duan et al. , 2012 ; Sun & Saenko , 2016 ; Li et al. , 2018b ; c ; 2017 ; Niu et al. , 2015 ) , or meta learning ( Li et al. , 2019 ; Balaji et al. , 2018 ; Li et al. , 2018a ) . There are also series of work do not rely on invariant features . They can be categorized as ( 1 ) domainspecific method : Domain2Vec ( D2V ) ( Deshmukh et al. , 2018 ) learns domain-specific embedding , DMG ( Chattopadhyay et al. , 2020 ) aims to learn domain specific masks ; and ( 2 ) augmentation method : ( Volpi et al. , 2018 ) augments the dataset adversarially , L2A-OT ( Zhou et al. , 2020 ) augments data with image information . Despite their success , there is no guarantee that empirical methods can solve the task across different environments . In this paper , we use an information-theoretic approach to tackle domain generalization . We assume there is a domain-free latent instance ( e.g. , an image ) that captures the invariant features we want to extract . We define a domain transformation model that maps the domain-free latent instance into a domain and then we apply the rate distortion theory to obtain a domain-invariant representation . The proposed method , called Twins , is guaranteed to converge to the invariant feature under the linear classification structural equation model ( Ahuja et al. , 2021 ) . We evaluate our method on linear unit tests ( Aubin et al. , 2021 ) and variants of MNIST dataset ( LeCun & Cortes , 2010 ; Xiao et al. , 2017 ; Clanuwat et al. , 2018 ) , which validates the theoretical analysis and demonstrates how the proposed method can outperform the previous ones . Our contributions can be summarized as follows : • We cast domain generalization as a rate distortion problem and prove how the proposed method can converge . • We illustrate how the proposed method extends previous results on domain generalization , and draw links to self-supervised contrastive learning . We demystify the success of contrastive learning by giving a contrastive learning based domain generalization algorithm with theoretical guarantee . • We evaluate our method on two datasets and observe consistent improvement over existing baselines . 2 PRELIMINARY ON DOMAIN GENERALIZATION . Assume that the instance-label pair ( X , Y ) is sampled from an unknown distribution P ( X , Y ) . The objective of standard supervised learning is to learn a predictor f that is able to predict the labels Y of corresponding instances X for each ( X , Y ) ∼ P ( X , Y ) , given the finite training samples drawn from the underlying distribution P ( X , Y ) . Unlike the standard supervised learning tasks , in domain generalization , we can not sample directly from the distribution P ( X , Y ) . Instead , we can only observe ( X , Y ) under different domains e ∈ Eall , denoted as ( Xe , Y e ) ∼ Pe ( Xe , Y e ) . We also assume that e ∈ Eall is distributed as e ∼ Pe . Given samples from a finite subset Etrain ( Eall of all the domains , the goal of the domain generalization problem is to learn a predictor f that generalizes across all possible domains . This can be summarized as follows : Problem 2.1 ( Domain generalization ) . Let Etrain ( Eall be a finite subset of training domains . We have access to the data for each training domain etrain ∈ Etrain , but have no access to the data for each test domain etest ∈ Eall\Etrain . Given a function classF and a loss function ` , our goal is to learn a predictor f ∈ F using the data from the training domain such that f minimizes the worst-case risk over Eall . Define the risk of the predictor f on the domain e as Re ( f ) : = EPe ( Xe , Y e ) ` ( f ( Xe ) , Y e ) . We want to solve the following min-max optimization problem : minimize f∈F max e∈Eall Re ( f ) . ( DG ) We establish the domain transformation model to characterize the relation between domain-aware instance Xe and the domain-invariant latent instance X in the Assumption 1 , which first appears in Robey et al . ( 2021 ) . Assumption 1 ( Domain transformation model ) . Let δe denote a Dirac distribution for e ∈ Eall . We assume that there exists a measurable function G : X × Eall → X , which we refer to as a domain transformation model , that parameterizes the inter-domain covariate shift via Pe ( X ) =d G # ( P ( X ) × δe ) ∀e ∈ Eall , ( 1 ) where # denotes the push-forward measure and =d denotes equality in distribution . The Assumption 1 can somewhat reflect the generation of domain specific instances . For example , the multiple different views of a 3D object ( Niu et al. , 2015 ) , different angles of the image ( Rotated MNIST ( Worrall et al. , 2017 ) ) . Besides , the MUNIT architecture ( Huang et al. , 2018 ) can effectively distangle the domain-free latent instance X and the specific environment e , and thus can be used as the domain transformation model G ( Robey et al. , 2021 ) . Let Φ denote the feature representation mapping , w denote the classifier and w ◦ Φ denote the full predictor . The regret of the network on the domain e is denoted as Re ( w ◦ Φ ) . Next , we define standard properties related to the datasets used in the domain generalization literature ( Ahuja et al. , 2021 ) . For each e ∈ Eall , the distribution ( Xe , Y e ) ∼ Pe satisfies the following properties : ( 1 ) ∃ a map Φ∗ , which we call an invariant feature map , such that E [ Y e ∣∣Φ∗ ( Xe ) ] is the same for all e ∈ Eall and Y e 6⊥ Φ∗ ( Xe ) , where ⊥ means mutual independence . ( 2 ) ∃ a map Ψ∗ , which we call spurious feature map , such that E [ Y e ∣∣Ψ∗ ( Xe ) ] is not the same for all e ∈ Eall and Y e 6⊥ Ψ∗ ( Xe ) for some domains . Ψ∗ often hinders learning predictors that only rely on Φ∗ . For example , in the CMNIST dataset , the Φ ? extracts the underlying digit and Ψ ? extracts background color . The baseline algorithm for domain generalization Equation ( DG ) is the Empirical Risk Minimization , i.e . directly minimizing the empirical risk on the training domains : min w , Φ 1 |Etrain| ∑ e∈Etrain Re ( w ◦ Φ ) , ( 2 ) where |Etrain| denotes the number of training domains . We say that a data representation Φ elicits an invariant predictor across the set of training domains Etrain if there is a predictor w that simultaneously achieves the minimum risk , i.e . w ∈ arg minw′ Re ( w′ ◦ Φ ) , ∀e ∈ Etrain . Using this notation , the main objective of Invariant Risk Minimization ( IRM ) is stated as : min w , Φ 1 |Etrain| ∑ e∈Etrain Re ( w ◦ Φ ) , s.t . w ∈ arg min w′ Re ( w′ ◦ Φ ) , ∀e ∈ Etrain . ( 3 ) Lastly , we rely on the notion of ‘ informativeness ’ about the datasets ( Ahuja et al. , 2021 ) . There are two such categories of informativeness . In the first case , the invariant features Φ∗ ( Xe ) are partially informative about the label , i.e . Y 6⊥ Xe|Φ∗ ( Xe ) , and color contains information about label not contained in the uncolored digit . In the second case , invariant features are fully informative about the label , i.e. , Y ⊥ Xe|Φ∗ ( Xe ) , i.e. , they contain all the information about the label that is contained in input Xe . Many real-world image datasets have fully informative invariant features , the labels are a deterministic function of the domain-invariant features and domain-aware spurious features do not affect the label . 3 METHOD . 3.1 RATE DISTORTION & INFORMATION BOTTLENECK PRINCIPLE . Given a domain-free latent instance X ∈ RdX , its observation in a domain e is denoted as Xe : = G ( X , e ) . We want to learn the feature Ze = Φ ( Xe ) ∈ RdZ which is informative about the domainfree variable X , but invariant ( i.e . uninformative ) to the specific domain e. We use rate–distortion theory ( Davisson , 1972 ; Blau & Michaeli , 2019 ) to formulate our domain generalization problem . Rate–distortion theory is a major branch of information theory which provides the theoretical foundations for lossy data compression . An encoder Φ encodes domain-aware instances Xe . We want the representation Ze = Φ ( Xe ) to be domain-invariant , so we feed Ze into a decoder which outputs domain-invariant X . We minimize the distortion between the original domain-aware instance Xe and the reconstructed domain-free instance X . The distortion function measures how well X is predicted from a compressed representation Ze compared to its direct prediction from Xe . This trade-off is captured by the following loss function : LIB ( θ , e ) = EX∼PX , e∼PeI ( Ze ; Xe ) − βI ( Ze ; X ) IB objective ( 4 ) where I denotes the mutual information , θ is the parameter of the representation function Φ , and β is a constant . In the following , we consider two cases : discrete and continuous variables , owing to their different definition of entropy . Discrete case : Since the representation function is deterministic with respect to θ , we can rewrite Equation ( 4 ) through a classical identity of mutual information : I ( X ; Y ) = H ( X ) − H ( X|Y ) , where H denotes the Shannon entropy for discrete variables , as follows : LIB ( θ , e ) = EX , eI ( Ze ; Xe ) − βI ( Ze ; X ) = EX , eH ( Ze ) −H ( Ze|Xe ) − β ( H ( Ze ) −H ( Ze|X ) ) = EX , eH ( Ze|X ) + 1− β β H ( Ze ) , ( 5 ) where in the last equality we omit the overall scaling factor of the loss function . If 0 ≤ β ≤ 1 , since H ( · ) is bounded below by 0 , setting Φ to be constant will clearly minimize the penalty , which is uninformative about the representations we want to learn . Hence , we set β > 1 , and replace 1−ββ with −λ , where 0 ≤ λ < 1 . The IB objective can be rewritten as LIB ( θ , e ) = EX , eH ( Ze|X ) − λH ( Ze ) . ( 6 ) Continuous case : In terms of continuous variables , the differential entropy h ( · ) is not bounded below , which hinders our analysis . To overcome this , we can define the lower bounded differential entropy ĥ ( X ) : = h ( X + ε ) , where ε is the independent bounded zero-entropy noise ε ∼ Uniform ( 0 , 1 ) . Thus , ĥ ( X ) ≥ h ( ε ) = 0 . We can replace the Shannon entropy H ( · ) with lower bounded differential entropy ĥ ( · ) in Equation ( 6 ) : LIB ( θ , e ) = EX , eĥ ( Ze|X ) − λĥ ( Ze ) . ( 7 ) For simplicity , we define H to be the Shannon entropy for the discrete variables , or lower bounded entropy ĥ for continuous variables in the main text . We define He ( f ) : = EXe∼PeH ( f ( Xe ) ) . We can extend the Empirical Risk Minimization ( ERM ) algorithm to include the IB Penalty , and the resulting algorithm , denoted as Twins-ERM method , is the following : min w , Φ ∑ e∈Etrain He ( Φ ∣∣X ) − λHe ( Φ ) s.t . 1 |Etrain| ∑ e∈Etrain Re ( w ◦ Φ ) ≤ r ( 8 ) where r is the threshold on the empirical risk on the training domains . In addition to ERM , another popular minimization framework is the invariant risk minimization ( Arjovsky et al. , 2019 ) . The proposed penalty can be readily incorporated into the IRM framework , we call the resulting algorithm Twins-IRM : min w , Φ ∑ e∈Etrain He ( Φ ∣∣X ) − λHe ( Φ ) , s.t . 1 |Etrain| ∑ e∈Etrain Re ( w ◦ Φ ) ≤ r , w ∈ arg min w̃ Re ( w̃ ◦ Φ ) , ∀e ∈ Etrain . ( 9 ) | In this work, the authors study the problem of domain generalization. Recent works such as invariant risk minimization [Arjovsky et al.] have invigorated a lot of interest in the problem of domain generalization. The paper brings together ideas from rate distortion and information bottleneck principle (recently used in Ahuja et al. for domain generalization) and the work of model based domain generalization [Robey et al.]. In Ahuja et al., the authors combine invariance and information bottleneck to address domain generalization. The representation learned in Ahuja et al. is constrained by the label and information bottleneck constraints. In this work, the authors add some more structure to the generation of the observations X from the latent and say that there is a common instance X that is transformed by the domain transformation model to get the image in the current domain, i.e. X^e = G(X,e). The authors try to recover the common instance X that is shared across domains. | SP:cb0575b48467a88eaef38cf9af20c76148c3b04d |
Visual Correspondence Hallucination | 1 INTRODUCTION . Establishing correspondences between two partially overlapping images is a fundamental computer vision problem with many applications . For example , state-of-the-art methods for visual localization from an input image rely on keypoint matches between the input image and a reference image ( Sattler et al. , 2018 ; Sarlin et al. , 2019 ; 2020 ; Revaud et al. , 2019 ) . However , these local feature matching methods will still fail when few keypoints are covisible , i.e . when many image locations in one image are outside the field of view or become occluded in the second image . These failures are to be expected since these methods are pure pattern recognition approaches that seek to identify correspondences , i.e . to find correspondences in covisible regions , and consider the non-covisible regions as noise . By contrast , humans explain the presence of these non-covisible regions through geometric reasoning and consequently are able to hallucinate ( i.e . predict ) correspondences at those locations . Geometric reasoning has already been used in computer vision for image matching , but usually as an a posteriori processing ( Fischler & Bolles , 1981 ; Luong & Faugeras , 1996 ; Barath & Matas , 2018 ; Chum et al. , 2003 ; 2005 ; Barath et al. , 2019 ; 2020 ) . These methods seek to remove outliers from the set of correspondences produced by a local feature matching approach using only limited geometric models such as epipolar geometry or planar assumptions . Contributions . In this paper we tackle the problem of correspondence hallucination . In doing so we seek to answer two questions : ( i ) can we derive a network architecture able to learn to hallucinate correspondences ? and ( ii ) is correspondence hallucination beneficial for absolute pose estimation ? The answer to these questions is the main novelty of this paper . More precisely , we consider a network that takes as input a pair of partially overlapping source/target images and keypoints in the source image , and outputs for each keypoint a probability distribution over its correspondent ’ s location in the target image plane . We propose to train this network to both identify and hallucinate the keypoints ’ correspondents . We call the resulting method NeurHal , for Neural Hallucinations . To the best of our knowledge , learning to hallucinate correspondences is a virgin territory , thus we first provide an analysis of the specific features of that novel learning task . This analysis guides us towards employing an appropriate loss function and designing the architecture of the network . After training the network , we experimentally demonstrate that it is indeed able to hallucinate correspondences on unseen pairs of images captured in novel scenes . We also apply this network to a camera pose estimation problem and find it is significantly more robust than state-of-the-art local feature matching-based competitors . 2 RELATED WORK . To the best of our knowledge , aiming at hallucinating visual correspondences has never been done but the related fields of local feature description and matching are immensely vast , and we focus here only on recent learning-based approaches . Learning-based local feature description . Using deep neural networks to learn to compute local feature descriptors have shown to bring significant improvements in invariance to viewpoint and illumination changes compared to handcrafted methods ( Csurka & Humenberger , 2018 ; Gauglitz et al. , 2011 ; Salahat & Qasaimeh , 2017 ; Balntas et al. , 2017 ) . Most methods learn descriptors locally around pre-computed covisible interest regions in both images ( Yi et al. , 2016 ; Detone et al. , 2018 ; Balntas et al. , 2016a ; Luo et al. , 2019 ) , using convolutional-based siamese architectures trained with a contrastive loss ( Gordo et al. , 2016 ; Schroff et al. , 2015 ; Balntas et al. , 2016b ; Radenović et al. , 2016 ; Mishchuk et al. , 2017 ; Simonyan et al. , 2014 ) , or using pose ( Wang et al. , 2020 ; Zhou et al. , 2021 ) or self ( Yang et al. , 2021 ) supervision . To further improve the performances , ( Dusmanu et al. , 2019 ; Revaud et al. , 2019 ) propose to jointly learn to detect and describe keypoints in both images , while Germain et al . ( 2020 ) only detects in one image and densely matches descriptors in the other . Learning-based local feature matching . All the methods described in the previous paragraph establish correspondences by comparing descriptors using a simple operation such as a dot product . Thus the combination of such a simple matching method with a siamese architecture inevitably produces outlier correspondences , especially in non-covisible regions . To reduce the amount of outliers , most approaches employ so-called Mutual Nearest Neighbor ( MNN ) filtering . However , it is possible to go beyond a simple MNN and learn to match descriptors . Learning-based matching methods ( Zhang et al. , 2019 ; Brachmann & Rother , 2019 ; Moo Yi et al. , 2018 ; Sun et al. , 2020 ; Choy et al. , 2020 ; 2016 ) take as input local descriptors and/or putative correspondences , and learn to output correspondences probabilities . However , all these matching methods focus only on predicting correctly covisible correspondences . Jointly learning local feature description and matching . Several methods have recently proposed to jointly learn to compute and match descriptors ( Sarlin et al. , 2020 ; Sun et al. , 2021 ; Li et al. , 2020 ; Rocco et al. , 2018 ; 2020 ) . All these methods use a siamese Convolutional Neural Network ( CNN ) to obtain dense local descriptors , but they significantly differ regarding the way they establish matches . They actually fall into two categories . The first category of methods ( Li et al. , 2020 ; Rocco et al. , 2018 ; 2020 ) computes a 4D correlation tensor that essentially represents the scores of all the possible correspondences . This 4D correlation tensor is then used as input to a second network that learns to modify it using soft-MNN and 4D convolutions . Instead of summarizing all the information into a 4D correlation tensor , the second category of methods ( Sarlin et al. , 2020 ; Sun et al. , 2021 ) rely on Transformers ( Vaswani et al. , 2017 ; Dosovitskiy et al. , 2020 ; Ramachandran et al. , 2019 ; Caron et al. , 2021 ; Cordonnier et al. , 2020 ; Zhao et al. , 2020 ; Katharopoulos et al. , 2020 ) to let the descriptors of both images communicate and adapt to each other . All these methods again focus on identifying correctly covisible correspondences and consider non-covisible correspondences as noise . While our architecture is closely related to the second category of methods as we also rely on Transformers , the motivation for using it is quite different since it is our goal of hallucinating correspondences that calls for a non-siamese architecture ( see Sec.3 ) . Visual content hallucination . ( Yang et al. , 2019 ) proposes to hallucinate the content of RGB-D scans to perform relative pose estimation between two images . More recently ( Chen et al. , 2021 ) regresses distributions over relative camera poses for spherical images using joint processing of both images . The work of ( Yang et al. , 2020 ; Qian et al. , 2020 ; Jin et al. , 2021 ) shows that employing a hallucinate-then-match paradigm can be a reliable way of recovering 3D geometry or relative pose from sparsely sampled images . In this work , we focus on the problem of correspondence hallucination which unlike previously mentioned approaches does not aim at recovering explicit visual content or directly regressing a camera pose . Perhaps closest to our goal is Cai et al . ( 2021 ) that seeks to estimate a relative rotation between two non-overlapping images by learning to reason about “ hidden ” cues such as direction of shadows in outdoor scenes , parallel lines or vanishing points . 3 OUR APPROACH . Our goal is to train a network that takes as input a pair of partially overlapping source/target images and keypoints in the source image , and outputs for each keypoint a probability distribution over its correspondent ’ s location in the target image plane , regardless of this correspondent being visible , occluded , or outside the field of view . While the problem of learning to find the location of a visible correspondent received a lot of attention in the past few years ( see Sec . 2 ) , to the best of our knowledge , this paper is the first attempt of learning to find the location of a correspondent regardless of this correspondent being visible , occluded , or outside the field of view . Since this learning task is virgin territory , we first analyze its specific features below , before defining a loss function and a network architecture able to handle these features . 3.1 ANALYSIS OF THE PROBLEM . The task of finding the location of a correspondent regardless of this correspondent being visible , occluded , or outside the field of view actually leads to three different problems . Before stating those three problems , let us first recall the notion of correspondent as it is the keystone of our problem . Correspondent . Given a keypoint pS ∈ R2 in the source image IS , its depth dS ∈ R+ , and the relative camera pose RTS ∈ SO ( 3 ) , tTS ∈ R3 between the coordinate systems of IS and the target image IT , the correspondent pT ∈ R2 of pS in the target image plane is obtained by warping pS : pT : = ω ( dS , pS , RTS , tTS ) : = KTπ ( dSRTSK −1 S pS + tTS ) , where KS and KT are the camera calibration matrices of source and target images and π ( u ) : = [ ux/uz , uy/uz , 1 ] T is the projection function . In a slight abuse of notation , we do not distinguish a homogeneous 2D vector from a non-homogeneous 2D vector . Let us highlight that the correspondent pT of pS may not be visible , i.e . it may be occluded or outside the field of view . Identifying the correspondent . In the case where a network has to establish a correspondence between a keypoint pS in IS and its visible correspondent pT in IT , standard approaches , such as comparing a local descriptor computed at pS in IS with local descriptors computed at detected keypoints in IT , are applicable to identify the correspondent pT . Outpainting the correspondent . When pT is outside the field of view of IT , there is nothing to identify , i.e . neither can pT be detected as a keypoint nor can a local descriptor be computed at that location . Here the network first needs to identify correspondences in the region where IT overlaps with IS and realize that the correspondent pT is outside the field of view to eventually outpaint it ( see Fig . 1 ) . We call this operation `` outpainting the correspondent '' as the network needs to predict the location of pT outside the field of view of IT . Inpainting the correspondent . When pT is occluded in IT , the problem is even more difficult since local features can be computed at that location but will not match the local descriptor computed at pS in IS . As in the outpainting case , the network needs to identify correspondences in the region where IT overlaps with IS and realize that the correspondent pT is occluded to eventually inpaint the correspondent pT ( see Fig . 1 ) . We call this operation `` inpainting the correspondent '' as the network needs to predict the location of pT behind the occluding object . Let us now introduce a loss function and an architecture that are able to unify the identifying , inpainting and outpainting tasks . | The paper proposes a method that accepts two partially overlapping images and a keypoint in one of them, and detects the location of the keypoint in the other image, regardless of whether it is visible, occluded, or outside the frame of the image. This is an interesting re-formulation of the correspondence estimation problem, the conventional formulation of which considers only keypoints that are visible in both images. Under the previous formulation, correspondence estimators are considered successful if they can declare that the correspondent of the keypoint is invisible in the target image. In addition to the capability to predict the location of invisible keypoints in isolation, the paper demonstrates that this capability is beneficial to camera pose estimation. | SP:4bad1ee9318dcf0d353aed7f9b8c1423db12435a |
Visual Correspondence Hallucination | 1 INTRODUCTION . Establishing correspondences between two partially overlapping images is a fundamental computer vision problem with many applications . For example , state-of-the-art methods for visual localization from an input image rely on keypoint matches between the input image and a reference image ( Sattler et al. , 2018 ; Sarlin et al. , 2019 ; 2020 ; Revaud et al. , 2019 ) . However , these local feature matching methods will still fail when few keypoints are covisible , i.e . when many image locations in one image are outside the field of view or become occluded in the second image . These failures are to be expected since these methods are pure pattern recognition approaches that seek to identify correspondences , i.e . to find correspondences in covisible regions , and consider the non-covisible regions as noise . By contrast , humans explain the presence of these non-covisible regions through geometric reasoning and consequently are able to hallucinate ( i.e . predict ) correspondences at those locations . Geometric reasoning has already been used in computer vision for image matching , but usually as an a posteriori processing ( Fischler & Bolles , 1981 ; Luong & Faugeras , 1996 ; Barath & Matas , 2018 ; Chum et al. , 2003 ; 2005 ; Barath et al. , 2019 ; 2020 ) . These methods seek to remove outliers from the set of correspondences produced by a local feature matching approach using only limited geometric models such as epipolar geometry or planar assumptions . Contributions . In this paper we tackle the problem of correspondence hallucination . In doing so we seek to answer two questions : ( i ) can we derive a network architecture able to learn to hallucinate correspondences ? and ( ii ) is correspondence hallucination beneficial for absolute pose estimation ? The answer to these questions is the main novelty of this paper . More precisely , we consider a network that takes as input a pair of partially overlapping source/target images and keypoints in the source image , and outputs for each keypoint a probability distribution over its correspondent ’ s location in the target image plane . We propose to train this network to both identify and hallucinate the keypoints ’ correspondents . We call the resulting method NeurHal , for Neural Hallucinations . To the best of our knowledge , learning to hallucinate correspondences is a virgin territory , thus we first provide an analysis of the specific features of that novel learning task . This analysis guides us towards employing an appropriate loss function and designing the architecture of the network . After training the network , we experimentally demonstrate that it is indeed able to hallucinate correspondences on unseen pairs of images captured in novel scenes . We also apply this network to a camera pose estimation problem and find it is significantly more robust than state-of-the-art local feature matching-based competitors . 2 RELATED WORK . To the best of our knowledge , aiming at hallucinating visual correspondences has never been done but the related fields of local feature description and matching are immensely vast , and we focus here only on recent learning-based approaches . Learning-based local feature description . Using deep neural networks to learn to compute local feature descriptors have shown to bring significant improvements in invariance to viewpoint and illumination changes compared to handcrafted methods ( Csurka & Humenberger , 2018 ; Gauglitz et al. , 2011 ; Salahat & Qasaimeh , 2017 ; Balntas et al. , 2017 ) . Most methods learn descriptors locally around pre-computed covisible interest regions in both images ( Yi et al. , 2016 ; Detone et al. , 2018 ; Balntas et al. , 2016a ; Luo et al. , 2019 ) , using convolutional-based siamese architectures trained with a contrastive loss ( Gordo et al. , 2016 ; Schroff et al. , 2015 ; Balntas et al. , 2016b ; Radenović et al. , 2016 ; Mishchuk et al. , 2017 ; Simonyan et al. , 2014 ) , or using pose ( Wang et al. , 2020 ; Zhou et al. , 2021 ) or self ( Yang et al. , 2021 ) supervision . To further improve the performances , ( Dusmanu et al. , 2019 ; Revaud et al. , 2019 ) propose to jointly learn to detect and describe keypoints in both images , while Germain et al . ( 2020 ) only detects in one image and densely matches descriptors in the other . Learning-based local feature matching . All the methods described in the previous paragraph establish correspondences by comparing descriptors using a simple operation such as a dot product . Thus the combination of such a simple matching method with a siamese architecture inevitably produces outlier correspondences , especially in non-covisible regions . To reduce the amount of outliers , most approaches employ so-called Mutual Nearest Neighbor ( MNN ) filtering . However , it is possible to go beyond a simple MNN and learn to match descriptors . Learning-based matching methods ( Zhang et al. , 2019 ; Brachmann & Rother , 2019 ; Moo Yi et al. , 2018 ; Sun et al. , 2020 ; Choy et al. , 2020 ; 2016 ) take as input local descriptors and/or putative correspondences , and learn to output correspondences probabilities . However , all these matching methods focus only on predicting correctly covisible correspondences . Jointly learning local feature description and matching . Several methods have recently proposed to jointly learn to compute and match descriptors ( Sarlin et al. , 2020 ; Sun et al. , 2021 ; Li et al. , 2020 ; Rocco et al. , 2018 ; 2020 ) . All these methods use a siamese Convolutional Neural Network ( CNN ) to obtain dense local descriptors , but they significantly differ regarding the way they establish matches . They actually fall into two categories . The first category of methods ( Li et al. , 2020 ; Rocco et al. , 2018 ; 2020 ) computes a 4D correlation tensor that essentially represents the scores of all the possible correspondences . This 4D correlation tensor is then used as input to a second network that learns to modify it using soft-MNN and 4D convolutions . Instead of summarizing all the information into a 4D correlation tensor , the second category of methods ( Sarlin et al. , 2020 ; Sun et al. , 2021 ) rely on Transformers ( Vaswani et al. , 2017 ; Dosovitskiy et al. , 2020 ; Ramachandran et al. , 2019 ; Caron et al. , 2021 ; Cordonnier et al. , 2020 ; Zhao et al. , 2020 ; Katharopoulos et al. , 2020 ) to let the descriptors of both images communicate and adapt to each other . All these methods again focus on identifying correctly covisible correspondences and consider non-covisible correspondences as noise . While our architecture is closely related to the second category of methods as we also rely on Transformers , the motivation for using it is quite different since it is our goal of hallucinating correspondences that calls for a non-siamese architecture ( see Sec.3 ) . Visual content hallucination . ( Yang et al. , 2019 ) proposes to hallucinate the content of RGB-D scans to perform relative pose estimation between two images . More recently ( Chen et al. , 2021 ) regresses distributions over relative camera poses for spherical images using joint processing of both images . The work of ( Yang et al. , 2020 ; Qian et al. , 2020 ; Jin et al. , 2021 ) shows that employing a hallucinate-then-match paradigm can be a reliable way of recovering 3D geometry or relative pose from sparsely sampled images . In this work , we focus on the problem of correspondence hallucination which unlike previously mentioned approaches does not aim at recovering explicit visual content or directly regressing a camera pose . Perhaps closest to our goal is Cai et al . ( 2021 ) that seeks to estimate a relative rotation between two non-overlapping images by learning to reason about “ hidden ” cues such as direction of shadows in outdoor scenes , parallel lines or vanishing points . 3 OUR APPROACH . Our goal is to train a network that takes as input a pair of partially overlapping source/target images and keypoints in the source image , and outputs for each keypoint a probability distribution over its correspondent ’ s location in the target image plane , regardless of this correspondent being visible , occluded , or outside the field of view . While the problem of learning to find the location of a visible correspondent received a lot of attention in the past few years ( see Sec . 2 ) , to the best of our knowledge , this paper is the first attempt of learning to find the location of a correspondent regardless of this correspondent being visible , occluded , or outside the field of view . Since this learning task is virgin territory , we first analyze its specific features below , before defining a loss function and a network architecture able to handle these features . 3.1 ANALYSIS OF THE PROBLEM . The task of finding the location of a correspondent regardless of this correspondent being visible , occluded , or outside the field of view actually leads to three different problems . Before stating those three problems , let us first recall the notion of correspondent as it is the keystone of our problem . Correspondent . Given a keypoint pS ∈ R2 in the source image IS , its depth dS ∈ R+ , and the relative camera pose RTS ∈ SO ( 3 ) , tTS ∈ R3 between the coordinate systems of IS and the target image IT , the correspondent pT ∈ R2 of pS in the target image plane is obtained by warping pS : pT : = ω ( dS , pS , RTS , tTS ) : = KTπ ( dSRTSK −1 S pS + tTS ) , where KS and KT are the camera calibration matrices of source and target images and π ( u ) : = [ ux/uz , uy/uz , 1 ] T is the projection function . In a slight abuse of notation , we do not distinguish a homogeneous 2D vector from a non-homogeneous 2D vector . Let us highlight that the correspondent pT of pS may not be visible , i.e . it may be occluded or outside the field of view . Identifying the correspondent . In the case where a network has to establish a correspondence between a keypoint pS in IS and its visible correspondent pT in IT , standard approaches , such as comparing a local descriptor computed at pS in IS with local descriptors computed at detected keypoints in IT , are applicable to identify the correspondent pT . Outpainting the correspondent . When pT is outside the field of view of IT , there is nothing to identify , i.e . neither can pT be detected as a keypoint nor can a local descriptor be computed at that location . Here the network first needs to identify correspondences in the region where IT overlaps with IS and realize that the correspondent pT is outside the field of view to eventually outpaint it ( see Fig . 1 ) . We call this operation `` outpainting the correspondent '' as the network needs to predict the location of pT outside the field of view of IT . Inpainting the correspondent . When pT is occluded in IT , the problem is even more difficult since local features can be computed at that location but will not match the local descriptor computed at pS in IS . As in the outpainting case , the network needs to identify correspondences in the region where IT overlaps with IS and realize that the correspondent pT is occluded to eventually inpaint the correspondent pT ( see Fig . 1 ) . We call this operation `` inpainting the correspondent '' as the network needs to predict the location of pT behind the occluding object . Let us now introduce a loss function and an architecture that are able to unify the identifying , inpainting and outpainting tasks . | The paper proposed a deep method (NeurHal) to predict visible, occluded or out-of-view keypoint matching from source images to target images. In training, a correspondence map is obtained from ground truth of camera matrix/pose, and images. In testing, the model directly outputs three categories of matchings: identified, outputpainting and inpainting. As an application of NeurHal, the method is applied to camera pose estimation and tested on ScanNet and Megadepth. The experiments shows the method improves the estimation accuracy, particularly the outputpainting correspondences. | SP:4bad1ee9318dcf0d353aed7f9b8c1423db12435a |
Visual Correspondence Hallucination | 1 INTRODUCTION . Establishing correspondences between two partially overlapping images is a fundamental computer vision problem with many applications . For example , state-of-the-art methods for visual localization from an input image rely on keypoint matches between the input image and a reference image ( Sattler et al. , 2018 ; Sarlin et al. , 2019 ; 2020 ; Revaud et al. , 2019 ) . However , these local feature matching methods will still fail when few keypoints are covisible , i.e . when many image locations in one image are outside the field of view or become occluded in the second image . These failures are to be expected since these methods are pure pattern recognition approaches that seek to identify correspondences , i.e . to find correspondences in covisible regions , and consider the non-covisible regions as noise . By contrast , humans explain the presence of these non-covisible regions through geometric reasoning and consequently are able to hallucinate ( i.e . predict ) correspondences at those locations . Geometric reasoning has already been used in computer vision for image matching , but usually as an a posteriori processing ( Fischler & Bolles , 1981 ; Luong & Faugeras , 1996 ; Barath & Matas , 2018 ; Chum et al. , 2003 ; 2005 ; Barath et al. , 2019 ; 2020 ) . These methods seek to remove outliers from the set of correspondences produced by a local feature matching approach using only limited geometric models such as epipolar geometry or planar assumptions . Contributions . In this paper we tackle the problem of correspondence hallucination . In doing so we seek to answer two questions : ( i ) can we derive a network architecture able to learn to hallucinate correspondences ? and ( ii ) is correspondence hallucination beneficial for absolute pose estimation ? The answer to these questions is the main novelty of this paper . More precisely , we consider a network that takes as input a pair of partially overlapping source/target images and keypoints in the source image , and outputs for each keypoint a probability distribution over its correspondent ’ s location in the target image plane . We propose to train this network to both identify and hallucinate the keypoints ’ correspondents . We call the resulting method NeurHal , for Neural Hallucinations . To the best of our knowledge , learning to hallucinate correspondences is a virgin territory , thus we first provide an analysis of the specific features of that novel learning task . This analysis guides us towards employing an appropriate loss function and designing the architecture of the network . After training the network , we experimentally demonstrate that it is indeed able to hallucinate correspondences on unseen pairs of images captured in novel scenes . We also apply this network to a camera pose estimation problem and find it is significantly more robust than state-of-the-art local feature matching-based competitors . 2 RELATED WORK . To the best of our knowledge , aiming at hallucinating visual correspondences has never been done but the related fields of local feature description and matching are immensely vast , and we focus here only on recent learning-based approaches . Learning-based local feature description . Using deep neural networks to learn to compute local feature descriptors have shown to bring significant improvements in invariance to viewpoint and illumination changes compared to handcrafted methods ( Csurka & Humenberger , 2018 ; Gauglitz et al. , 2011 ; Salahat & Qasaimeh , 2017 ; Balntas et al. , 2017 ) . Most methods learn descriptors locally around pre-computed covisible interest regions in both images ( Yi et al. , 2016 ; Detone et al. , 2018 ; Balntas et al. , 2016a ; Luo et al. , 2019 ) , using convolutional-based siamese architectures trained with a contrastive loss ( Gordo et al. , 2016 ; Schroff et al. , 2015 ; Balntas et al. , 2016b ; Radenović et al. , 2016 ; Mishchuk et al. , 2017 ; Simonyan et al. , 2014 ) , or using pose ( Wang et al. , 2020 ; Zhou et al. , 2021 ) or self ( Yang et al. , 2021 ) supervision . To further improve the performances , ( Dusmanu et al. , 2019 ; Revaud et al. , 2019 ) propose to jointly learn to detect and describe keypoints in both images , while Germain et al . ( 2020 ) only detects in one image and densely matches descriptors in the other . Learning-based local feature matching . All the methods described in the previous paragraph establish correspondences by comparing descriptors using a simple operation such as a dot product . Thus the combination of such a simple matching method with a siamese architecture inevitably produces outlier correspondences , especially in non-covisible regions . To reduce the amount of outliers , most approaches employ so-called Mutual Nearest Neighbor ( MNN ) filtering . However , it is possible to go beyond a simple MNN and learn to match descriptors . Learning-based matching methods ( Zhang et al. , 2019 ; Brachmann & Rother , 2019 ; Moo Yi et al. , 2018 ; Sun et al. , 2020 ; Choy et al. , 2020 ; 2016 ) take as input local descriptors and/or putative correspondences , and learn to output correspondences probabilities . However , all these matching methods focus only on predicting correctly covisible correspondences . Jointly learning local feature description and matching . Several methods have recently proposed to jointly learn to compute and match descriptors ( Sarlin et al. , 2020 ; Sun et al. , 2021 ; Li et al. , 2020 ; Rocco et al. , 2018 ; 2020 ) . All these methods use a siamese Convolutional Neural Network ( CNN ) to obtain dense local descriptors , but they significantly differ regarding the way they establish matches . They actually fall into two categories . The first category of methods ( Li et al. , 2020 ; Rocco et al. , 2018 ; 2020 ) computes a 4D correlation tensor that essentially represents the scores of all the possible correspondences . This 4D correlation tensor is then used as input to a second network that learns to modify it using soft-MNN and 4D convolutions . Instead of summarizing all the information into a 4D correlation tensor , the second category of methods ( Sarlin et al. , 2020 ; Sun et al. , 2021 ) rely on Transformers ( Vaswani et al. , 2017 ; Dosovitskiy et al. , 2020 ; Ramachandran et al. , 2019 ; Caron et al. , 2021 ; Cordonnier et al. , 2020 ; Zhao et al. , 2020 ; Katharopoulos et al. , 2020 ) to let the descriptors of both images communicate and adapt to each other . All these methods again focus on identifying correctly covisible correspondences and consider non-covisible correspondences as noise . While our architecture is closely related to the second category of methods as we also rely on Transformers , the motivation for using it is quite different since it is our goal of hallucinating correspondences that calls for a non-siamese architecture ( see Sec.3 ) . Visual content hallucination . ( Yang et al. , 2019 ) proposes to hallucinate the content of RGB-D scans to perform relative pose estimation between two images . More recently ( Chen et al. , 2021 ) regresses distributions over relative camera poses for spherical images using joint processing of both images . The work of ( Yang et al. , 2020 ; Qian et al. , 2020 ; Jin et al. , 2021 ) shows that employing a hallucinate-then-match paradigm can be a reliable way of recovering 3D geometry or relative pose from sparsely sampled images . In this work , we focus on the problem of correspondence hallucination which unlike previously mentioned approaches does not aim at recovering explicit visual content or directly regressing a camera pose . Perhaps closest to our goal is Cai et al . ( 2021 ) that seeks to estimate a relative rotation between two non-overlapping images by learning to reason about “ hidden ” cues such as direction of shadows in outdoor scenes , parallel lines or vanishing points . 3 OUR APPROACH . Our goal is to train a network that takes as input a pair of partially overlapping source/target images and keypoints in the source image , and outputs for each keypoint a probability distribution over its correspondent ’ s location in the target image plane , regardless of this correspondent being visible , occluded , or outside the field of view . While the problem of learning to find the location of a visible correspondent received a lot of attention in the past few years ( see Sec . 2 ) , to the best of our knowledge , this paper is the first attempt of learning to find the location of a correspondent regardless of this correspondent being visible , occluded , or outside the field of view . Since this learning task is virgin territory , we first analyze its specific features below , before defining a loss function and a network architecture able to handle these features . 3.1 ANALYSIS OF THE PROBLEM . The task of finding the location of a correspondent regardless of this correspondent being visible , occluded , or outside the field of view actually leads to three different problems . Before stating those three problems , let us first recall the notion of correspondent as it is the keystone of our problem . Correspondent . Given a keypoint pS ∈ R2 in the source image IS , its depth dS ∈ R+ , and the relative camera pose RTS ∈ SO ( 3 ) , tTS ∈ R3 between the coordinate systems of IS and the target image IT , the correspondent pT ∈ R2 of pS in the target image plane is obtained by warping pS : pT : = ω ( dS , pS , RTS , tTS ) : = KTπ ( dSRTSK −1 S pS + tTS ) , where KS and KT are the camera calibration matrices of source and target images and π ( u ) : = [ ux/uz , uy/uz , 1 ] T is the projection function . In a slight abuse of notation , we do not distinguish a homogeneous 2D vector from a non-homogeneous 2D vector . Let us highlight that the correspondent pT of pS may not be visible , i.e . it may be occluded or outside the field of view . Identifying the correspondent . In the case where a network has to establish a correspondence between a keypoint pS in IS and its visible correspondent pT in IT , standard approaches , such as comparing a local descriptor computed at pS in IS with local descriptors computed at detected keypoints in IT , are applicable to identify the correspondent pT . Outpainting the correspondent . When pT is outside the field of view of IT , there is nothing to identify , i.e . neither can pT be detected as a keypoint nor can a local descriptor be computed at that location . Here the network first needs to identify correspondences in the region where IT overlaps with IS and realize that the correspondent pT is outside the field of view to eventually outpaint it ( see Fig . 1 ) . We call this operation `` outpainting the correspondent '' as the network needs to predict the location of pT outside the field of view of IT . Inpainting the correspondent . When pT is occluded in IT , the problem is even more difficult since local features can be computed at that location but will not match the local descriptor computed at pS in IS . As in the outpainting case , the network needs to identify correspondences in the region where IT overlaps with IS and realize that the correspondent pT is occluded to eventually inpaint the correspondent pT ( see Fig . 1 ) . We call this operation `` inpainting the correspondent '' as the network needs to predict the location of pT behind the occluding object . Let us now introduce a loss function and an architecture that are able to unify the identifying , inpainting and outpainting tasks . | In this manuscript, authors proposed a new problem of correspondence hallucination, in which for keypoint in the source image, its correspondence should be detected regardless if it is occluded or outside the field of view. In particular, the authors proposed a new model and training paradigm that learn to hallucinate correspondence by predicting its probability distribution of its location. Extensive experiments on both indoor and outdoor benchmarks demonstrated that proposed method can help camera pose estimation and outperforms prior state of the art feature matching approaches. | SP:4bad1ee9318dcf0d353aed7f9b8c1423db12435a |
Learning Scenario Representation for Solving Two-stage Stochastic Integer Programs | 1 INTRODUCTION . Stochastic integer programs ( SIPs ) are a class of combinatorial optimization problems ( COPs ) with uncertain parameters . They focus on finding a best decision for a practical task to optimize both the deterministic cost and the expectation of stochastic costs on a set of potential scenarios . Since the uncertain elements commonly exist in reality , SIPs are widely applied and studied in many fields such as transportation , inventory management , energy optimization , and so on ( Jammeli et al. , 2019 ; Dillon et al. , 2017 ; Bruno et al. , 2016 ; Wallace & Ziemba , 2005 ) . However , optimally solving SIP is intractable especially when many scenarios are involved , due to the fact that : 1 ) most integer programs themselves are already NP-hard ; 2 ) considerable ( even continuous ) scenarios significantly increase the computational complexity ( Klein , 2021 ) . In reality , solving moderate-sized problems may require prohibitively long time . Thus efficient and high-quality approximate solutions for SIPs are often practically pursued . The advances in deep ( reinforcement ) learning has aroused extensive studies on solving optimization problems with neural networks . The related works have shown promising results in tackling some classic COPs , e.g. , vehicle routing , job shop scheduling , combinatorial auction , etc . ( Kool et al. , 2019 ; Zhang et al. , 2020 ; Lee et al. , 2020 ; Kwon et al. , 2020 ; Gasse et al. , 2019 ; Chen & Tian , 2019 ; Ichter et al. , 2018 ; Hottung et al. , 2020 ; Wu et al. , 2021 ) . However , most of the existing deep learning based methods only focus on deterministic problems , which could hinder their practical applications in the uncertain situation . On the other hand , a few early attempts introduce deep learning to solve SIPs ( Larsen et al. , 2018 ; Abbasi et al. , 2020 ; Joe & Lau , 2020 ; Bengio et al. , 2020 ; Nair et al. , 2018 ) . However , they are generally designed for only specific problems and also lack the ability of generalizing across different problem sizes . In this paper , we focus on graph-based SIPs , which is a general class of problems with broad applications . We propose to learn the deep latent representation of scenarios in SIPs , which can be ∗Equal contribution . †Corresponding author ( zhiguangcao @ outlook.com ) . applied to various downstream tasks in solving SIPs , e.g. , scenario reduction and objective prediction . Based on the basic two-stage form of SIPs , we leverage conditional variational autoencoder ( CVAE ) to learn latent and continuous representations of stochastic scenarios while considering the deterministic part of a SIP instance , which we term the context . Specifically , we employ a graph convolutional network ( GCN ) to learn embeddings of each deterministic integer program , which models the first-stage problem with a single scenario . The learned embeddings are mapped into continuous representations , and then decoded back into corresponding scenarios given the embedding of the context . This design ensures that the learned representations of scenarios are correctly linked to the corresponding instances . The resulting latent space well represents scenarios in a class of SIP instances , and we demonstrate its power with two tasks commonly used in solving SIPs . First , we leverage it for scenario reduction by finding representative scenarios via an off-the-shelf clustering algorithm , which decreases the problem complexity and meanwhile attains high-quality approximate solutions . Second , we further extend the encoder with an additional sub-network to predict objective values for each scenario . Due to the generalization in the latent continuous space , we readily deploy the prediction task in semisupervised manner with a small number of target objective values . In doing so , the latent space is augmented with the predicted objective value and hence yields more representative scenarios , which further shrinks the approximation gap to the optimal solutions of the original SIPs . In summary , this paper aims to learn scenario representation for solving graph-based two-stage SIPs . The main contributions are as follows : • We firstly present a deep generative framework to learn representations for scenarios in graphbased two-stage SIPs . It considers dependencies of the scenarios on the deterministic context of each instance , and hence well differentiates scenarios in the latent space . • We apply the learned representations to scenario reduction and objective prediction for SIPs . The representative scenarios derived from clustering of the representations can be used to efficiently compute high-quality solutions for SIPs . Moreover , we further shrink the approximation error by predicting objective values of scenarios via semi-supervised learning . • We evaluate the proposed method on two SIP problems , i.e. , the network design problem and facility location problem . Experimental results verify the superiority of the learned scenario representation for solving SIPs . Our method significantly outperforms existing deep learning based baselines . Notably , it also generalizes well to problems with larger sizes or more scenarios . 2 RELATED WORK . Learning based methods for SIPs . Recent works of deep learning for COPs mostly address deterministic problems , with scarce attention to uncertainty that commonly exist in practice . Though a few methods apply deep learning to improve approximate solutions for two-stage SIPs , they are mostly designed for some specific problems . Nair et al . ( 2018 ) train a bit-flipping policy with reinforcement learning to improve solutions iteratively , but it is limited to binary decision variables and assumes no constraints in the first-stage problem . Larsen et al . ( 2018 ) predict properties of optimal solutions to integer programs ( i.e . the first-stage problem with respective single scenario ) in a supervised manner . This method is only applicable when operational solutions are not needed . In contrast , Abbasi et al . ( 2020 ) predict values of decision variables for blood transshipment problem with fixed-sized instances . To reduce the complexity of SIPs , Bengio et al . ( 2020 ) aim to yield one scenario for the first-stage problem , so that the derived solution achieves a small objective value when evaluated with the original set of scenarios . This method assumes complete recourse , with any generated scenario being feasible for the second-stage problem . All the above methods attempt to reduce the expected cost of stochastic scenarios but their applications are limited by distinct assumptions or fixed problem sizes . In contrast , our method can be used for more general two-stage SIPs , and generalizes well to varying problem sizes or scenario quantities . Scenario reduction for SIPs . In the SIP formulation , a set of scenarios is used to model stochastic events on top of the first-stage problem . It introduces extra complexity which may exponentially increase with its cardinality , owing to the combinatorial search space ( Dyer & Stougie , 2006 ) . Since the direct optimization with massive scenarios is intractable , the scenario reduction is often conducted to find a subset of scenarios that well replaces the original set with a small approximation error . Existing reduction methods mainly branches into distribution-oriented and problem-oriented paradigms . The former ones pursue a group of scenarios that closely estimate the probability distribution under the scenario space ( Henrion & Römisch , 2017 ) . The distance between the estimated and actual probability are often measured by Wasserstein distance ( Rujeerapaiboon et al. , 2018 ) , polyhedral discrepancy ( Henrion et al. , 2008 ) or difference of moments ( Høyland et al. , 2003 ) . These methods neglect the influence of the context on the objective function , e.g. , similar scenario distributions may cause different expected costs in disparate SIP instances . Thus , there is a recent trend towards the study of problem-oriented methods ( Henrion & Römisch , 2018 ; Fairbrother et al. , 2019 ; Keutchayan et al. , 2020 ; 2021 ) , which attempts to involve problem-specific properties in scenario reduction . For example , Keutchayan et al . ( 2021 ) propose to find K scenarios with their objective values separately approximating the expected objective values in the K scenario subsets . Most the above methods are mainly for theoretical proof on stochastic programs ( without the restriction of integers ) . In contrast , we firstly propose a deep learning method for SIPs to learn scenario representation , which can be used for both scenario reduction and objective prediction . 3 PRELIMINARIES . 3.1 TWO-STAGE STOCHASTIC INTEGER PROGRAMS . As an optimization problem , SIP is usually characterized by both the uncertain parameters that potentially follow certain probability distributions and the discrete solution space due to the integer restrictions . It is commonly described by a two-stage formulation as below : min x µ⊤x+ Eω [ Q ( x , ω ) ] ( 1 ) s.t . Ax ≤ b , x ∈ Rn1−p1 × Zp1 , ( 2 ) where Q ( x , ω ) : = miny { q⊤ω y|Wωy ≤ hω − Tωx ; y ∈ Rn2−p2 × Zp2 } . In particular , Eq . ( 1 ) and ( 2 ) prescribe the first-stage problem with x ∈ Rn1 being the decision variable , where n1 ≥ p1 ; Q ( x , ω ) prescribes the second-stage problem , with y ∈ Rn2 being the decision variable , where n2 ≥ p2 . We refer to the group of static parameters µ ∈ Rn1 , A ∈ Rm1×n1 and b ∈ Rm1 in the first stage as the context , and assume that the group of uncertain parameters qω ∈ Rn2 , Wω ∈ Rm2×n2 , Tω ∈ Rm2×n1 and hω ∈ Rm2 follows a distribution P . Here we focus on SIPs defined on graphs , which are a family of problems with practical applications in many domains such as networks , transportation and scheduling ( Rahmaniani et al. , 2018 ; An & Lo , 2016 ) . The primary method to solve the above SIP is sample average approximation ( Kleywegt et al. , 2002 ) , which converts it into a mixed integer program ( MIP ) by Monte Carlo simulation and in turn optimizes the following objective : O ( x ) : = min x µ⊤x+ 1 N ∑N i=1 Q ( x , ωi ) , ( 3 ) where { ωi } Ni=1 is a set of scenarios from P , i.e. , an independently and identically distributed ( i.i.d . ) random sample of N realizations of uncertain parameters . Typically , a large scenario set is often required to make the distribution of scenarios P̃ well fit P , which may cause intractable MIP for a given solver . In this paper , we aim to find a small number of informative representatives in { ωi } Ni=1 by learning representations of scenarios , which is supposed to considerably boost the computation efficiency with tolerable approximation errors . 3.2 CONDITIONAL VARIATIONAL AUTOENCODER . As an unsupervised generative model , CVAE is developed on top of VAE , and it further controls the data generation process conditioned on additional random variables ( Sohn et al. , 2015 ) . These conditional variables could be either class labels or certain properties of the data with specific distributions , which are engaged in the input to both the encoder and decoder . Optimized with the stochastic gradient variational bayes ( SGVB ) framework ( Kingma & Welling , 2014 ) , the evidence lower bound objective ( ELBO ) of CVAE on the marginal likelihood for the input data is defined as : log pθ ( X , c ) ≥ ELBO ( X , c ) = Eqϕ ( z|X , c ) [ log pθ ( X|z , c ) ] − KL [ qϕ ( z|X , c ) ∥p ( z|c ) ] , ( 4 ) where X , c , z denote input , latent and conditional variables , respectively ; both the encoder qϕ and decoder pθ are typically parameterized by deep neural networks . Rather than simple distributions of conditional variables in most existing works , in this paper we exploit CVAE to learn scenario representation in SIPs , with conditional variables derived from continuous parameters in the context . For more details of CVAE , we refer readers to ( Kingma et al. , 2014 ; Feng et al. , 2021 ) . | This paper studies the problem of generating representative scenarios for two-stage stochastic integer programmings in which the parameters could be either static (referred to as context) or stochastic (forming a space of scenarios). The proposed method leverages conditional variational autoencoder to learn the distribution of scenarios conditioned on the context, where the encoder computes the latent variables (based on the context and scenarios) while the decoder recovers the scenarios. In particular, the functions are parametrized by graph neural networks and multilayer perceptron. Experiments on two concrete problems are performed. | SP:92c1e01fac5c67a7561cbeabeae1213d2f5eddeb |
Learning Scenario Representation for Solving Two-stage Stochastic Integer Programs | 1 INTRODUCTION . Stochastic integer programs ( SIPs ) are a class of combinatorial optimization problems ( COPs ) with uncertain parameters . They focus on finding a best decision for a practical task to optimize both the deterministic cost and the expectation of stochastic costs on a set of potential scenarios . Since the uncertain elements commonly exist in reality , SIPs are widely applied and studied in many fields such as transportation , inventory management , energy optimization , and so on ( Jammeli et al. , 2019 ; Dillon et al. , 2017 ; Bruno et al. , 2016 ; Wallace & Ziemba , 2005 ) . However , optimally solving SIP is intractable especially when many scenarios are involved , due to the fact that : 1 ) most integer programs themselves are already NP-hard ; 2 ) considerable ( even continuous ) scenarios significantly increase the computational complexity ( Klein , 2021 ) . In reality , solving moderate-sized problems may require prohibitively long time . Thus efficient and high-quality approximate solutions for SIPs are often practically pursued . The advances in deep ( reinforcement ) learning has aroused extensive studies on solving optimization problems with neural networks . The related works have shown promising results in tackling some classic COPs , e.g. , vehicle routing , job shop scheduling , combinatorial auction , etc . ( Kool et al. , 2019 ; Zhang et al. , 2020 ; Lee et al. , 2020 ; Kwon et al. , 2020 ; Gasse et al. , 2019 ; Chen & Tian , 2019 ; Ichter et al. , 2018 ; Hottung et al. , 2020 ; Wu et al. , 2021 ) . However , most of the existing deep learning based methods only focus on deterministic problems , which could hinder their practical applications in the uncertain situation . On the other hand , a few early attempts introduce deep learning to solve SIPs ( Larsen et al. , 2018 ; Abbasi et al. , 2020 ; Joe & Lau , 2020 ; Bengio et al. , 2020 ; Nair et al. , 2018 ) . However , they are generally designed for only specific problems and also lack the ability of generalizing across different problem sizes . In this paper , we focus on graph-based SIPs , which is a general class of problems with broad applications . We propose to learn the deep latent representation of scenarios in SIPs , which can be ∗Equal contribution . †Corresponding author ( zhiguangcao @ outlook.com ) . applied to various downstream tasks in solving SIPs , e.g. , scenario reduction and objective prediction . Based on the basic two-stage form of SIPs , we leverage conditional variational autoencoder ( CVAE ) to learn latent and continuous representations of stochastic scenarios while considering the deterministic part of a SIP instance , which we term the context . Specifically , we employ a graph convolutional network ( GCN ) to learn embeddings of each deterministic integer program , which models the first-stage problem with a single scenario . The learned embeddings are mapped into continuous representations , and then decoded back into corresponding scenarios given the embedding of the context . This design ensures that the learned representations of scenarios are correctly linked to the corresponding instances . The resulting latent space well represents scenarios in a class of SIP instances , and we demonstrate its power with two tasks commonly used in solving SIPs . First , we leverage it for scenario reduction by finding representative scenarios via an off-the-shelf clustering algorithm , which decreases the problem complexity and meanwhile attains high-quality approximate solutions . Second , we further extend the encoder with an additional sub-network to predict objective values for each scenario . Due to the generalization in the latent continuous space , we readily deploy the prediction task in semisupervised manner with a small number of target objective values . In doing so , the latent space is augmented with the predicted objective value and hence yields more representative scenarios , which further shrinks the approximation gap to the optimal solutions of the original SIPs . In summary , this paper aims to learn scenario representation for solving graph-based two-stage SIPs . The main contributions are as follows : • We firstly present a deep generative framework to learn representations for scenarios in graphbased two-stage SIPs . It considers dependencies of the scenarios on the deterministic context of each instance , and hence well differentiates scenarios in the latent space . • We apply the learned representations to scenario reduction and objective prediction for SIPs . The representative scenarios derived from clustering of the representations can be used to efficiently compute high-quality solutions for SIPs . Moreover , we further shrink the approximation error by predicting objective values of scenarios via semi-supervised learning . • We evaluate the proposed method on two SIP problems , i.e. , the network design problem and facility location problem . Experimental results verify the superiority of the learned scenario representation for solving SIPs . Our method significantly outperforms existing deep learning based baselines . Notably , it also generalizes well to problems with larger sizes or more scenarios . 2 RELATED WORK . Learning based methods for SIPs . Recent works of deep learning for COPs mostly address deterministic problems , with scarce attention to uncertainty that commonly exist in practice . Though a few methods apply deep learning to improve approximate solutions for two-stage SIPs , they are mostly designed for some specific problems . Nair et al . ( 2018 ) train a bit-flipping policy with reinforcement learning to improve solutions iteratively , but it is limited to binary decision variables and assumes no constraints in the first-stage problem . Larsen et al . ( 2018 ) predict properties of optimal solutions to integer programs ( i.e . the first-stage problem with respective single scenario ) in a supervised manner . This method is only applicable when operational solutions are not needed . In contrast , Abbasi et al . ( 2020 ) predict values of decision variables for blood transshipment problem with fixed-sized instances . To reduce the complexity of SIPs , Bengio et al . ( 2020 ) aim to yield one scenario for the first-stage problem , so that the derived solution achieves a small objective value when evaluated with the original set of scenarios . This method assumes complete recourse , with any generated scenario being feasible for the second-stage problem . All the above methods attempt to reduce the expected cost of stochastic scenarios but their applications are limited by distinct assumptions or fixed problem sizes . In contrast , our method can be used for more general two-stage SIPs , and generalizes well to varying problem sizes or scenario quantities . Scenario reduction for SIPs . In the SIP formulation , a set of scenarios is used to model stochastic events on top of the first-stage problem . It introduces extra complexity which may exponentially increase with its cardinality , owing to the combinatorial search space ( Dyer & Stougie , 2006 ) . Since the direct optimization with massive scenarios is intractable , the scenario reduction is often conducted to find a subset of scenarios that well replaces the original set with a small approximation error . Existing reduction methods mainly branches into distribution-oriented and problem-oriented paradigms . The former ones pursue a group of scenarios that closely estimate the probability distribution under the scenario space ( Henrion & Römisch , 2017 ) . The distance between the estimated and actual probability are often measured by Wasserstein distance ( Rujeerapaiboon et al. , 2018 ) , polyhedral discrepancy ( Henrion et al. , 2008 ) or difference of moments ( Høyland et al. , 2003 ) . These methods neglect the influence of the context on the objective function , e.g. , similar scenario distributions may cause different expected costs in disparate SIP instances . Thus , there is a recent trend towards the study of problem-oriented methods ( Henrion & Römisch , 2018 ; Fairbrother et al. , 2019 ; Keutchayan et al. , 2020 ; 2021 ) , which attempts to involve problem-specific properties in scenario reduction . For example , Keutchayan et al . ( 2021 ) propose to find K scenarios with their objective values separately approximating the expected objective values in the K scenario subsets . Most the above methods are mainly for theoretical proof on stochastic programs ( without the restriction of integers ) . In contrast , we firstly propose a deep learning method for SIPs to learn scenario representation , which can be used for both scenario reduction and objective prediction . 3 PRELIMINARIES . 3.1 TWO-STAGE STOCHASTIC INTEGER PROGRAMS . As an optimization problem , SIP is usually characterized by both the uncertain parameters that potentially follow certain probability distributions and the discrete solution space due to the integer restrictions . It is commonly described by a two-stage formulation as below : min x µ⊤x+ Eω [ Q ( x , ω ) ] ( 1 ) s.t . Ax ≤ b , x ∈ Rn1−p1 × Zp1 , ( 2 ) where Q ( x , ω ) : = miny { q⊤ω y|Wωy ≤ hω − Tωx ; y ∈ Rn2−p2 × Zp2 } . In particular , Eq . ( 1 ) and ( 2 ) prescribe the first-stage problem with x ∈ Rn1 being the decision variable , where n1 ≥ p1 ; Q ( x , ω ) prescribes the second-stage problem , with y ∈ Rn2 being the decision variable , where n2 ≥ p2 . We refer to the group of static parameters µ ∈ Rn1 , A ∈ Rm1×n1 and b ∈ Rm1 in the first stage as the context , and assume that the group of uncertain parameters qω ∈ Rn2 , Wω ∈ Rm2×n2 , Tω ∈ Rm2×n1 and hω ∈ Rm2 follows a distribution P . Here we focus on SIPs defined on graphs , which are a family of problems with practical applications in many domains such as networks , transportation and scheduling ( Rahmaniani et al. , 2018 ; An & Lo , 2016 ) . The primary method to solve the above SIP is sample average approximation ( Kleywegt et al. , 2002 ) , which converts it into a mixed integer program ( MIP ) by Monte Carlo simulation and in turn optimizes the following objective : O ( x ) : = min x µ⊤x+ 1 N ∑N i=1 Q ( x , ωi ) , ( 3 ) where { ωi } Ni=1 is a set of scenarios from P , i.e. , an independently and identically distributed ( i.i.d . ) random sample of N realizations of uncertain parameters . Typically , a large scenario set is often required to make the distribution of scenarios P̃ well fit P , which may cause intractable MIP for a given solver . In this paper , we aim to find a small number of informative representatives in { ωi } Ni=1 by learning representations of scenarios , which is supposed to considerably boost the computation efficiency with tolerable approximation errors . 3.2 CONDITIONAL VARIATIONAL AUTOENCODER . As an unsupervised generative model , CVAE is developed on top of VAE , and it further controls the data generation process conditioned on additional random variables ( Sohn et al. , 2015 ) . These conditional variables could be either class labels or certain properties of the data with specific distributions , which are engaged in the input to both the encoder and decoder . Optimized with the stochastic gradient variational bayes ( SGVB ) framework ( Kingma & Welling , 2014 ) , the evidence lower bound objective ( ELBO ) of CVAE on the marginal likelihood for the input data is defined as : log pθ ( X , c ) ≥ ELBO ( X , c ) = Eqϕ ( z|X , c ) [ log pθ ( X|z , c ) ] − KL [ qϕ ( z|X , c ) ∥p ( z|c ) ] , ( 4 ) where X , c , z denote input , latent and conditional variables , respectively ; both the encoder qϕ and decoder pθ are typically parameterized by deep neural networks . Rather than simple distributions of conditional variables in most existing works , in this paper we exploit CVAE to learn scenario representation in SIPs , with conditional variables derived from continuous parameters in the context . For more details of CVAE , we refer readers to ( Kingma et al. , 2014 ; Feng et al. , 2021 ) . | The paper aims to use deep-learning towards solving generic stochastic integer programs. The proposed approach involves using a conditional VAE to model the distribution over scenarios, and leveraging the scenario's latent space embeddings to enable better representative scenario selection: the embeddings are used as inputs to a standard clustering algorithm that returns representatives. The paper demonstrates that using VAE embeddings improves performance when compared to using the same clustering algorithm on the raw scenario representations. It further demonstrates that using embeddings concatenated with a predicted objective generally improves performance over using the embeddings alone. Finally, the paper shows improvement over two recent approaches. | SP:92c1e01fac5c67a7561cbeabeae1213d2f5eddeb |
Learning Scenario Representation for Solving Two-stage Stochastic Integer Programs | 1 INTRODUCTION . Stochastic integer programs ( SIPs ) are a class of combinatorial optimization problems ( COPs ) with uncertain parameters . They focus on finding a best decision for a practical task to optimize both the deterministic cost and the expectation of stochastic costs on a set of potential scenarios . Since the uncertain elements commonly exist in reality , SIPs are widely applied and studied in many fields such as transportation , inventory management , energy optimization , and so on ( Jammeli et al. , 2019 ; Dillon et al. , 2017 ; Bruno et al. , 2016 ; Wallace & Ziemba , 2005 ) . However , optimally solving SIP is intractable especially when many scenarios are involved , due to the fact that : 1 ) most integer programs themselves are already NP-hard ; 2 ) considerable ( even continuous ) scenarios significantly increase the computational complexity ( Klein , 2021 ) . In reality , solving moderate-sized problems may require prohibitively long time . Thus efficient and high-quality approximate solutions for SIPs are often practically pursued . The advances in deep ( reinforcement ) learning has aroused extensive studies on solving optimization problems with neural networks . The related works have shown promising results in tackling some classic COPs , e.g. , vehicle routing , job shop scheduling , combinatorial auction , etc . ( Kool et al. , 2019 ; Zhang et al. , 2020 ; Lee et al. , 2020 ; Kwon et al. , 2020 ; Gasse et al. , 2019 ; Chen & Tian , 2019 ; Ichter et al. , 2018 ; Hottung et al. , 2020 ; Wu et al. , 2021 ) . However , most of the existing deep learning based methods only focus on deterministic problems , which could hinder their practical applications in the uncertain situation . On the other hand , a few early attempts introduce deep learning to solve SIPs ( Larsen et al. , 2018 ; Abbasi et al. , 2020 ; Joe & Lau , 2020 ; Bengio et al. , 2020 ; Nair et al. , 2018 ) . However , they are generally designed for only specific problems and also lack the ability of generalizing across different problem sizes . In this paper , we focus on graph-based SIPs , which is a general class of problems with broad applications . We propose to learn the deep latent representation of scenarios in SIPs , which can be ∗Equal contribution . †Corresponding author ( zhiguangcao @ outlook.com ) . applied to various downstream tasks in solving SIPs , e.g. , scenario reduction and objective prediction . Based on the basic two-stage form of SIPs , we leverage conditional variational autoencoder ( CVAE ) to learn latent and continuous representations of stochastic scenarios while considering the deterministic part of a SIP instance , which we term the context . Specifically , we employ a graph convolutional network ( GCN ) to learn embeddings of each deterministic integer program , which models the first-stage problem with a single scenario . The learned embeddings are mapped into continuous representations , and then decoded back into corresponding scenarios given the embedding of the context . This design ensures that the learned representations of scenarios are correctly linked to the corresponding instances . The resulting latent space well represents scenarios in a class of SIP instances , and we demonstrate its power with two tasks commonly used in solving SIPs . First , we leverage it for scenario reduction by finding representative scenarios via an off-the-shelf clustering algorithm , which decreases the problem complexity and meanwhile attains high-quality approximate solutions . Second , we further extend the encoder with an additional sub-network to predict objective values for each scenario . Due to the generalization in the latent continuous space , we readily deploy the prediction task in semisupervised manner with a small number of target objective values . In doing so , the latent space is augmented with the predicted objective value and hence yields more representative scenarios , which further shrinks the approximation gap to the optimal solutions of the original SIPs . In summary , this paper aims to learn scenario representation for solving graph-based two-stage SIPs . The main contributions are as follows : • We firstly present a deep generative framework to learn representations for scenarios in graphbased two-stage SIPs . It considers dependencies of the scenarios on the deterministic context of each instance , and hence well differentiates scenarios in the latent space . • We apply the learned representations to scenario reduction and objective prediction for SIPs . The representative scenarios derived from clustering of the representations can be used to efficiently compute high-quality solutions for SIPs . Moreover , we further shrink the approximation error by predicting objective values of scenarios via semi-supervised learning . • We evaluate the proposed method on two SIP problems , i.e. , the network design problem and facility location problem . Experimental results verify the superiority of the learned scenario representation for solving SIPs . Our method significantly outperforms existing deep learning based baselines . Notably , it also generalizes well to problems with larger sizes or more scenarios . 2 RELATED WORK . Learning based methods for SIPs . Recent works of deep learning for COPs mostly address deterministic problems , with scarce attention to uncertainty that commonly exist in practice . Though a few methods apply deep learning to improve approximate solutions for two-stage SIPs , they are mostly designed for some specific problems . Nair et al . ( 2018 ) train a bit-flipping policy with reinforcement learning to improve solutions iteratively , but it is limited to binary decision variables and assumes no constraints in the first-stage problem . Larsen et al . ( 2018 ) predict properties of optimal solutions to integer programs ( i.e . the first-stage problem with respective single scenario ) in a supervised manner . This method is only applicable when operational solutions are not needed . In contrast , Abbasi et al . ( 2020 ) predict values of decision variables for blood transshipment problem with fixed-sized instances . To reduce the complexity of SIPs , Bengio et al . ( 2020 ) aim to yield one scenario for the first-stage problem , so that the derived solution achieves a small objective value when evaluated with the original set of scenarios . This method assumes complete recourse , with any generated scenario being feasible for the second-stage problem . All the above methods attempt to reduce the expected cost of stochastic scenarios but their applications are limited by distinct assumptions or fixed problem sizes . In contrast , our method can be used for more general two-stage SIPs , and generalizes well to varying problem sizes or scenario quantities . Scenario reduction for SIPs . In the SIP formulation , a set of scenarios is used to model stochastic events on top of the first-stage problem . It introduces extra complexity which may exponentially increase with its cardinality , owing to the combinatorial search space ( Dyer & Stougie , 2006 ) . Since the direct optimization with massive scenarios is intractable , the scenario reduction is often conducted to find a subset of scenarios that well replaces the original set with a small approximation error . Existing reduction methods mainly branches into distribution-oriented and problem-oriented paradigms . The former ones pursue a group of scenarios that closely estimate the probability distribution under the scenario space ( Henrion & Römisch , 2017 ) . The distance between the estimated and actual probability are often measured by Wasserstein distance ( Rujeerapaiboon et al. , 2018 ) , polyhedral discrepancy ( Henrion et al. , 2008 ) or difference of moments ( Høyland et al. , 2003 ) . These methods neglect the influence of the context on the objective function , e.g. , similar scenario distributions may cause different expected costs in disparate SIP instances . Thus , there is a recent trend towards the study of problem-oriented methods ( Henrion & Römisch , 2018 ; Fairbrother et al. , 2019 ; Keutchayan et al. , 2020 ; 2021 ) , which attempts to involve problem-specific properties in scenario reduction . For example , Keutchayan et al . ( 2021 ) propose to find K scenarios with their objective values separately approximating the expected objective values in the K scenario subsets . Most the above methods are mainly for theoretical proof on stochastic programs ( without the restriction of integers ) . In contrast , we firstly propose a deep learning method for SIPs to learn scenario representation , which can be used for both scenario reduction and objective prediction . 3 PRELIMINARIES . 3.1 TWO-STAGE STOCHASTIC INTEGER PROGRAMS . As an optimization problem , SIP is usually characterized by both the uncertain parameters that potentially follow certain probability distributions and the discrete solution space due to the integer restrictions . It is commonly described by a two-stage formulation as below : min x µ⊤x+ Eω [ Q ( x , ω ) ] ( 1 ) s.t . Ax ≤ b , x ∈ Rn1−p1 × Zp1 , ( 2 ) where Q ( x , ω ) : = miny { q⊤ω y|Wωy ≤ hω − Tωx ; y ∈ Rn2−p2 × Zp2 } . In particular , Eq . ( 1 ) and ( 2 ) prescribe the first-stage problem with x ∈ Rn1 being the decision variable , where n1 ≥ p1 ; Q ( x , ω ) prescribes the second-stage problem , with y ∈ Rn2 being the decision variable , where n2 ≥ p2 . We refer to the group of static parameters µ ∈ Rn1 , A ∈ Rm1×n1 and b ∈ Rm1 in the first stage as the context , and assume that the group of uncertain parameters qω ∈ Rn2 , Wω ∈ Rm2×n2 , Tω ∈ Rm2×n1 and hω ∈ Rm2 follows a distribution P . Here we focus on SIPs defined on graphs , which are a family of problems with practical applications in many domains such as networks , transportation and scheduling ( Rahmaniani et al. , 2018 ; An & Lo , 2016 ) . The primary method to solve the above SIP is sample average approximation ( Kleywegt et al. , 2002 ) , which converts it into a mixed integer program ( MIP ) by Monte Carlo simulation and in turn optimizes the following objective : O ( x ) : = min x µ⊤x+ 1 N ∑N i=1 Q ( x , ωi ) , ( 3 ) where { ωi } Ni=1 is a set of scenarios from P , i.e. , an independently and identically distributed ( i.i.d . ) random sample of N realizations of uncertain parameters . Typically , a large scenario set is often required to make the distribution of scenarios P̃ well fit P , which may cause intractable MIP for a given solver . In this paper , we aim to find a small number of informative representatives in { ωi } Ni=1 by learning representations of scenarios , which is supposed to considerably boost the computation efficiency with tolerable approximation errors . 3.2 CONDITIONAL VARIATIONAL AUTOENCODER . As an unsupervised generative model , CVAE is developed on top of VAE , and it further controls the data generation process conditioned on additional random variables ( Sohn et al. , 2015 ) . These conditional variables could be either class labels or certain properties of the data with specific distributions , which are engaged in the input to both the encoder and decoder . Optimized with the stochastic gradient variational bayes ( SGVB ) framework ( Kingma & Welling , 2014 ) , the evidence lower bound objective ( ELBO ) of CVAE on the marginal likelihood for the input data is defined as : log pθ ( X , c ) ≥ ELBO ( X , c ) = Eqϕ ( z|X , c ) [ log pθ ( X|z , c ) ] − KL [ qϕ ( z|X , c ) ∥p ( z|c ) ] , ( 4 ) where X , c , z denote input , latent and conditional variables , respectively ; both the encoder qϕ and decoder pθ are typically parameterized by deep neural networks . Rather than simple distributions of conditional variables in most existing works , in this paper we exploit CVAE to learn scenario representation in SIPs , with conditional variables derived from continuous parameters in the context . For more details of CVAE , we refer readers to ( Kingma et al. , 2014 ; Feng et al. , 2021 ) . | Solving stochastic integer programs in practice can be difficult for large problems with many scenarios (i.e., sample discretizations of the uncertain distribution), motivating relevant problems such as scenario reduction and objective prediction. This paper explores these problems by using a graph conditional VAE to learn low-dimensional representations of scenarios and perform downstream tasks in this space. The results show improvements over existing scenario reduction and objective prediction methods over the original high-dimensional space. | SP:92c1e01fac5c67a7561cbeabeae1213d2f5eddeb |
SoftHebb: Bayesian inference in unsupervised Hebbian soft winner-take-all networks | 1 INTRODUCTION . State-of-the-art ( SOTA ) artificial neural networks ( ANNs ) achieve impressive results in a variety of machine intelligence tasks ( Sejnowski , 2020 ) . However , they largely rely on mechanisms that diverge from the original inspiration from biological neural networks ( Bengio et al. , 2015 ; Illing et al. , 2019 ) . As a result , only a small part of this prolific field also contributes to computational neuroscience . In fact , this biological implausibility is also an important issue for machine intelligence . For their impressive performance , ANNs trade off other desired properties , which are present in biological systems . For example , ANN training often demands very large and labelled datasets . When labels are unavailable , self-supervised learning schemes exist , where supervisory error signals generated by the network itself are exploited and backpropagated from the output towards the input to update the network ’ s parameters ( Goodfellow et al. , 2014 ; Devlin et al. , 2018 ; Chen et al. , 2020 ) . However , this global propagation of signals in deep networks introduces another limitation . Namely , it prevents the implementation of efficient distributed computing hardware that would be based on only local signals from neighbouring physical nodes in the network , and is in contrast to local synaptic plasticity rules that partly govern biological learning . Several pieces of work have been addressing parts of the biological implausibility and hardware-inefficiency of backpropagation in ANNs ( Bengio et al. , 2015 ; Lillicrap et al. , 2016 ; Guerguiev et al. , 2017 ; Pfeiffer & Pfeil , 2018 ; Illing et al. , 2019 ; Pogodin & Latham , 2020 ; Millidge et al. , 2020 ; Pogodin et al. , 2021 ) . such as the need for exactly symmetric forward and backward weights or the waiting time caused by the network ’ s forward-backward pass between two training updates in a layer ( weight transport and update-locking problems ) . Recently , an approximation to backpropagation that is mostly Hebbian , i.e . relies on mostly pre- and post- synaptic activity of each synapse , has been achieved by reducing the global error requirements to 1-bit information ( Pogodin & Latham , 2020 ) . Two schemes that further localize the signal that is required for a weight update are Equilibrium Propagation ( Scellier & Bengio , 2017 ) and Predictive Coding ( Millidge et al. , 2020 ) . Both methods approximate backpropagation through Hebbian-like learning , by delegating the global aspect of the computation , from a global error signal , to a global convergence of the network state to an equilibrium . This equilibrium is reached through several iterative steps of feed-forward and feed-back communication throughout the network , before the ultimate weight update by one training example . The biological plausibility and hardware-efficiency of this added iterative process of signal propagation are open questions that begin to be addressed ( Ernoult et al. , 2020 ) . Moreover , learning through backpropagation , and presumably also its approximations , has another indication of biological implausibility , which also significantly limits ANN applicability . Namely , it produces networks that are confused by small adversarial perturbations of the input , which are imperceptible by humans . It has recently been proposed that a defence strategy of `` deflection '' of adversarial attacks may be the ultimate solution to that problem ( Qin et al. , 2020 ) . Through this strategy , to cause confusion in the network ’ s inferred class , the adversary is forced to generate such a changed input that really belongs to the distribution of a different input class . Intuitively , but also strictly by definition , this deflection is achieved if a human assigns to the perturbed input the same label that the network does . Deflection of adversarial attacks in ANNs has been demonstrated by an elaborate scheme that is based on detecting the attacks ( Qin et al. , 2020 ) . However , the human ability to deflect adversarial perturbations likely does not rely on detecting them , but rather on effectively ignoring them , making the deflecting type of robustness an emergent property of biological computation rather than a defence mechanism . The biological principles that underlie this property of robustness are unclear , but it might emerge from the distinct algorithms that govern learning in the brain . Therefore , what is missing is a biologically plausible model that can learn from fewer data-points , without labels , through local plasticity , and without feedback from distant layers . This model could then be tested for emergent adversarial robustness . A good candidate category of biological networks and learning algorithms is that of competitive learning . Neurons that compete for their activation through lateral inhibition are a common connectivity pattern in the superficial layers of the cerebral cortex ( Douglas & Martin , 2004 ; Binzegger et al. , 2004 ) . This pattern is described as winner-take-all ( WTA ) , because competition suppresses activity of weakly activated neurons , and emphasizes strong ones . Combined with Hebbian-like plasticity rules , WTA connectivity gives rise to competitivelearning algorithms . These networks and learning schemes have been long studied ( Von der Malsburg , 1973 ) and a large literature based on simulations and analyses describes their functional properties . A WTA neuronal layer , depending on its specifics , can restore missing input signals ( Rutishauser et al. , 2011 ; Diehl & Cook , 2016 ) , perform decision making i.e . winner selection ( Hahnloser et al. , 1999 ; Maass , 2000 ; Rutishauser et al. , 2011 ) , and generate oscillations such as those that underlie brain rhythms ( Cannon et al. , 2014 ) . Perhaps more importantly , its neurons can learn to become selective to different input patterns , such as orientation of visual bars in models of the primary visual cortex ( Von der Malsburg , 1973 ) , MNIST handwritten digits ( Nessler et al. , 2013 ; Diehl & Cook , 2015 ; Krotov & Hopfield , 2019 ) , CIFAR10 objects ( Krotov & Hopfield , 2019 ) , spatiotemporal spiking patterns ( Nessler et al. , 2013 ) , and can adapt dynamically to model changing objects ( Moraitis et al. , 2020 ) . The WTA model is indeed biologically plausible , Hebbian plasticity is local , and learning is input-driven , relying on only feed-forward communication of neurons – properties that seem to address several of the limitations of ANNs . However , the model ’ s applicability is limited to simple tasks . That is partly because the related theoretical literature remains surprisingly unsettled , despite its long history , and the strong and productive community interest ( Sanger , 1989 ; Földiák & Fdilr , 1989 ; Földiak , 1990 ; Linsker , 1992 ; Olshausen & Field , 1996 ; Bell & Sejnowski , 1995 ; Olshausen & Field , 1997 ; Lee et al. , 1999 ; Nessler et al. , 2013 ; Pehlevan & Chklovskii , 2014 ; Hu et al. , 2014 ; Pehlevan & Chklovskii , 2015 ; Pehlevan et al. , 2017 ; Isomura & Toyoizumi , 2018 ) . Nessler et al . ( 2009 ; 2013 ) described a very related theory but for a model that is largely incompatible with ANNs and thus less practical . It uses spiking and stochastic neurons , input has to be discretized , and each input feature must be encoded through multiple binary neurons . Moreover , it was only proven for neurons with an exponential activation function . It remains therefore unclear which specific plasticity rule and structure could optimize an ANN WTA for Bayesian inference . It is also unclear how to minimize a common loss function such as cross-entropy despite unsupervised learning , and how a WTA could represent varying families of probability distributions . In summary , on the theoretical side , an algorithm that is simultaneously normative , based on WTA networks and Hebbian unsupervised plasticity , performs Bayesian inference , and , importantly , is composed of conventional , i.e . non-spiking , ANN elements and is rigorously linked to modern ANN tools such as cross-entropy loss , would be an important advance but has been missing . On the practical side , evidence that Hebbian WTA networks could be useful for presently pertinent issues of modern ANNs such as adversarial robustness , generation of synthetic images , or faster learning , has remained limited . Here we aim to fill these gaps . Recently , when WTA networks were studied in a theoretical framework compatible with conventional machine learning ( ML ) , but in the context of short-term as opposed to long-term Hebbian plasticity , it resulted in surprising practical advantages over supervised ANNs ( Moraitis et al. , 2020 ) . A similar theoretical approach could also reveal unknown advantages of long-term Hebbian plasticity in WTA networks . In addition , it could provide insights into how a WTA microcircuit could participate in larger-scale computation by deeper cortical or artificial networks . Here we construct `` SoftHebb '' , a biologically plausible WTA model that is based on standard ratebased neurons as in ANNs , can accommodate various activation functions , and learns without labels , using local plasticity and only feed-forward communication , i.e . the properties we seek in an ANN . Importantly , it is equipped with a simple normalization of the layer ’ s activations , and an optional temperature-scaling mechanism ( Hinton et al. , 2015 ) , producing a soft WTA instead of selecting a single `` hard '' winner neuron . This allows us to prove formally that a SoftHebb layer is a generative mixture model that objectively minimizes its Kullback-Leibler ( KL ) divergence from the input distribution through Bayesian inference , thus providing a new formal ML-theoretic perspective of these networks . We complement our main results , which are theoretical , with experiments that are small-scale but produce intriguing results . As a generative model , SoftHebb has a broader scope than classification , but we test it on image classification tasks . Surprisingly , in addition to overcoming several inefficiencies of backpropagation , the unsupervised WTA model also outperforms a supervised two-layer perceptron in several aspects : learning speed and accuracy in the first presentation of the training dataset , robustness to noisy data and to one of the strongest white-box adversarial attacks , i.e . projected gradient descent ( PGD ) ( Madry et al. , 2017 ) , and without any explicit defence . Interestingly , the SoftHebb model also exhibits inherent properties of deflection ( Qin et al. , 2020 ) of the adversarial attacks , and generates object interpolations . 2 THEORY . A supporting diagram summarising the theoretical and neural model , and a succinct description of the learning algorithm are provided in the beginning of Appendix A . Definition 2.1 ( The input assumptions ) . Each observation jx ∈ Rn is generated by a hidden `` cause '' jC from a finite set of K possible such causes : jC ∈ { Ck , ∀k ≤ K ∈ N } . Therefore , the data is generated by a mixture of the probability distributions attributed to each of the K classes Ck : p ( x ) = K∑ k=1 p ( x|Ck ) P ( Ck ) . ( 1 ) In addition , the dimensions of x , xi are conditionally independent from each other , i.e . p ( x ) = ∏n i=1 p ( xi ) . The number K of the true causes or classes of the data is assumed to be known . The term `` cause '' is used here in the sense of causal inference . It is important to emphasize that the true cause of each input is hidden , i.e . not known . In the case of a labelled dataset , labels may correspond to causes , and the labels are deleted before presenting the training data to the model . We choose a mixture model that corresponds to the data assumptions but is also interpretable in neural terms ( Paragraph 2.4 ) : Definition 2.2 ( The generative probabilistic mixture model ) . We consider a mixture model distribution q : q ( x ) = ∑K k=1 q ( x|Ck ) Q ( Ck ) , approximating the data distribution p. We choose specifically a mixture of exponentials and we parametrize Q ( Ck ; w0k ) also as an exponential , specifically : q ( xi|Ck ; wik ) = ewik· xi ||x|| , ∀k ( 2 ) Q ( Ck ; w0k ) = e w0k , ∀k . ( 3 ) In addition , the parameter vectors are subject to the normalization constraints : ||wk|| = 1 , ∀k , and∑K k=1 e w0k = 1 . The model we have chosen is a reasonable choice because it factorizes similarly to the data of Definition 2.1 : qk : = q ( x|Ck ; wk ) = n∏ i=1 q ( xi|Ck ; wik ) = e ∑n i=1 wik xi ||x|| = euk , ( 4 ) where uk = wk·x||wk||·||x|| , i.e . the cosine similarity of the two vectors . A similar probabilistic model was used in related previous theoretical work Nessler et al . ( 2009 ; 2013 ) ; Moraitis et al . ( 2020 ) , but for different data assumptions , and with certain further constraints to the model . Namely , ( Nessler et al. , 2009 ; 2013 ) considered data that was binary , and created by a population code , while the model was stochastic . These works provide the foundation of our derivation , but here we consider the more generic scenario where data are continuous-valued and input directly into the model , which is deterministic and , as we will show , more compatible with standard ANNs . In Moraitis et al . ( 2020 ) , data had particular short-term temporal dependencies , whereas here we consider the distinct case of independent and identically distributed ( i.i.d . ) input samples . The Bayes-optimal parameters of a model mixture of exponentials can be found analytically as functions of the input distribution ’ s parameters , and the model is equivalent to a soft winner-take-all neural network ( Moraitis et al. , 2020 ) . After describing this , we will prove here that Hebbian plasticity of synapses combined with local plasticity of the neuronal biases sets the parameters to their optimal values . Theorem 2.3 ( The optimal parameters of the model ) . The parameters that minimize the KL divergence of such a mixture model from the data are , for every k , optw0k = lnP ( Ck ) ( 5 ) and optw ∗ k = optwk || optwk|| = µpk ( x ) ||µpk ( x ) || , ( 6 ) where optwk = c · µpk ( x ) , c ∈ R+ , µpk ( x ) is the mean of the distribution pk , and pk : = p ( x|Ck ) . In other words , the optimal parameter vector of each component k in this mixture is proportional to the mean of the corresponding component of the input distribution , i.e . it is a centroid of the component . In addition , the optimal parameter of the model ’ s prior Q ( Ck ) is the logarithm of the corresponding component ’ s prior probability . This Theorem ’ s proof was provided in the supplementary material of Moraitis et al . ( 2020 ) , but for completeness we also provide it in our Appendix . These centroids and priors of the input ’ s component distributions , as well as the method of their estimation , however , are different for different input assumptions , and we will derive a learning rule that provably sets the parameters to their Maximum Likelihood Estimate for the inputs addressed here . The learning rule is a Hebbian type of synaptic plasticity combined with a plasticity for neuronal biases . Before providing the rule and the related proof , we will describe how our mixture model is equivalent to a WTA neural network . | The work presents an interesting equivalency between a generative probabilistic mixture model and a winner-take-all Hebbian local learning rule-based learning. The approach seems promising, especially the adversarial robustness results compared to a multi-layer perceptron. **UPDATED SCORE** I would like to thank the authors for their revisions and modification based on my feedback. I am changing my score from 5 --> 6 to reflect that. I would also like to mention that there have been works based on Hebbian/Non-Hebbian Learning that outperform backdrop-based approaches in challenging scenarios such as continual supervised/reinforcement learning. There are other strategies for backprop networks such as implicit formulation (treating NN as a dynamical system) that improves adversarial robustness without adversarial training. Moreover, from a practical usability standpoint, even though SoftHebb is faster, the accuracy still trails the backprop-based networks. | SP:d14997b630179be24d198dea421b4a91d8e1e8e6 |
SoftHebb: Bayesian inference in unsupervised Hebbian soft winner-take-all networks | 1 INTRODUCTION . State-of-the-art ( SOTA ) artificial neural networks ( ANNs ) achieve impressive results in a variety of machine intelligence tasks ( Sejnowski , 2020 ) . However , they largely rely on mechanisms that diverge from the original inspiration from biological neural networks ( Bengio et al. , 2015 ; Illing et al. , 2019 ) . As a result , only a small part of this prolific field also contributes to computational neuroscience . In fact , this biological implausibility is also an important issue for machine intelligence . For their impressive performance , ANNs trade off other desired properties , which are present in biological systems . For example , ANN training often demands very large and labelled datasets . When labels are unavailable , self-supervised learning schemes exist , where supervisory error signals generated by the network itself are exploited and backpropagated from the output towards the input to update the network ’ s parameters ( Goodfellow et al. , 2014 ; Devlin et al. , 2018 ; Chen et al. , 2020 ) . However , this global propagation of signals in deep networks introduces another limitation . Namely , it prevents the implementation of efficient distributed computing hardware that would be based on only local signals from neighbouring physical nodes in the network , and is in contrast to local synaptic plasticity rules that partly govern biological learning . Several pieces of work have been addressing parts of the biological implausibility and hardware-inefficiency of backpropagation in ANNs ( Bengio et al. , 2015 ; Lillicrap et al. , 2016 ; Guerguiev et al. , 2017 ; Pfeiffer & Pfeil , 2018 ; Illing et al. , 2019 ; Pogodin & Latham , 2020 ; Millidge et al. , 2020 ; Pogodin et al. , 2021 ) . such as the need for exactly symmetric forward and backward weights or the waiting time caused by the network ’ s forward-backward pass between two training updates in a layer ( weight transport and update-locking problems ) . Recently , an approximation to backpropagation that is mostly Hebbian , i.e . relies on mostly pre- and post- synaptic activity of each synapse , has been achieved by reducing the global error requirements to 1-bit information ( Pogodin & Latham , 2020 ) . Two schemes that further localize the signal that is required for a weight update are Equilibrium Propagation ( Scellier & Bengio , 2017 ) and Predictive Coding ( Millidge et al. , 2020 ) . Both methods approximate backpropagation through Hebbian-like learning , by delegating the global aspect of the computation , from a global error signal , to a global convergence of the network state to an equilibrium . This equilibrium is reached through several iterative steps of feed-forward and feed-back communication throughout the network , before the ultimate weight update by one training example . The biological plausibility and hardware-efficiency of this added iterative process of signal propagation are open questions that begin to be addressed ( Ernoult et al. , 2020 ) . Moreover , learning through backpropagation , and presumably also its approximations , has another indication of biological implausibility , which also significantly limits ANN applicability . Namely , it produces networks that are confused by small adversarial perturbations of the input , which are imperceptible by humans . It has recently been proposed that a defence strategy of `` deflection '' of adversarial attacks may be the ultimate solution to that problem ( Qin et al. , 2020 ) . Through this strategy , to cause confusion in the network ’ s inferred class , the adversary is forced to generate such a changed input that really belongs to the distribution of a different input class . Intuitively , but also strictly by definition , this deflection is achieved if a human assigns to the perturbed input the same label that the network does . Deflection of adversarial attacks in ANNs has been demonstrated by an elaborate scheme that is based on detecting the attacks ( Qin et al. , 2020 ) . However , the human ability to deflect adversarial perturbations likely does not rely on detecting them , but rather on effectively ignoring them , making the deflecting type of robustness an emergent property of biological computation rather than a defence mechanism . The biological principles that underlie this property of robustness are unclear , but it might emerge from the distinct algorithms that govern learning in the brain . Therefore , what is missing is a biologically plausible model that can learn from fewer data-points , without labels , through local plasticity , and without feedback from distant layers . This model could then be tested for emergent adversarial robustness . A good candidate category of biological networks and learning algorithms is that of competitive learning . Neurons that compete for their activation through lateral inhibition are a common connectivity pattern in the superficial layers of the cerebral cortex ( Douglas & Martin , 2004 ; Binzegger et al. , 2004 ) . This pattern is described as winner-take-all ( WTA ) , because competition suppresses activity of weakly activated neurons , and emphasizes strong ones . Combined with Hebbian-like plasticity rules , WTA connectivity gives rise to competitivelearning algorithms . These networks and learning schemes have been long studied ( Von der Malsburg , 1973 ) and a large literature based on simulations and analyses describes their functional properties . A WTA neuronal layer , depending on its specifics , can restore missing input signals ( Rutishauser et al. , 2011 ; Diehl & Cook , 2016 ) , perform decision making i.e . winner selection ( Hahnloser et al. , 1999 ; Maass , 2000 ; Rutishauser et al. , 2011 ) , and generate oscillations such as those that underlie brain rhythms ( Cannon et al. , 2014 ) . Perhaps more importantly , its neurons can learn to become selective to different input patterns , such as orientation of visual bars in models of the primary visual cortex ( Von der Malsburg , 1973 ) , MNIST handwritten digits ( Nessler et al. , 2013 ; Diehl & Cook , 2015 ; Krotov & Hopfield , 2019 ) , CIFAR10 objects ( Krotov & Hopfield , 2019 ) , spatiotemporal spiking patterns ( Nessler et al. , 2013 ) , and can adapt dynamically to model changing objects ( Moraitis et al. , 2020 ) . The WTA model is indeed biologically plausible , Hebbian plasticity is local , and learning is input-driven , relying on only feed-forward communication of neurons – properties that seem to address several of the limitations of ANNs . However , the model ’ s applicability is limited to simple tasks . That is partly because the related theoretical literature remains surprisingly unsettled , despite its long history , and the strong and productive community interest ( Sanger , 1989 ; Földiák & Fdilr , 1989 ; Földiak , 1990 ; Linsker , 1992 ; Olshausen & Field , 1996 ; Bell & Sejnowski , 1995 ; Olshausen & Field , 1997 ; Lee et al. , 1999 ; Nessler et al. , 2013 ; Pehlevan & Chklovskii , 2014 ; Hu et al. , 2014 ; Pehlevan & Chklovskii , 2015 ; Pehlevan et al. , 2017 ; Isomura & Toyoizumi , 2018 ) . Nessler et al . ( 2009 ; 2013 ) described a very related theory but for a model that is largely incompatible with ANNs and thus less practical . It uses spiking and stochastic neurons , input has to be discretized , and each input feature must be encoded through multiple binary neurons . Moreover , it was only proven for neurons with an exponential activation function . It remains therefore unclear which specific plasticity rule and structure could optimize an ANN WTA for Bayesian inference . It is also unclear how to minimize a common loss function such as cross-entropy despite unsupervised learning , and how a WTA could represent varying families of probability distributions . In summary , on the theoretical side , an algorithm that is simultaneously normative , based on WTA networks and Hebbian unsupervised plasticity , performs Bayesian inference , and , importantly , is composed of conventional , i.e . non-spiking , ANN elements and is rigorously linked to modern ANN tools such as cross-entropy loss , would be an important advance but has been missing . On the practical side , evidence that Hebbian WTA networks could be useful for presently pertinent issues of modern ANNs such as adversarial robustness , generation of synthetic images , or faster learning , has remained limited . Here we aim to fill these gaps . Recently , when WTA networks were studied in a theoretical framework compatible with conventional machine learning ( ML ) , but in the context of short-term as opposed to long-term Hebbian plasticity , it resulted in surprising practical advantages over supervised ANNs ( Moraitis et al. , 2020 ) . A similar theoretical approach could also reveal unknown advantages of long-term Hebbian plasticity in WTA networks . In addition , it could provide insights into how a WTA microcircuit could participate in larger-scale computation by deeper cortical or artificial networks . Here we construct `` SoftHebb '' , a biologically plausible WTA model that is based on standard ratebased neurons as in ANNs , can accommodate various activation functions , and learns without labels , using local plasticity and only feed-forward communication , i.e . the properties we seek in an ANN . Importantly , it is equipped with a simple normalization of the layer ’ s activations , and an optional temperature-scaling mechanism ( Hinton et al. , 2015 ) , producing a soft WTA instead of selecting a single `` hard '' winner neuron . This allows us to prove formally that a SoftHebb layer is a generative mixture model that objectively minimizes its Kullback-Leibler ( KL ) divergence from the input distribution through Bayesian inference , thus providing a new formal ML-theoretic perspective of these networks . We complement our main results , which are theoretical , with experiments that are small-scale but produce intriguing results . As a generative model , SoftHebb has a broader scope than classification , but we test it on image classification tasks . Surprisingly , in addition to overcoming several inefficiencies of backpropagation , the unsupervised WTA model also outperforms a supervised two-layer perceptron in several aspects : learning speed and accuracy in the first presentation of the training dataset , robustness to noisy data and to one of the strongest white-box adversarial attacks , i.e . projected gradient descent ( PGD ) ( Madry et al. , 2017 ) , and without any explicit defence . Interestingly , the SoftHebb model also exhibits inherent properties of deflection ( Qin et al. , 2020 ) of the adversarial attacks , and generates object interpolations . 2 THEORY . A supporting diagram summarising the theoretical and neural model , and a succinct description of the learning algorithm are provided in the beginning of Appendix A . Definition 2.1 ( The input assumptions ) . Each observation jx ∈ Rn is generated by a hidden `` cause '' jC from a finite set of K possible such causes : jC ∈ { Ck , ∀k ≤ K ∈ N } . Therefore , the data is generated by a mixture of the probability distributions attributed to each of the K classes Ck : p ( x ) = K∑ k=1 p ( x|Ck ) P ( Ck ) . ( 1 ) In addition , the dimensions of x , xi are conditionally independent from each other , i.e . p ( x ) = ∏n i=1 p ( xi ) . The number K of the true causes or classes of the data is assumed to be known . The term `` cause '' is used here in the sense of causal inference . It is important to emphasize that the true cause of each input is hidden , i.e . not known . In the case of a labelled dataset , labels may correspond to causes , and the labels are deleted before presenting the training data to the model . We choose a mixture model that corresponds to the data assumptions but is also interpretable in neural terms ( Paragraph 2.4 ) : Definition 2.2 ( The generative probabilistic mixture model ) . We consider a mixture model distribution q : q ( x ) = ∑K k=1 q ( x|Ck ) Q ( Ck ) , approximating the data distribution p. We choose specifically a mixture of exponentials and we parametrize Q ( Ck ; w0k ) also as an exponential , specifically : q ( xi|Ck ; wik ) = ewik· xi ||x|| , ∀k ( 2 ) Q ( Ck ; w0k ) = e w0k , ∀k . ( 3 ) In addition , the parameter vectors are subject to the normalization constraints : ||wk|| = 1 , ∀k , and∑K k=1 e w0k = 1 . The model we have chosen is a reasonable choice because it factorizes similarly to the data of Definition 2.1 : qk : = q ( x|Ck ; wk ) = n∏ i=1 q ( xi|Ck ; wik ) = e ∑n i=1 wik xi ||x|| = euk , ( 4 ) where uk = wk·x||wk||·||x|| , i.e . the cosine similarity of the two vectors . A similar probabilistic model was used in related previous theoretical work Nessler et al . ( 2009 ; 2013 ) ; Moraitis et al . ( 2020 ) , but for different data assumptions , and with certain further constraints to the model . Namely , ( Nessler et al. , 2009 ; 2013 ) considered data that was binary , and created by a population code , while the model was stochastic . These works provide the foundation of our derivation , but here we consider the more generic scenario where data are continuous-valued and input directly into the model , which is deterministic and , as we will show , more compatible with standard ANNs . In Moraitis et al . ( 2020 ) , data had particular short-term temporal dependencies , whereas here we consider the distinct case of independent and identically distributed ( i.i.d . ) input samples . The Bayes-optimal parameters of a model mixture of exponentials can be found analytically as functions of the input distribution ’ s parameters , and the model is equivalent to a soft winner-take-all neural network ( Moraitis et al. , 2020 ) . After describing this , we will prove here that Hebbian plasticity of synapses combined with local plasticity of the neuronal biases sets the parameters to their optimal values . Theorem 2.3 ( The optimal parameters of the model ) . The parameters that minimize the KL divergence of such a mixture model from the data are , for every k , optw0k = lnP ( Ck ) ( 5 ) and optw ∗ k = optwk || optwk|| = µpk ( x ) ||µpk ( x ) || , ( 6 ) where optwk = c · µpk ( x ) , c ∈ R+ , µpk ( x ) is the mean of the distribution pk , and pk : = p ( x|Ck ) . In other words , the optimal parameter vector of each component k in this mixture is proportional to the mean of the corresponding component of the input distribution , i.e . it is a centroid of the component . In addition , the optimal parameter of the model ’ s prior Q ( Ck ) is the logarithm of the corresponding component ’ s prior probability . This Theorem ’ s proof was provided in the supplementary material of Moraitis et al . ( 2020 ) , but for completeness we also provide it in our Appendix . These centroids and priors of the input ’ s component distributions , as well as the method of their estimation , however , are different for different input assumptions , and we will derive a learning rule that provably sets the parameters to their Maximum Likelihood Estimate for the inputs addressed here . The learning rule is a Hebbian type of synaptic plasticity combined with a plasticity for neuronal biases . Before providing the rule and the related proof , we will describe how our mixture model is equivalent to a WTA neural network . | In this paper, the authors develop a theoretical framework to incorporate winner-takes-all (WTA) connectivity with Hebbian-like plasticity which translates into a Bayesian generative model that can be used with generic artificial neural network (ANN) elements. This implementation, which they call SoftHebb, marginally outperforms a competing WTA alternative in digit classification on the MNIST. Furthermore, it also trains marginally faster than a standard backprop multilayer perceptron (MLP), though its performance saturates at a lower accuracy. Finally, the model appears to be substantially more robust than the standard MLP for both black-box and white-box attacks. | SP:d14997b630179be24d198dea421b4a91d8e1e8e6 |
SoftHebb: Bayesian inference in unsupervised Hebbian soft winner-take-all networks | 1 INTRODUCTION . State-of-the-art ( SOTA ) artificial neural networks ( ANNs ) achieve impressive results in a variety of machine intelligence tasks ( Sejnowski , 2020 ) . However , they largely rely on mechanisms that diverge from the original inspiration from biological neural networks ( Bengio et al. , 2015 ; Illing et al. , 2019 ) . As a result , only a small part of this prolific field also contributes to computational neuroscience . In fact , this biological implausibility is also an important issue for machine intelligence . For their impressive performance , ANNs trade off other desired properties , which are present in biological systems . For example , ANN training often demands very large and labelled datasets . When labels are unavailable , self-supervised learning schemes exist , where supervisory error signals generated by the network itself are exploited and backpropagated from the output towards the input to update the network ’ s parameters ( Goodfellow et al. , 2014 ; Devlin et al. , 2018 ; Chen et al. , 2020 ) . However , this global propagation of signals in deep networks introduces another limitation . Namely , it prevents the implementation of efficient distributed computing hardware that would be based on only local signals from neighbouring physical nodes in the network , and is in contrast to local synaptic plasticity rules that partly govern biological learning . Several pieces of work have been addressing parts of the biological implausibility and hardware-inefficiency of backpropagation in ANNs ( Bengio et al. , 2015 ; Lillicrap et al. , 2016 ; Guerguiev et al. , 2017 ; Pfeiffer & Pfeil , 2018 ; Illing et al. , 2019 ; Pogodin & Latham , 2020 ; Millidge et al. , 2020 ; Pogodin et al. , 2021 ) . such as the need for exactly symmetric forward and backward weights or the waiting time caused by the network ’ s forward-backward pass between two training updates in a layer ( weight transport and update-locking problems ) . Recently , an approximation to backpropagation that is mostly Hebbian , i.e . relies on mostly pre- and post- synaptic activity of each synapse , has been achieved by reducing the global error requirements to 1-bit information ( Pogodin & Latham , 2020 ) . Two schemes that further localize the signal that is required for a weight update are Equilibrium Propagation ( Scellier & Bengio , 2017 ) and Predictive Coding ( Millidge et al. , 2020 ) . Both methods approximate backpropagation through Hebbian-like learning , by delegating the global aspect of the computation , from a global error signal , to a global convergence of the network state to an equilibrium . This equilibrium is reached through several iterative steps of feed-forward and feed-back communication throughout the network , before the ultimate weight update by one training example . The biological plausibility and hardware-efficiency of this added iterative process of signal propagation are open questions that begin to be addressed ( Ernoult et al. , 2020 ) . Moreover , learning through backpropagation , and presumably also its approximations , has another indication of biological implausibility , which also significantly limits ANN applicability . Namely , it produces networks that are confused by small adversarial perturbations of the input , which are imperceptible by humans . It has recently been proposed that a defence strategy of `` deflection '' of adversarial attacks may be the ultimate solution to that problem ( Qin et al. , 2020 ) . Through this strategy , to cause confusion in the network ’ s inferred class , the adversary is forced to generate such a changed input that really belongs to the distribution of a different input class . Intuitively , but also strictly by definition , this deflection is achieved if a human assigns to the perturbed input the same label that the network does . Deflection of adversarial attacks in ANNs has been demonstrated by an elaborate scheme that is based on detecting the attacks ( Qin et al. , 2020 ) . However , the human ability to deflect adversarial perturbations likely does not rely on detecting them , but rather on effectively ignoring them , making the deflecting type of robustness an emergent property of biological computation rather than a defence mechanism . The biological principles that underlie this property of robustness are unclear , but it might emerge from the distinct algorithms that govern learning in the brain . Therefore , what is missing is a biologically plausible model that can learn from fewer data-points , without labels , through local plasticity , and without feedback from distant layers . This model could then be tested for emergent adversarial robustness . A good candidate category of biological networks and learning algorithms is that of competitive learning . Neurons that compete for their activation through lateral inhibition are a common connectivity pattern in the superficial layers of the cerebral cortex ( Douglas & Martin , 2004 ; Binzegger et al. , 2004 ) . This pattern is described as winner-take-all ( WTA ) , because competition suppresses activity of weakly activated neurons , and emphasizes strong ones . Combined with Hebbian-like plasticity rules , WTA connectivity gives rise to competitivelearning algorithms . These networks and learning schemes have been long studied ( Von der Malsburg , 1973 ) and a large literature based on simulations and analyses describes their functional properties . A WTA neuronal layer , depending on its specifics , can restore missing input signals ( Rutishauser et al. , 2011 ; Diehl & Cook , 2016 ) , perform decision making i.e . winner selection ( Hahnloser et al. , 1999 ; Maass , 2000 ; Rutishauser et al. , 2011 ) , and generate oscillations such as those that underlie brain rhythms ( Cannon et al. , 2014 ) . Perhaps more importantly , its neurons can learn to become selective to different input patterns , such as orientation of visual bars in models of the primary visual cortex ( Von der Malsburg , 1973 ) , MNIST handwritten digits ( Nessler et al. , 2013 ; Diehl & Cook , 2015 ; Krotov & Hopfield , 2019 ) , CIFAR10 objects ( Krotov & Hopfield , 2019 ) , spatiotemporal spiking patterns ( Nessler et al. , 2013 ) , and can adapt dynamically to model changing objects ( Moraitis et al. , 2020 ) . The WTA model is indeed biologically plausible , Hebbian plasticity is local , and learning is input-driven , relying on only feed-forward communication of neurons – properties that seem to address several of the limitations of ANNs . However , the model ’ s applicability is limited to simple tasks . That is partly because the related theoretical literature remains surprisingly unsettled , despite its long history , and the strong and productive community interest ( Sanger , 1989 ; Földiák & Fdilr , 1989 ; Földiak , 1990 ; Linsker , 1992 ; Olshausen & Field , 1996 ; Bell & Sejnowski , 1995 ; Olshausen & Field , 1997 ; Lee et al. , 1999 ; Nessler et al. , 2013 ; Pehlevan & Chklovskii , 2014 ; Hu et al. , 2014 ; Pehlevan & Chklovskii , 2015 ; Pehlevan et al. , 2017 ; Isomura & Toyoizumi , 2018 ) . Nessler et al . ( 2009 ; 2013 ) described a very related theory but for a model that is largely incompatible with ANNs and thus less practical . It uses spiking and stochastic neurons , input has to be discretized , and each input feature must be encoded through multiple binary neurons . Moreover , it was only proven for neurons with an exponential activation function . It remains therefore unclear which specific plasticity rule and structure could optimize an ANN WTA for Bayesian inference . It is also unclear how to minimize a common loss function such as cross-entropy despite unsupervised learning , and how a WTA could represent varying families of probability distributions . In summary , on the theoretical side , an algorithm that is simultaneously normative , based on WTA networks and Hebbian unsupervised plasticity , performs Bayesian inference , and , importantly , is composed of conventional , i.e . non-spiking , ANN elements and is rigorously linked to modern ANN tools such as cross-entropy loss , would be an important advance but has been missing . On the practical side , evidence that Hebbian WTA networks could be useful for presently pertinent issues of modern ANNs such as adversarial robustness , generation of synthetic images , or faster learning , has remained limited . Here we aim to fill these gaps . Recently , when WTA networks were studied in a theoretical framework compatible with conventional machine learning ( ML ) , but in the context of short-term as opposed to long-term Hebbian plasticity , it resulted in surprising practical advantages over supervised ANNs ( Moraitis et al. , 2020 ) . A similar theoretical approach could also reveal unknown advantages of long-term Hebbian plasticity in WTA networks . In addition , it could provide insights into how a WTA microcircuit could participate in larger-scale computation by deeper cortical or artificial networks . Here we construct `` SoftHebb '' , a biologically plausible WTA model that is based on standard ratebased neurons as in ANNs , can accommodate various activation functions , and learns without labels , using local plasticity and only feed-forward communication , i.e . the properties we seek in an ANN . Importantly , it is equipped with a simple normalization of the layer ’ s activations , and an optional temperature-scaling mechanism ( Hinton et al. , 2015 ) , producing a soft WTA instead of selecting a single `` hard '' winner neuron . This allows us to prove formally that a SoftHebb layer is a generative mixture model that objectively minimizes its Kullback-Leibler ( KL ) divergence from the input distribution through Bayesian inference , thus providing a new formal ML-theoretic perspective of these networks . We complement our main results , which are theoretical , with experiments that are small-scale but produce intriguing results . As a generative model , SoftHebb has a broader scope than classification , but we test it on image classification tasks . Surprisingly , in addition to overcoming several inefficiencies of backpropagation , the unsupervised WTA model also outperforms a supervised two-layer perceptron in several aspects : learning speed and accuracy in the first presentation of the training dataset , robustness to noisy data and to one of the strongest white-box adversarial attacks , i.e . projected gradient descent ( PGD ) ( Madry et al. , 2017 ) , and without any explicit defence . Interestingly , the SoftHebb model also exhibits inherent properties of deflection ( Qin et al. , 2020 ) of the adversarial attacks , and generates object interpolations . 2 THEORY . A supporting diagram summarising the theoretical and neural model , and a succinct description of the learning algorithm are provided in the beginning of Appendix A . Definition 2.1 ( The input assumptions ) . Each observation jx ∈ Rn is generated by a hidden `` cause '' jC from a finite set of K possible such causes : jC ∈ { Ck , ∀k ≤ K ∈ N } . Therefore , the data is generated by a mixture of the probability distributions attributed to each of the K classes Ck : p ( x ) = K∑ k=1 p ( x|Ck ) P ( Ck ) . ( 1 ) In addition , the dimensions of x , xi are conditionally independent from each other , i.e . p ( x ) = ∏n i=1 p ( xi ) . The number K of the true causes or classes of the data is assumed to be known . The term `` cause '' is used here in the sense of causal inference . It is important to emphasize that the true cause of each input is hidden , i.e . not known . In the case of a labelled dataset , labels may correspond to causes , and the labels are deleted before presenting the training data to the model . We choose a mixture model that corresponds to the data assumptions but is also interpretable in neural terms ( Paragraph 2.4 ) : Definition 2.2 ( The generative probabilistic mixture model ) . We consider a mixture model distribution q : q ( x ) = ∑K k=1 q ( x|Ck ) Q ( Ck ) , approximating the data distribution p. We choose specifically a mixture of exponentials and we parametrize Q ( Ck ; w0k ) also as an exponential , specifically : q ( xi|Ck ; wik ) = ewik· xi ||x|| , ∀k ( 2 ) Q ( Ck ; w0k ) = e w0k , ∀k . ( 3 ) In addition , the parameter vectors are subject to the normalization constraints : ||wk|| = 1 , ∀k , and∑K k=1 e w0k = 1 . The model we have chosen is a reasonable choice because it factorizes similarly to the data of Definition 2.1 : qk : = q ( x|Ck ; wk ) = n∏ i=1 q ( xi|Ck ; wik ) = e ∑n i=1 wik xi ||x|| = euk , ( 4 ) where uk = wk·x||wk||·||x|| , i.e . the cosine similarity of the two vectors . A similar probabilistic model was used in related previous theoretical work Nessler et al . ( 2009 ; 2013 ) ; Moraitis et al . ( 2020 ) , but for different data assumptions , and with certain further constraints to the model . Namely , ( Nessler et al. , 2009 ; 2013 ) considered data that was binary , and created by a population code , while the model was stochastic . These works provide the foundation of our derivation , but here we consider the more generic scenario where data are continuous-valued and input directly into the model , which is deterministic and , as we will show , more compatible with standard ANNs . In Moraitis et al . ( 2020 ) , data had particular short-term temporal dependencies , whereas here we consider the distinct case of independent and identically distributed ( i.i.d . ) input samples . The Bayes-optimal parameters of a model mixture of exponentials can be found analytically as functions of the input distribution ’ s parameters , and the model is equivalent to a soft winner-take-all neural network ( Moraitis et al. , 2020 ) . After describing this , we will prove here that Hebbian plasticity of synapses combined with local plasticity of the neuronal biases sets the parameters to their optimal values . Theorem 2.3 ( The optimal parameters of the model ) . The parameters that minimize the KL divergence of such a mixture model from the data are , for every k , optw0k = lnP ( Ck ) ( 5 ) and optw ∗ k = optwk || optwk|| = µpk ( x ) ||µpk ( x ) || , ( 6 ) where optwk = c · µpk ( x ) , c ∈ R+ , µpk ( x ) is the mean of the distribution pk , and pk : = p ( x|Ck ) . In other words , the optimal parameter vector of each component k in this mixture is proportional to the mean of the corresponding component of the input distribution , i.e . it is a centroid of the component . In addition , the optimal parameter of the model ’ s prior Q ( Ck ) is the logarithm of the corresponding component ’ s prior probability . This Theorem ’ s proof was provided in the supplementary material of Moraitis et al . ( 2020 ) , but for completeness we also provide it in our Appendix . These centroids and priors of the input ’ s component distributions , as well as the method of their estimation , however , are different for different input assumptions , and we will derive a learning rule that provably sets the parameters to their Maximum Likelihood Estimate for the inputs addressed here . The learning rule is a Hebbian type of synaptic plasticity combined with a plasticity for neuronal biases . Before providing the rule and the related proof , we will describe how our mixture model is equivalent to a WTA neural network . | The paper wants to provide an optimization theory for WTA networks that it claims to be missing. More precisely they consider soft WTA networks that are implemented as ANNs.They apply their model to MNIST and Fashion-MNIST. In addition some robustness to adversarial attacks is demonstrated. | SP:d14997b630179be24d198dea421b4a91d8e1e8e6 |
SAU: Smooth activation function using convolution with approximate identities | Well-known activation functions like ReLU or Leaky ReLU are non-differentiable at the origin . Over the years , many smooth approximations of ReLU have been proposed using various smoothing techniques . We propose new smooth approximations of a non-differentiable activation function by convolving it with approximate identities . In particular , we present smooth approximations of Leaky ReLU and show that they outperform several well-known activation functions in various datasets and models . We call this function Smooth Activation Unit ( SAU ) . Replacing ReLU by SAU , we get 5.12 % improvement with ShuffleNet V2 ( 2.0x ) model on the CIFAR100 dataset . 1 INTRODUCTION . Deep networks form a crucial component of modern deep learning . Non-linearity is introduced in such networks by the use of activation functions , and the choice has a substantial impact on network performance and training dynamics . Designing a new novel activation function is a difficult task . Handcrafted activations like Rectified Linear Unit ( ReLU ) ( Nair & Hinton ( 2010 ) ) , Leaky ReLU ( Maas et al . ( 2013 ) ) or its variants are very common choices for activation functions and exhibits promising performance on different deep learning tasks . There are many activations that have been proposed so far and some of them are ELU ( Clevert et al . ( 2016 ) ) , Parametric ReLU ( PReLU ) ( He et al . ( 2015a ) ) , Swish ( Ramachandran et al . ( 2017 ) ) , Tanhsoft ( Biswas et al . ( 2021d ) ) , EIS ( Biswas et al . ( 2021b ) ) , Padé Activation Unit ( PAU ) ( Molina et al . ( 2020 ) ) , Orthogonal Padé Activation Unit ( OPAU ) ( Biswas et al . ( 2021a ) ) , ACON ( Ma et al . ( 2021 ) ) , ErfAct ( Biswas et al . ( 2021c ) ) , Mish ( Misra ( 2020 ) ) , GELU ( Hendrycks & Gimpel ( 2020 ) ) , ReLU6 ( Krizhevsky ( 2010 ) ) , Softplus ( Zheng et al . ( 2015 ) ) etc . Nevertheless , ReLU remains the favourite choice among the deep learning community due to its simplicity and better performance when compared to Tanh or Sigmoid , though it has a drawback known as dying ReLU in which the network starts to lose the gradient direction due to the negative inputs and produces zero outcome . In 2017 , Swish ( Ramachandran et al . ( 2017 ) ) was proposed by the Google brain team . Swish was found by automatic search technique , and it has shown some promising performance across different deep learning tasks . Activation functions are usually handcrafted . PReLU ( He et al . ( 2015a ) ) tries to overcome this problem by introducing a learnable negative component to ReLU ( Nair & Hinton ( 2010 ) ) . Maxout ( Goodfellow et al . ( 2013 ) ) and Mixout ( Hui-zhen Zhao ( 2017 ) ) are constructed with piecewise linear components , and theoretically , they are universal function approximators , though they increase the number of parameters in the network . Recently , meta-ACON ( Ma et al . ( 2021 ) ) , a smooth activation , have been proposed , which is the generalization of the ReLU and Maxout activations and can smoothly approximate Swish . Meta-ACON has shown some good improvement on both small models and highly optimized large models . PAU ( Molina et al . ( 2020 ) ) and OPAU ( Biswas et al . ( 2021a ) ) are two promising candidates for trainable activations , which have been introduced recently based on rational function approximation . In this paper , we introduce a smooth approximation of known non-smooth activation functions like ReLU or Leaky ReLU based on the approximation of identity . Our experiments show that the proposed activations improve the performance of different network architectures as compared to ReLU on different deep learning problems . 2 MATHEMATICAL FORMALISM . 2.1 CONVOLUTION . Convolution is a binary operation , which takes two functions f and g as input , and outputs a new function denoted by f ∗ g. Mathematically , we define this operation as follows ( f ∗ g ) ( x ) = ∫ ∞ −∞ f ( y ) g ( x− y ) dy . ( 1 ) The convolution operation has several properties . Below , we will list two of them which will be used larter in this article . P1 . ( f ∗ g ) ( x ) = ( g ∗ f ) ( x ) , P2 . If f is n-times differentiable with compact support over R and g is locally integrable over R then f ∗ g is at least n-times differentiable over R. Property P1 is an easy consequence of definition equation 1 . Property P2 can be easily obtained by moving the derivative operator inside the integral . Note that this exchange of derivative and integral requires f to be of compact support . An immediate consequence of property P2 is that if one of the functions f or g is smooth with compact support , then f ∗ g is also smooth . This observation will be used later in the article to obtain smooth approximations of non-differentiable activation functions . 2.2 MOLLIFIER AND APPROXIMATE IDENTITIES . A smooth function φ over R is called a mollifier if it satisfies the following three properties : 1 . It is compactly supported . 2 . ∫ R φ ( x ) dx = 1 . 3. lim →0 φ ( x ) : = lim →0 1 φ ( x/ ) = δ ( x ) , where δ ( x ) is the Dirac delta function . We say that a mollifier φ is an approximate identity if for any locally integrable function f over R , we have lim →0 ( f ∗ φ ) ( x ) = f ( x ) pointwise for all x . 2.3 SMOOTH APPROXIMATIONS OF NON-DIFFERENTIABLE FUNCTIONS . Let φ be an approximate identity . Choosing = 1/n for n ∈ N , one can define φn ( x ) : = nφ ( nx ) . ( 2 ) Using the property of approximate identity , for any locally integrable function f over R , we have lim n→∞ ( f ∗ φn ) ( x ) = f ( x ) pointwise for all x . That is , for large enough n , f ∗ φn is a good approximation of f . Moreover , since φ is smooth , φn is smooth for each n ∈ N and therefore , using property P2 , f ∗ φn is a smooth approximation of f for large enough n. Let σ : R → R be any activation function . Then , by definition , σ is a continuous and hence , a locally integrable function . For a given approximate identity φ and n ∈ N , we define a smooth approximation of σ as σ ∗ φn , where φn is defined in equation 2 . 3 SMOOTH APPROXIMATION UNIT ( SAU ) . Consider the Gaussian function φ ( x ) = 1√ 2π e− x2 2 which is a well known approximate identity . Consider the Leaky Rectified Linear Unit ( Leaky ReLU ) activation function LeakyReLU [ α ] ( x ) = { x x ≥ 0 αx x < 0 Note that LeakyReLU [ α ] activation function is hyperparametrized by α and it is non-differentiable at the origin for all values of α except α = 1 . For α = 0 , LeakyReLU [ α ] reduces to well known activation function ReLU ( Nair & Hinton ( 2010 ) ) while for constant and trainable α , LeakyReLU [ α ] reduces to Leaky ReLU ( Maas et al . ( 2013 ) ) and Parametric ReLU ( He et al . ( 2015a ) ) respectively . For a given n ∈ N , and α 6= 1 , a smooth approximation of LeakyReLU [ α ] is given by G ( x , α , n ) = ( LeakyReLU [ α ] ∗ φn ) ( x ) = 1 2n √ 2 π e −n2x2 2 + ( 1 + α ) 2 x+ ( 1− α ) 2 x erf ( nx√ 2 ) ( 3 ) where erf is the Gaussian error function erf ( x ) = 2√ π ∫ x 0 e−t 2 dt . It is noticeable that this function is not zero centered but passes by extremely close neighbourhood of zero . To make the function zero centered , we have multiplied the first term of ( 3 ) by a linear component x . To further investigate these two functions as a possible candidates for activation function , we have conducted several experiments on MNIST ( LeCun et al . ( 2010 ) ) , CIFAR10 ( Krizhevsky ( 2009 ) ) , and CIFAR100 ( Krizhevsky ( 2009 ) ) datasets with PreActResNet-18 ( He et al . ( 2016 ) ) , VGG-16 ( with batch-normalization ) ( Ioffe & Szegedy ( 2015 ) ) ( Simonyan & Zisserman ( 2015 ) ) , and DenseNet-121 ( Huang et al . ( 2016 ) ) models , and we notice that both of them performs almost similar in every cases . So , for rest of the paper , we will only consider the approximate identity of Leaky ReLU ( α = 0.25 ) given in ( 3 ) as the activation function . We call this function Smooth Approximation Unit ( SAU ) . Approximation of Leaky ReLU ( α = 0.25 ) by SAU is given in figure 1 . It is clear from the figure 1 that SAU can approximate Leaky ReLU ( as well as ReLU or its variants ) quite well . We note that in GELU ( Hendrycks & Gimpel ( 2020 ) ) paper , a similar idea is utilized to obtain their activation functions . They use the product of xwith the cumulative distribution function of a suitable probability distribution ( see ( Hendrycks & Gimpel ( 2020 ) ) for further details ) . 3.1 LEARNING ACTIVATION PARAMETERS VIA BACK-PROPAGATION . Back-propagation algorithm ( LeCun et al . ( 1989 ) ) and gradient descent is used in neural networks to update Weights and biases . Parameters in trainable activation functions are updated using the same technique . The forward pass is implemented in both Pytorch ( Paszke et al . ( 2019 ) ) & TensorflowKeras ( Chollet et al . ( 2015 ) ) API , and automatic differentiation will update the parameters . Alternatively , CUDA ( Nickolls et al . ( 2008 ) ) based implementation ( see ( Maas et al . ( 2013 ) ) ) can be used and the gradients of equation ( 3 ) for the input x and the parameter α can be computed as follows : ∂G ∂x = −nx 2 √ 2 π e −n2x2 2 + ( 1 + α ) 2 + ( 1− α ) 2 erf ( nx√ 2 ) + n ( 1− α ) √ 2π x e− n2x2 2 ( 4 ) ∂G ∂α = x 2 ( 1− erf ( nx√ 2 ) ) . ( 5 ) where d dx erf ( x ) = 2√ π e−x 2 α and n can be either hyperparameters or trainable parameters . Now , note that the class of neural networks with SAU activation function is dense in C ( K ) , where K is a compact subset of Rn and C ( K ) is the space of all continuous functions over K. The proof follows from the following proposition ( see ( Molina et al . ( 2020 ) ) ) . Proposition 1 . ( Theorem 1.1 in Kidger and Lyons , 2020 ( Kidger & Lyons ( 2020 ) ) ) : - Let ρ : R → R be any continuous function . Let Nρn represent the class of neural networks with activation function ρ , with n neurons in the input layer , one neuron in the output layer , and one hidden layer with an arbitrary number of neurons . Let K ⊆ Rn be compact . Then Nρn is dense in C ( K ) if and only if ρ is non-polynomial . | In this paper, the authors introduce an activation function (SAU) based on smoothing of the leaky relu. More precisely, the authors use convolutions and approximate identities to achieve that goal. Furthermore, they present the smooth version as a learnable activation function, whose parameters can be optimized via back-propagation and hyper-parameter searches. The authors present the smoothing from the ground up and conclude their theoretical development with the gradients needed for back-propagation as well as a proof that guarantees the activation function allows the network to be an universal approximator. The empirical section describes the behavior of SAU on different datasets and architectures. | SP:ae61318ee80b89bf047eca072385679c4fb5d51a |
SAU: Smooth activation function using convolution with approximate identities | Well-known activation functions like ReLU or Leaky ReLU are non-differentiable at the origin . Over the years , many smooth approximations of ReLU have been proposed using various smoothing techniques . We propose new smooth approximations of a non-differentiable activation function by convolving it with approximate identities . In particular , we present smooth approximations of Leaky ReLU and show that they outperform several well-known activation functions in various datasets and models . We call this function Smooth Activation Unit ( SAU ) . Replacing ReLU by SAU , we get 5.12 % improvement with ShuffleNet V2 ( 2.0x ) model on the CIFAR100 dataset . 1 INTRODUCTION . Deep networks form a crucial component of modern deep learning . Non-linearity is introduced in such networks by the use of activation functions , and the choice has a substantial impact on network performance and training dynamics . Designing a new novel activation function is a difficult task . Handcrafted activations like Rectified Linear Unit ( ReLU ) ( Nair & Hinton ( 2010 ) ) , Leaky ReLU ( Maas et al . ( 2013 ) ) or its variants are very common choices for activation functions and exhibits promising performance on different deep learning tasks . There are many activations that have been proposed so far and some of them are ELU ( Clevert et al . ( 2016 ) ) , Parametric ReLU ( PReLU ) ( He et al . ( 2015a ) ) , Swish ( Ramachandran et al . ( 2017 ) ) , Tanhsoft ( Biswas et al . ( 2021d ) ) , EIS ( Biswas et al . ( 2021b ) ) , Padé Activation Unit ( PAU ) ( Molina et al . ( 2020 ) ) , Orthogonal Padé Activation Unit ( OPAU ) ( Biswas et al . ( 2021a ) ) , ACON ( Ma et al . ( 2021 ) ) , ErfAct ( Biswas et al . ( 2021c ) ) , Mish ( Misra ( 2020 ) ) , GELU ( Hendrycks & Gimpel ( 2020 ) ) , ReLU6 ( Krizhevsky ( 2010 ) ) , Softplus ( Zheng et al . ( 2015 ) ) etc . Nevertheless , ReLU remains the favourite choice among the deep learning community due to its simplicity and better performance when compared to Tanh or Sigmoid , though it has a drawback known as dying ReLU in which the network starts to lose the gradient direction due to the negative inputs and produces zero outcome . In 2017 , Swish ( Ramachandran et al . ( 2017 ) ) was proposed by the Google brain team . Swish was found by automatic search technique , and it has shown some promising performance across different deep learning tasks . Activation functions are usually handcrafted . PReLU ( He et al . ( 2015a ) ) tries to overcome this problem by introducing a learnable negative component to ReLU ( Nair & Hinton ( 2010 ) ) . Maxout ( Goodfellow et al . ( 2013 ) ) and Mixout ( Hui-zhen Zhao ( 2017 ) ) are constructed with piecewise linear components , and theoretically , they are universal function approximators , though they increase the number of parameters in the network . Recently , meta-ACON ( Ma et al . ( 2021 ) ) , a smooth activation , have been proposed , which is the generalization of the ReLU and Maxout activations and can smoothly approximate Swish . Meta-ACON has shown some good improvement on both small models and highly optimized large models . PAU ( Molina et al . ( 2020 ) ) and OPAU ( Biswas et al . ( 2021a ) ) are two promising candidates for trainable activations , which have been introduced recently based on rational function approximation . In this paper , we introduce a smooth approximation of known non-smooth activation functions like ReLU or Leaky ReLU based on the approximation of identity . Our experiments show that the proposed activations improve the performance of different network architectures as compared to ReLU on different deep learning problems . 2 MATHEMATICAL FORMALISM . 2.1 CONVOLUTION . Convolution is a binary operation , which takes two functions f and g as input , and outputs a new function denoted by f ∗ g. Mathematically , we define this operation as follows ( f ∗ g ) ( x ) = ∫ ∞ −∞ f ( y ) g ( x− y ) dy . ( 1 ) The convolution operation has several properties . Below , we will list two of them which will be used larter in this article . P1 . ( f ∗ g ) ( x ) = ( g ∗ f ) ( x ) , P2 . If f is n-times differentiable with compact support over R and g is locally integrable over R then f ∗ g is at least n-times differentiable over R. Property P1 is an easy consequence of definition equation 1 . Property P2 can be easily obtained by moving the derivative operator inside the integral . Note that this exchange of derivative and integral requires f to be of compact support . An immediate consequence of property P2 is that if one of the functions f or g is smooth with compact support , then f ∗ g is also smooth . This observation will be used later in the article to obtain smooth approximations of non-differentiable activation functions . 2.2 MOLLIFIER AND APPROXIMATE IDENTITIES . A smooth function φ over R is called a mollifier if it satisfies the following three properties : 1 . It is compactly supported . 2 . ∫ R φ ( x ) dx = 1 . 3. lim →0 φ ( x ) : = lim →0 1 φ ( x/ ) = δ ( x ) , where δ ( x ) is the Dirac delta function . We say that a mollifier φ is an approximate identity if for any locally integrable function f over R , we have lim →0 ( f ∗ φ ) ( x ) = f ( x ) pointwise for all x . 2.3 SMOOTH APPROXIMATIONS OF NON-DIFFERENTIABLE FUNCTIONS . Let φ be an approximate identity . Choosing = 1/n for n ∈ N , one can define φn ( x ) : = nφ ( nx ) . ( 2 ) Using the property of approximate identity , for any locally integrable function f over R , we have lim n→∞ ( f ∗ φn ) ( x ) = f ( x ) pointwise for all x . That is , for large enough n , f ∗ φn is a good approximation of f . Moreover , since φ is smooth , φn is smooth for each n ∈ N and therefore , using property P2 , f ∗ φn is a smooth approximation of f for large enough n. Let σ : R → R be any activation function . Then , by definition , σ is a continuous and hence , a locally integrable function . For a given approximate identity φ and n ∈ N , we define a smooth approximation of σ as σ ∗ φn , where φn is defined in equation 2 . 3 SMOOTH APPROXIMATION UNIT ( SAU ) . Consider the Gaussian function φ ( x ) = 1√ 2π e− x2 2 which is a well known approximate identity . Consider the Leaky Rectified Linear Unit ( Leaky ReLU ) activation function LeakyReLU [ α ] ( x ) = { x x ≥ 0 αx x < 0 Note that LeakyReLU [ α ] activation function is hyperparametrized by α and it is non-differentiable at the origin for all values of α except α = 1 . For α = 0 , LeakyReLU [ α ] reduces to well known activation function ReLU ( Nair & Hinton ( 2010 ) ) while for constant and trainable α , LeakyReLU [ α ] reduces to Leaky ReLU ( Maas et al . ( 2013 ) ) and Parametric ReLU ( He et al . ( 2015a ) ) respectively . For a given n ∈ N , and α 6= 1 , a smooth approximation of LeakyReLU [ α ] is given by G ( x , α , n ) = ( LeakyReLU [ α ] ∗ φn ) ( x ) = 1 2n √ 2 π e −n2x2 2 + ( 1 + α ) 2 x+ ( 1− α ) 2 x erf ( nx√ 2 ) ( 3 ) where erf is the Gaussian error function erf ( x ) = 2√ π ∫ x 0 e−t 2 dt . It is noticeable that this function is not zero centered but passes by extremely close neighbourhood of zero . To make the function zero centered , we have multiplied the first term of ( 3 ) by a linear component x . To further investigate these two functions as a possible candidates for activation function , we have conducted several experiments on MNIST ( LeCun et al . ( 2010 ) ) , CIFAR10 ( Krizhevsky ( 2009 ) ) , and CIFAR100 ( Krizhevsky ( 2009 ) ) datasets with PreActResNet-18 ( He et al . ( 2016 ) ) , VGG-16 ( with batch-normalization ) ( Ioffe & Szegedy ( 2015 ) ) ( Simonyan & Zisserman ( 2015 ) ) , and DenseNet-121 ( Huang et al . ( 2016 ) ) models , and we notice that both of them performs almost similar in every cases . So , for rest of the paper , we will only consider the approximate identity of Leaky ReLU ( α = 0.25 ) given in ( 3 ) as the activation function . We call this function Smooth Approximation Unit ( SAU ) . Approximation of Leaky ReLU ( α = 0.25 ) by SAU is given in figure 1 . It is clear from the figure 1 that SAU can approximate Leaky ReLU ( as well as ReLU or its variants ) quite well . We note that in GELU ( Hendrycks & Gimpel ( 2020 ) ) paper , a similar idea is utilized to obtain their activation functions . They use the product of xwith the cumulative distribution function of a suitable probability distribution ( see ( Hendrycks & Gimpel ( 2020 ) ) for further details ) . 3.1 LEARNING ACTIVATION PARAMETERS VIA BACK-PROPAGATION . Back-propagation algorithm ( LeCun et al . ( 1989 ) ) and gradient descent is used in neural networks to update Weights and biases . Parameters in trainable activation functions are updated using the same technique . The forward pass is implemented in both Pytorch ( Paszke et al . ( 2019 ) ) & TensorflowKeras ( Chollet et al . ( 2015 ) ) API , and automatic differentiation will update the parameters . Alternatively , CUDA ( Nickolls et al . ( 2008 ) ) based implementation ( see ( Maas et al . ( 2013 ) ) ) can be used and the gradients of equation ( 3 ) for the input x and the parameter α can be computed as follows : ∂G ∂x = −nx 2 √ 2 π e −n2x2 2 + ( 1 + α ) 2 + ( 1− α ) 2 erf ( nx√ 2 ) + n ( 1− α ) √ 2π x e− n2x2 2 ( 4 ) ∂G ∂α = x 2 ( 1− erf ( nx√ 2 ) ) . ( 5 ) where d dx erf ( x ) = 2√ π e−x 2 α and n can be either hyperparameters or trainable parameters . Now , note that the class of neural networks with SAU activation function is dense in C ( K ) , where K is a compact subset of Rn and C ( K ) is the space of all continuous functions over K. The proof follows from the following proposition ( see ( Molina et al . ( 2020 ) ) ) . Proposition 1 . ( Theorem 1.1 in Kidger and Lyons , 2020 ( Kidger & Lyons ( 2020 ) ) ) : - Let ρ : R → R be any continuous function . Let Nρn represent the class of neural networks with activation function ρ , with n neurons in the input layer , one neuron in the output layer , and one hidden layer with an arbitrary number of neurons . Let K ⊆ Rn be compact . Then Nρn is dense in C ( K ) if and only if ρ is non-polynomial . | The authors propose a new activation function, named SAU, which is a smoothed approximation to Leaky/PReLU. The activation is derived by convolving a given activation function with a smooth approximation to the delta function. The paper only investigates using LeakyReLU as the target activation and the standard concentrated Gaussian approximation to the delta function. The degree of approximation is controlled via a hyperparameter denoted by $n$, controlling the variance of the Gaussian. The new activation is tested in various settings and with various architectures and is shown to outperform other alternatives to the common ReLU activation function. | SP:ae61318ee80b89bf047eca072385679c4fb5d51a |
SAU: Smooth activation function using convolution with approximate identities | Well-known activation functions like ReLU or Leaky ReLU are non-differentiable at the origin . Over the years , many smooth approximations of ReLU have been proposed using various smoothing techniques . We propose new smooth approximations of a non-differentiable activation function by convolving it with approximate identities . In particular , we present smooth approximations of Leaky ReLU and show that they outperform several well-known activation functions in various datasets and models . We call this function Smooth Activation Unit ( SAU ) . Replacing ReLU by SAU , we get 5.12 % improvement with ShuffleNet V2 ( 2.0x ) model on the CIFAR100 dataset . 1 INTRODUCTION . Deep networks form a crucial component of modern deep learning . Non-linearity is introduced in such networks by the use of activation functions , and the choice has a substantial impact on network performance and training dynamics . Designing a new novel activation function is a difficult task . Handcrafted activations like Rectified Linear Unit ( ReLU ) ( Nair & Hinton ( 2010 ) ) , Leaky ReLU ( Maas et al . ( 2013 ) ) or its variants are very common choices for activation functions and exhibits promising performance on different deep learning tasks . There are many activations that have been proposed so far and some of them are ELU ( Clevert et al . ( 2016 ) ) , Parametric ReLU ( PReLU ) ( He et al . ( 2015a ) ) , Swish ( Ramachandran et al . ( 2017 ) ) , Tanhsoft ( Biswas et al . ( 2021d ) ) , EIS ( Biswas et al . ( 2021b ) ) , Padé Activation Unit ( PAU ) ( Molina et al . ( 2020 ) ) , Orthogonal Padé Activation Unit ( OPAU ) ( Biswas et al . ( 2021a ) ) , ACON ( Ma et al . ( 2021 ) ) , ErfAct ( Biswas et al . ( 2021c ) ) , Mish ( Misra ( 2020 ) ) , GELU ( Hendrycks & Gimpel ( 2020 ) ) , ReLU6 ( Krizhevsky ( 2010 ) ) , Softplus ( Zheng et al . ( 2015 ) ) etc . Nevertheless , ReLU remains the favourite choice among the deep learning community due to its simplicity and better performance when compared to Tanh or Sigmoid , though it has a drawback known as dying ReLU in which the network starts to lose the gradient direction due to the negative inputs and produces zero outcome . In 2017 , Swish ( Ramachandran et al . ( 2017 ) ) was proposed by the Google brain team . Swish was found by automatic search technique , and it has shown some promising performance across different deep learning tasks . Activation functions are usually handcrafted . PReLU ( He et al . ( 2015a ) ) tries to overcome this problem by introducing a learnable negative component to ReLU ( Nair & Hinton ( 2010 ) ) . Maxout ( Goodfellow et al . ( 2013 ) ) and Mixout ( Hui-zhen Zhao ( 2017 ) ) are constructed with piecewise linear components , and theoretically , they are universal function approximators , though they increase the number of parameters in the network . Recently , meta-ACON ( Ma et al . ( 2021 ) ) , a smooth activation , have been proposed , which is the generalization of the ReLU and Maxout activations and can smoothly approximate Swish . Meta-ACON has shown some good improvement on both small models and highly optimized large models . PAU ( Molina et al . ( 2020 ) ) and OPAU ( Biswas et al . ( 2021a ) ) are two promising candidates for trainable activations , which have been introduced recently based on rational function approximation . In this paper , we introduce a smooth approximation of known non-smooth activation functions like ReLU or Leaky ReLU based on the approximation of identity . Our experiments show that the proposed activations improve the performance of different network architectures as compared to ReLU on different deep learning problems . 2 MATHEMATICAL FORMALISM . 2.1 CONVOLUTION . Convolution is a binary operation , which takes two functions f and g as input , and outputs a new function denoted by f ∗ g. Mathematically , we define this operation as follows ( f ∗ g ) ( x ) = ∫ ∞ −∞ f ( y ) g ( x− y ) dy . ( 1 ) The convolution operation has several properties . Below , we will list two of them which will be used larter in this article . P1 . ( f ∗ g ) ( x ) = ( g ∗ f ) ( x ) , P2 . If f is n-times differentiable with compact support over R and g is locally integrable over R then f ∗ g is at least n-times differentiable over R. Property P1 is an easy consequence of definition equation 1 . Property P2 can be easily obtained by moving the derivative operator inside the integral . Note that this exchange of derivative and integral requires f to be of compact support . An immediate consequence of property P2 is that if one of the functions f or g is smooth with compact support , then f ∗ g is also smooth . This observation will be used later in the article to obtain smooth approximations of non-differentiable activation functions . 2.2 MOLLIFIER AND APPROXIMATE IDENTITIES . A smooth function φ over R is called a mollifier if it satisfies the following three properties : 1 . It is compactly supported . 2 . ∫ R φ ( x ) dx = 1 . 3. lim →0 φ ( x ) : = lim →0 1 φ ( x/ ) = δ ( x ) , where δ ( x ) is the Dirac delta function . We say that a mollifier φ is an approximate identity if for any locally integrable function f over R , we have lim →0 ( f ∗ φ ) ( x ) = f ( x ) pointwise for all x . 2.3 SMOOTH APPROXIMATIONS OF NON-DIFFERENTIABLE FUNCTIONS . Let φ be an approximate identity . Choosing = 1/n for n ∈ N , one can define φn ( x ) : = nφ ( nx ) . ( 2 ) Using the property of approximate identity , for any locally integrable function f over R , we have lim n→∞ ( f ∗ φn ) ( x ) = f ( x ) pointwise for all x . That is , for large enough n , f ∗ φn is a good approximation of f . Moreover , since φ is smooth , φn is smooth for each n ∈ N and therefore , using property P2 , f ∗ φn is a smooth approximation of f for large enough n. Let σ : R → R be any activation function . Then , by definition , σ is a continuous and hence , a locally integrable function . For a given approximate identity φ and n ∈ N , we define a smooth approximation of σ as σ ∗ φn , where φn is defined in equation 2 . 3 SMOOTH APPROXIMATION UNIT ( SAU ) . Consider the Gaussian function φ ( x ) = 1√ 2π e− x2 2 which is a well known approximate identity . Consider the Leaky Rectified Linear Unit ( Leaky ReLU ) activation function LeakyReLU [ α ] ( x ) = { x x ≥ 0 αx x < 0 Note that LeakyReLU [ α ] activation function is hyperparametrized by α and it is non-differentiable at the origin for all values of α except α = 1 . For α = 0 , LeakyReLU [ α ] reduces to well known activation function ReLU ( Nair & Hinton ( 2010 ) ) while for constant and trainable α , LeakyReLU [ α ] reduces to Leaky ReLU ( Maas et al . ( 2013 ) ) and Parametric ReLU ( He et al . ( 2015a ) ) respectively . For a given n ∈ N , and α 6= 1 , a smooth approximation of LeakyReLU [ α ] is given by G ( x , α , n ) = ( LeakyReLU [ α ] ∗ φn ) ( x ) = 1 2n √ 2 π e −n2x2 2 + ( 1 + α ) 2 x+ ( 1− α ) 2 x erf ( nx√ 2 ) ( 3 ) where erf is the Gaussian error function erf ( x ) = 2√ π ∫ x 0 e−t 2 dt . It is noticeable that this function is not zero centered but passes by extremely close neighbourhood of zero . To make the function zero centered , we have multiplied the first term of ( 3 ) by a linear component x . To further investigate these two functions as a possible candidates for activation function , we have conducted several experiments on MNIST ( LeCun et al . ( 2010 ) ) , CIFAR10 ( Krizhevsky ( 2009 ) ) , and CIFAR100 ( Krizhevsky ( 2009 ) ) datasets with PreActResNet-18 ( He et al . ( 2016 ) ) , VGG-16 ( with batch-normalization ) ( Ioffe & Szegedy ( 2015 ) ) ( Simonyan & Zisserman ( 2015 ) ) , and DenseNet-121 ( Huang et al . ( 2016 ) ) models , and we notice that both of them performs almost similar in every cases . So , for rest of the paper , we will only consider the approximate identity of Leaky ReLU ( α = 0.25 ) given in ( 3 ) as the activation function . We call this function Smooth Approximation Unit ( SAU ) . Approximation of Leaky ReLU ( α = 0.25 ) by SAU is given in figure 1 . It is clear from the figure 1 that SAU can approximate Leaky ReLU ( as well as ReLU or its variants ) quite well . We note that in GELU ( Hendrycks & Gimpel ( 2020 ) ) paper , a similar idea is utilized to obtain their activation functions . They use the product of xwith the cumulative distribution function of a suitable probability distribution ( see ( Hendrycks & Gimpel ( 2020 ) ) for further details ) . 3.1 LEARNING ACTIVATION PARAMETERS VIA BACK-PROPAGATION . Back-propagation algorithm ( LeCun et al . ( 1989 ) ) and gradient descent is used in neural networks to update Weights and biases . Parameters in trainable activation functions are updated using the same technique . The forward pass is implemented in both Pytorch ( Paszke et al . ( 2019 ) ) & TensorflowKeras ( Chollet et al . ( 2015 ) ) API , and automatic differentiation will update the parameters . Alternatively , CUDA ( Nickolls et al . ( 2008 ) ) based implementation ( see ( Maas et al . ( 2013 ) ) ) can be used and the gradients of equation ( 3 ) for the input x and the parameter α can be computed as follows : ∂G ∂x = −nx 2 √ 2 π e −n2x2 2 + ( 1 + α ) 2 + ( 1− α ) 2 erf ( nx√ 2 ) + n ( 1− α ) √ 2π x e− n2x2 2 ( 4 ) ∂G ∂α = x 2 ( 1− erf ( nx√ 2 ) ) . ( 5 ) where d dx erf ( x ) = 2√ π e−x 2 α and n can be either hyperparameters or trainable parameters . Now , note that the class of neural networks with SAU activation function is dense in C ( K ) , where K is a compact subset of Rn and C ( K ) is the space of all continuous functions over K. The proof follows from the following proposition ( see ( Molina et al . ( 2020 ) ) ) . Proposition 1 . ( Theorem 1.1 in Kidger and Lyons , 2020 ( Kidger & Lyons ( 2020 ) ) ) : - Let ρ : R → R be any continuous function . Let Nρn represent the class of neural networks with activation function ρ , with n neurons in the input layer , one neuron in the output layer , and one hidden layer with an arbitrary number of neurons . Let K ⊆ Rn be compact . Then Nρn is dense in C ( K ) if and only if ρ is non-polynomial . | This paper proposes a new activation function for deep neural networks. Through the lens of *approximate identities*, the authors come up with the new activation function which is a ``smoothed'' version of ReLU/Leaky ReLU, i.e., the Smooth Activation Unit (SAU). The authors conduct experiments on both vision (including classification, object detection, and semantic segmentation) and natural language processing tasks (machine translation) and compare the performance of the proposed SAU with previous widely used activation functions. | SP:ae61318ee80b89bf047eca072385679c4fb5d51a |
Multi-scale Feature Learning Dynamics: Insights for Double Descent | 1 INTRODUCTION . Classical wisdom in statistical learning theory predicts a trade-off between the generalization ability of a machine learning model and its complexity , with highly complex models less likely to generalize well ( Friedman et al. , 2001 ) . If the number of parameters measures complexity , deep learning models sometimes go against this prediction ( Zhang et al. , 2016 ) : deep neural networks trained by stochastic gradient descent exhibit a so-called double descent behavior ( Belkin et al. , 2019b ) with increasing model parameters . Specifically , with increasing complexity , the generalization error first obeys the classical U-shaped curve consistent with statistical learning theory . However , a second regime emerges as the number of parameters is further increased past a transition threshold where generalization error drops again , hence the “ double descent ” or more accurately model-wise double descent ( Nakkiran et al. , 2019 ) . Nakkiran et al . ( 2019 ) showed that the phenomenon of double descent is not limited to varying model size but is also observed as a function of training time or epochs . In this case as well , the so-called epoch-wise double descent is in apparent contradiction with the classical understanding of over-fitting ( Vapnik , 1998 ) , where one expects that longer training of a sufficiently large model beyond a certain threshold should result in over-fitting . This has important implications for practitioners and raises questions about one of the most widely used regularization method in deep learning ( Goodfellow et al. , 2016 ) : early stopping . Indeed , while one might expect early stopping to prevent over-fitting , it might in fact prevent models from being trained at their fullest potential . Since the 1990s , there has been much interest in understanding the origins of non-trivial generalization behaviors of neural networks ( Opper , 1995 ; Opper & Kinzel , 1996 ) . The authors of Krogh & Hertz ( 1992b ) were among the first to provide theoretical explanations for ( model-wise ) double descent in linear models . Summarily , at intermediate levels of complexity , where the model size is equal to the number of training examples , the model is very sensitive to noise in training data and hence , generalizes poorly . This sensitivity to noise reduces if the model complexity is either de- creased or increased . More recently , the double descent phenomena has been also studied for more complex models such as two-layer neural networks and random feature models ( Ba et al. , 2019 ; Mei & Montanari , 2019 ; D ’ Ascoli et al. , 2020 ; Gerace et al. , 2020 ) . The majority of previous work in this direction focuses on understanding the asymptotic behavior of model performance , i.e. , where training time t → ∞ . In recent years , there has been an interest in studying the non-asymptotic ( finite training time ) performance , suggesting that several intriguing properties of neural networks can be attributed to different features being learned at different scales . Among the limited work studying the particular epoch-wise double descent , Nakkiran et al . ( 2019 ) introduces the notion of effective model complexity and hypothesizes that it increases with training time and hence unifies both model-wise and epoch-wise double descent . Through a combination of theory and empirical results , Heckel & Yilmaz ( 2020 ) find that the dynamics of evolution of single and two layer networks under gradient descent , can be perceived to be the superposition of two bias/variance curves with different minima times , thus leading to non-monotonic test error curves . In this work , we build on Bös et al . ( 1993 ) ; Bös ( 1998 ) ; Advani & Saxe ( 2017 ) ; Mei & Montanari ( 2019 ) which analyze model-wise double descent through the lens of linear models , to probe the origins of epoch-wise double descent . Particularly , • We introduce a linear teacher-student model which , despite its simplicity , exhibits some of intriguing properties of generalization dynamics in deep neural networks . ( Section 2.1 ) • In the limit of high dimensions , we leverage the replica method developed in statistical physics to derive closed-form expressions for the generalization dynamics of our teacherstudent setup , as a function of training time and regularization strength . ( Section 2.2 ) • Consistent with recent findings , we provide an explanation for the existence of epoch-wise double descent through the lens of multi-scale feature learning . ( Figure 1 ) • We perform simulation experiments to validate our analytical predictions . We also conduct experiments with deep networks , showing that our teacher-student setup exhibits generalization behavior which is qualitatively similar to that of deep networks . ( Figure 2 ) 2 ANALYTICAL RESULTS . Stochastic Gradient Descent ( SGD ) — the de facto optimization algorithm for neural networks — exhibits complex dynamics arising from a large number of parameters ( Kunin et al. , 2020 ) . However , it is possible to describe some aspects of the high-dimensional microscopic dynamics of neural networks in terms of low-dimensional understandable macroscopic entities . In a series of seminal papers by Gardner ( Gardner , 1988 ; Gardner & Derrida , 1988 ; 1989 ) , the replica method of statistical physics was adopted to derive expressions describing the generalization behavior of large linear models trained using SGD . In this paper , we employ Gardner ’ s analysis to build upon an established line of work studying linear and generalized linear models ( Seung et al. , 1992 ; Kabashima et al. , 2009 ; Krzakala et al. , 2012 ) . While most of previous work study the asymptotic ( t → ∞ ) generalization behavior , we adapt these methods to study transient learning dynamics of generalization for finite training time . In the following , we first introduce a teacher-student model that exhibits interesting characteristics of modern neural networks . We then adapt the replica method to study the generalization performance as a function of training time and amount of regularization . 2.1 A TEACHER-STUDENT SETUP . Teacher : We study a supervised linear regression problem in which the training labels y , are generated by a noisy linear model ( Figure 1 ) , y : = y∗ + , y∗ : = zTW , zi ∼ N ( 0 , 1√ d ) , ( 1 ) where z ∈ Rd is the teacher ’ s input and y∗ , y ∈ R are the teacher ’ s noiseless and noisy outputs , respectively . W ∈ Rd represents the ( fixed ) weights of the teacher and ∈ R is the noise . Both W and are drawn i.i.d . from Gaussian distributions with zero means and variances of 1 and σ2 , respectively . Student : A student model is correspondingly chosen to be a similar shallow network with trainable weights Ŵ ∈ Rd . The student model is trained on n training pairs { ( xµ , yµ ) } nµ=1 , with the labels yµ being generated by the above teacher network , as , ŷ : = xT Ŵ , s.t . x : = FTz , ( 2 ) where the matrix F ∈ Rd×d is a predefined and fixed modulation matrix regulating the student ’ s access to the true input z . One can think of z as the latent factors of variation on which the teacher operates , while x can be thought as the pixels that the student learns from . Learning paradigm : To train our student network , we use stochastic gradient descent ( SGD ) on the regularized mean squared loss , evaluated on the n training examples as , LT : = 1 2n n∑ µ=1 ( yµ − ŷµ ) 2 + λ 2 ||Ŵ ||22 ( 3 ) where λ ∈ [ 0 , ∞ ) is the regularization coefficient . Optimizing Eq . 3 with stochastic gradient descent ( SGD ) yields the typical update rule , Ŵt ← Ŵt−1 − η∇ŴLT + ξ , ( 4 ) in which t denotes the training step and η is the learning rate . Additionally , ξ ∼ N ( 0 , σ2ξ ) models the stochasticity noise of the optimization algorithm ( Bottou et al. , 1991 ) . Macroscopic variables : The quantity of interest in this work , is the expected generalization error of the student , determined by averaging the student ’ s error over all possible input-target pairs and noise realizations , as , LG : = 1 2 Ez [ ( y∗ − ŷ ) 2 ] . ( 5 ) As shown in Bös et al . ( 1993 ) , if n , d→∞ with a constant ratio nd < ∞ , Eq . 5 can be written as a function of two macroscopic scalar variables R , Q ∈ R , LG = 1 2 ( 1 +Q− 2R ) , ( 6 ) where σ2 is the variance of the teacher ’ s output noise and , R : = 1 d WTFŴ , Q : = 1 d ŴTFTFŴ , ( 7 ) See App . B.1 for the proof . Both R and Q have clear interpretations ; R is the dot-product between the teacher ’ s weights W and the student ’ s modulated weights FŴ , hence can be interpreted as the alignment between the teacher and the student . Similarly , Q can be interpreted as the student ’ s modulated norm . The negative sign of R in Eq . 6 suggests that the larger R is , the smaller the generalization error gets . At the same time , Q appears with a positive sign suggesting the students with smaller ( modulated ) norm generalize better . As a remark , note that bothR andQ are functions of Ŵ which itself is a function of training iteration t and the regularization strength λ . Therefore , hereafter , we denote the above quantities as LG ( t , λ ) , R ( t , λ ) , and Q ( t , λ ) . 2.2 MAIN RESULTS . In this Section , we present our main analytical results , with Section 2.3 containing a sketch of our derivations . For brevity of the results , here , we only present the results for σ2 = λ = 0 . See App . B for the general case and the detailed proofs . General matrix F . Let Z : = [ zµ ] nµ=1 ∈ Rn×d and X : = [ xµ ] nµ=1 ∈ Rn×d denote the input matrices for the teacher and student such that X : = ZF . For a general modulation matrix F , the input covariance matrix has the following singular value decomposition ( SVD ) , XTX = FTZTZF = V ΛV T , ( 8 ) in which the diagonal matrix Λ contains the eigenvalues of the student ’ s input covariance matrix . Solving the dynamics of gradient descent as in Eq . 4 , we arrive at the following exact analytical expressions for R ( t ) and Q ( t ) , R ( t ) = 1 d Tr ( D ) where , D : = ( I − [ I − ηΛ ] t ) , ( 9 ) Q ( t ) = 1 d Tr ( ATA ) where , A : = FV DV TF−1 , ( 10 ) in which Tr ( . ) is the trace operator . See App . B.2 the proof . Remark : The solution in Eqs . 9 and 10 are exact , however , they require the empirical computation of the eigenvalues Λ . Below , we treat a special case of the dynamics that allow us to derive approximate solutions that do not explicitly depend on Λ . Special case : Fast and slow features . We now study a case where the modulation matrix F has a specific structure described in Assumption 1 . Assumption 1 . The modulation matrix , F , under a SVD , F : = UΣV T has two sets of singular values such that the first p singular values are equal to σ1 and the remaining d− p singular values are equal to σ2 . We let the condition number of F to be denoted by κ : = σ1σ2 > 1 . By employing the replica method of statistical physics ( Gardner , 1988 ; Gardner & Derrida , 1988 ) , we now derive approximate expressions for R ( t ) and Q ( t ) . To begin with , we first define the following auxiliary variables , α1 : = n p , α2 : = n d− p , λ̃1 : = d p 1 ησ21t , λ̃2 : = d d− p 1 ησ22t , ( 11 ) and also let , ai = 1 + 2λ̃i ( 1− αi − λ̃i ) + √ ( 1− αi − λ̃i ) 2 + 4λ̃i , for i ∈ { 1 , 2 } . ( 12 ) The closed-from scalar expression for R ( t ) is then given by , R ( t ) = R1 +R2 , where , R1 : = n a1d , and , R2 : = n a2d ( 13 ) For Q ( t ) , we accordingly define two more auxiliary variables , bi = αi a2i − αi , ci = 1− 2Ri − n d 2− ai ai for i ∈ { 1 , 2 } , ( 14 ) with which the closed-from scalar expression for Q ( t ) reads , Q ( t ) = Q1 +Q2 , where , Q1 : = b1b2c2 + b1c1 1− b1b2 , and , Q2 : = b1b2c1 + b2c2 1− b1b2 . ( 15 ) By plugging Eqs . 13 and 15 into Eq . 6 , one obtains a closed-form expression for LG ( t ) as a function of the training time . See App . B.3 for the proof . R = R1 + R2 R1 R2 t SGD steps tth step on argmin L ( Ŵ ) < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L ( Ŵ ) < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > SGD steps tth step on argmin L ( Ŵ ) < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L ( Ŵ ) < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > Remark : Eq . 11 indicates that the singular values of F , are directly multiplied by t. That implies that the learning speed of each feature is scaled by the magnitude of its corresponding singular value . As an illustration , the figure on the right shows the evolution of R1 , R2 , and R = R1 + R2 for a case where p = d/2 , σ1 = 1 , and σ1 = 0.01 implying a condition number of κ = 100 . | An influential line of work has revealed that deep neural networks can exhibit non-monotonic behavior in their generalization error (double descent) as a function of model size, dataset size, and training time. Recent (and old) theoretical work has demonstrated that even simple models like linear regression exhibit the same non-monotonic behavior as a function of model and dataset size. The authors of this work build on this literature by demonstrating that linear teacher-student models trained with gradient descent can exhibit double descent as a function of training time. Using replica theory, they derive a closed-form expression for the generalization error of this model as a function of training time. They show that double descent can arise when the student is trained on anisotropic data which includes a set of high SNR features and a set of low SNR features. Finally, the authors demonstrate a qualitative match between the generalization error behavior of linear teacher-student regression and a ResNet18 trained on CIFAR10 as a function of training time and regularization strength. | SP:2b87cea58bd6312f65f20460314818937d8f8bcd |
Multi-scale Feature Learning Dynamics: Insights for Double Descent | 1 INTRODUCTION . Classical wisdom in statistical learning theory predicts a trade-off between the generalization ability of a machine learning model and its complexity , with highly complex models less likely to generalize well ( Friedman et al. , 2001 ) . If the number of parameters measures complexity , deep learning models sometimes go against this prediction ( Zhang et al. , 2016 ) : deep neural networks trained by stochastic gradient descent exhibit a so-called double descent behavior ( Belkin et al. , 2019b ) with increasing model parameters . Specifically , with increasing complexity , the generalization error first obeys the classical U-shaped curve consistent with statistical learning theory . However , a second regime emerges as the number of parameters is further increased past a transition threshold where generalization error drops again , hence the “ double descent ” or more accurately model-wise double descent ( Nakkiran et al. , 2019 ) . Nakkiran et al . ( 2019 ) showed that the phenomenon of double descent is not limited to varying model size but is also observed as a function of training time or epochs . In this case as well , the so-called epoch-wise double descent is in apparent contradiction with the classical understanding of over-fitting ( Vapnik , 1998 ) , where one expects that longer training of a sufficiently large model beyond a certain threshold should result in over-fitting . This has important implications for practitioners and raises questions about one of the most widely used regularization method in deep learning ( Goodfellow et al. , 2016 ) : early stopping . Indeed , while one might expect early stopping to prevent over-fitting , it might in fact prevent models from being trained at their fullest potential . Since the 1990s , there has been much interest in understanding the origins of non-trivial generalization behaviors of neural networks ( Opper , 1995 ; Opper & Kinzel , 1996 ) . The authors of Krogh & Hertz ( 1992b ) were among the first to provide theoretical explanations for ( model-wise ) double descent in linear models . Summarily , at intermediate levels of complexity , where the model size is equal to the number of training examples , the model is very sensitive to noise in training data and hence , generalizes poorly . This sensitivity to noise reduces if the model complexity is either de- creased or increased . More recently , the double descent phenomena has been also studied for more complex models such as two-layer neural networks and random feature models ( Ba et al. , 2019 ; Mei & Montanari , 2019 ; D ’ Ascoli et al. , 2020 ; Gerace et al. , 2020 ) . The majority of previous work in this direction focuses on understanding the asymptotic behavior of model performance , i.e. , where training time t → ∞ . In recent years , there has been an interest in studying the non-asymptotic ( finite training time ) performance , suggesting that several intriguing properties of neural networks can be attributed to different features being learned at different scales . Among the limited work studying the particular epoch-wise double descent , Nakkiran et al . ( 2019 ) introduces the notion of effective model complexity and hypothesizes that it increases with training time and hence unifies both model-wise and epoch-wise double descent . Through a combination of theory and empirical results , Heckel & Yilmaz ( 2020 ) find that the dynamics of evolution of single and two layer networks under gradient descent , can be perceived to be the superposition of two bias/variance curves with different minima times , thus leading to non-monotonic test error curves . In this work , we build on Bös et al . ( 1993 ) ; Bös ( 1998 ) ; Advani & Saxe ( 2017 ) ; Mei & Montanari ( 2019 ) which analyze model-wise double descent through the lens of linear models , to probe the origins of epoch-wise double descent . Particularly , • We introduce a linear teacher-student model which , despite its simplicity , exhibits some of intriguing properties of generalization dynamics in deep neural networks . ( Section 2.1 ) • In the limit of high dimensions , we leverage the replica method developed in statistical physics to derive closed-form expressions for the generalization dynamics of our teacherstudent setup , as a function of training time and regularization strength . ( Section 2.2 ) • Consistent with recent findings , we provide an explanation for the existence of epoch-wise double descent through the lens of multi-scale feature learning . ( Figure 1 ) • We perform simulation experiments to validate our analytical predictions . We also conduct experiments with deep networks , showing that our teacher-student setup exhibits generalization behavior which is qualitatively similar to that of deep networks . ( Figure 2 ) 2 ANALYTICAL RESULTS . Stochastic Gradient Descent ( SGD ) — the de facto optimization algorithm for neural networks — exhibits complex dynamics arising from a large number of parameters ( Kunin et al. , 2020 ) . However , it is possible to describe some aspects of the high-dimensional microscopic dynamics of neural networks in terms of low-dimensional understandable macroscopic entities . In a series of seminal papers by Gardner ( Gardner , 1988 ; Gardner & Derrida , 1988 ; 1989 ) , the replica method of statistical physics was adopted to derive expressions describing the generalization behavior of large linear models trained using SGD . In this paper , we employ Gardner ’ s analysis to build upon an established line of work studying linear and generalized linear models ( Seung et al. , 1992 ; Kabashima et al. , 2009 ; Krzakala et al. , 2012 ) . While most of previous work study the asymptotic ( t → ∞ ) generalization behavior , we adapt these methods to study transient learning dynamics of generalization for finite training time . In the following , we first introduce a teacher-student model that exhibits interesting characteristics of modern neural networks . We then adapt the replica method to study the generalization performance as a function of training time and amount of regularization . 2.1 A TEACHER-STUDENT SETUP . Teacher : We study a supervised linear regression problem in which the training labels y , are generated by a noisy linear model ( Figure 1 ) , y : = y∗ + , y∗ : = zTW , zi ∼ N ( 0 , 1√ d ) , ( 1 ) where z ∈ Rd is the teacher ’ s input and y∗ , y ∈ R are the teacher ’ s noiseless and noisy outputs , respectively . W ∈ Rd represents the ( fixed ) weights of the teacher and ∈ R is the noise . Both W and are drawn i.i.d . from Gaussian distributions with zero means and variances of 1 and σ2 , respectively . Student : A student model is correspondingly chosen to be a similar shallow network with trainable weights Ŵ ∈ Rd . The student model is trained on n training pairs { ( xµ , yµ ) } nµ=1 , with the labels yµ being generated by the above teacher network , as , ŷ : = xT Ŵ , s.t . x : = FTz , ( 2 ) where the matrix F ∈ Rd×d is a predefined and fixed modulation matrix regulating the student ’ s access to the true input z . One can think of z as the latent factors of variation on which the teacher operates , while x can be thought as the pixels that the student learns from . Learning paradigm : To train our student network , we use stochastic gradient descent ( SGD ) on the regularized mean squared loss , evaluated on the n training examples as , LT : = 1 2n n∑ µ=1 ( yµ − ŷµ ) 2 + λ 2 ||Ŵ ||22 ( 3 ) where λ ∈ [ 0 , ∞ ) is the regularization coefficient . Optimizing Eq . 3 with stochastic gradient descent ( SGD ) yields the typical update rule , Ŵt ← Ŵt−1 − η∇ŴLT + ξ , ( 4 ) in which t denotes the training step and η is the learning rate . Additionally , ξ ∼ N ( 0 , σ2ξ ) models the stochasticity noise of the optimization algorithm ( Bottou et al. , 1991 ) . Macroscopic variables : The quantity of interest in this work , is the expected generalization error of the student , determined by averaging the student ’ s error over all possible input-target pairs and noise realizations , as , LG : = 1 2 Ez [ ( y∗ − ŷ ) 2 ] . ( 5 ) As shown in Bös et al . ( 1993 ) , if n , d→∞ with a constant ratio nd < ∞ , Eq . 5 can be written as a function of two macroscopic scalar variables R , Q ∈ R , LG = 1 2 ( 1 +Q− 2R ) , ( 6 ) where σ2 is the variance of the teacher ’ s output noise and , R : = 1 d WTFŴ , Q : = 1 d ŴTFTFŴ , ( 7 ) See App . B.1 for the proof . Both R and Q have clear interpretations ; R is the dot-product between the teacher ’ s weights W and the student ’ s modulated weights FŴ , hence can be interpreted as the alignment between the teacher and the student . Similarly , Q can be interpreted as the student ’ s modulated norm . The negative sign of R in Eq . 6 suggests that the larger R is , the smaller the generalization error gets . At the same time , Q appears with a positive sign suggesting the students with smaller ( modulated ) norm generalize better . As a remark , note that bothR andQ are functions of Ŵ which itself is a function of training iteration t and the regularization strength λ . Therefore , hereafter , we denote the above quantities as LG ( t , λ ) , R ( t , λ ) , and Q ( t , λ ) . 2.2 MAIN RESULTS . In this Section , we present our main analytical results , with Section 2.3 containing a sketch of our derivations . For brevity of the results , here , we only present the results for σ2 = λ = 0 . See App . B for the general case and the detailed proofs . General matrix F . Let Z : = [ zµ ] nµ=1 ∈ Rn×d and X : = [ xµ ] nµ=1 ∈ Rn×d denote the input matrices for the teacher and student such that X : = ZF . For a general modulation matrix F , the input covariance matrix has the following singular value decomposition ( SVD ) , XTX = FTZTZF = V ΛV T , ( 8 ) in which the diagonal matrix Λ contains the eigenvalues of the student ’ s input covariance matrix . Solving the dynamics of gradient descent as in Eq . 4 , we arrive at the following exact analytical expressions for R ( t ) and Q ( t ) , R ( t ) = 1 d Tr ( D ) where , D : = ( I − [ I − ηΛ ] t ) , ( 9 ) Q ( t ) = 1 d Tr ( ATA ) where , A : = FV DV TF−1 , ( 10 ) in which Tr ( . ) is the trace operator . See App . B.2 the proof . Remark : The solution in Eqs . 9 and 10 are exact , however , they require the empirical computation of the eigenvalues Λ . Below , we treat a special case of the dynamics that allow us to derive approximate solutions that do not explicitly depend on Λ . Special case : Fast and slow features . We now study a case where the modulation matrix F has a specific structure described in Assumption 1 . Assumption 1 . The modulation matrix , F , under a SVD , F : = UΣV T has two sets of singular values such that the first p singular values are equal to σ1 and the remaining d− p singular values are equal to σ2 . We let the condition number of F to be denoted by κ : = σ1σ2 > 1 . By employing the replica method of statistical physics ( Gardner , 1988 ; Gardner & Derrida , 1988 ) , we now derive approximate expressions for R ( t ) and Q ( t ) . To begin with , we first define the following auxiliary variables , α1 : = n p , α2 : = n d− p , λ̃1 : = d p 1 ησ21t , λ̃2 : = d d− p 1 ησ22t , ( 11 ) and also let , ai = 1 + 2λ̃i ( 1− αi − λ̃i ) + √ ( 1− αi − λ̃i ) 2 + 4λ̃i , for i ∈ { 1 , 2 } . ( 12 ) The closed-from scalar expression for R ( t ) is then given by , R ( t ) = R1 +R2 , where , R1 : = n a1d , and , R2 : = n a2d ( 13 ) For Q ( t ) , we accordingly define two more auxiliary variables , bi = αi a2i − αi , ci = 1− 2Ri − n d 2− ai ai for i ∈ { 1 , 2 } , ( 14 ) with which the closed-from scalar expression for Q ( t ) reads , Q ( t ) = Q1 +Q2 , where , Q1 : = b1b2c2 + b1c1 1− b1b2 , and , Q2 : = b1b2c1 + b2c2 1− b1b2 . ( 15 ) By plugging Eqs . 13 and 15 into Eq . 6 , one obtains a closed-form expression for LG ( t ) as a function of the training time . See App . B.3 for the proof . R = R1 + R2 R1 R2 t SGD steps tth step on argmin L ( Ŵ ) < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L ( Ŵ ) < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > SGD steps tth step on argmin L ( Ŵ ) < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L ( Ŵ ) < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > Remark : Eq . 11 indicates that the singular values of F , are directly multiplied by t. That implies that the learning speed of each feature is scaled by the magnitude of its corresponding singular value . As an illustration , the figure on the right shows the evolution of R1 , R2 , and R = R1 + R2 for a case where p = d/2 , σ1 = 1 , and σ1 = 0.01 implying a condition number of κ = 100 . | This work studied epoch-wise double descent using linear model as a proxy. Basically, authors proposed a linear teacher-student models to established analysis and used random matrix theory (rmt) to interpret the learning dynamics. Some simulation on the well-posed (n>p) linear regression problems backups the theory. Some real-world experiments based on ResNet-18 and noisy labels also demonstrate the relevance of proposed theorem. | SP:2b87cea58bd6312f65f20460314818937d8f8bcd |
Multi-scale Feature Learning Dynamics: Insights for Double Descent | 1 INTRODUCTION . Classical wisdom in statistical learning theory predicts a trade-off between the generalization ability of a machine learning model and its complexity , with highly complex models less likely to generalize well ( Friedman et al. , 2001 ) . If the number of parameters measures complexity , deep learning models sometimes go against this prediction ( Zhang et al. , 2016 ) : deep neural networks trained by stochastic gradient descent exhibit a so-called double descent behavior ( Belkin et al. , 2019b ) with increasing model parameters . Specifically , with increasing complexity , the generalization error first obeys the classical U-shaped curve consistent with statistical learning theory . However , a second regime emerges as the number of parameters is further increased past a transition threshold where generalization error drops again , hence the “ double descent ” or more accurately model-wise double descent ( Nakkiran et al. , 2019 ) . Nakkiran et al . ( 2019 ) showed that the phenomenon of double descent is not limited to varying model size but is also observed as a function of training time or epochs . In this case as well , the so-called epoch-wise double descent is in apparent contradiction with the classical understanding of over-fitting ( Vapnik , 1998 ) , where one expects that longer training of a sufficiently large model beyond a certain threshold should result in over-fitting . This has important implications for practitioners and raises questions about one of the most widely used regularization method in deep learning ( Goodfellow et al. , 2016 ) : early stopping . Indeed , while one might expect early stopping to prevent over-fitting , it might in fact prevent models from being trained at their fullest potential . Since the 1990s , there has been much interest in understanding the origins of non-trivial generalization behaviors of neural networks ( Opper , 1995 ; Opper & Kinzel , 1996 ) . The authors of Krogh & Hertz ( 1992b ) were among the first to provide theoretical explanations for ( model-wise ) double descent in linear models . Summarily , at intermediate levels of complexity , where the model size is equal to the number of training examples , the model is very sensitive to noise in training data and hence , generalizes poorly . This sensitivity to noise reduces if the model complexity is either de- creased or increased . More recently , the double descent phenomena has been also studied for more complex models such as two-layer neural networks and random feature models ( Ba et al. , 2019 ; Mei & Montanari , 2019 ; D ’ Ascoli et al. , 2020 ; Gerace et al. , 2020 ) . The majority of previous work in this direction focuses on understanding the asymptotic behavior of model performance , i.e. , where training time t → ∞ . In recent years , there has been an interest in studying the non-asymptotic ( finite training time ) performance , suggesting that several intriguing properties of neural networks can be attributed to different features being learned at different scales . Among the limited work studying the particular epoch-wise double descent , Nakkiran et al . ( 2019 ) introduces the notion of effective model complexity and hypothesizes that it increases with training time and hence unifies both model-wise and epoch-wise double descent . Through a combination of theory and empirical results , Heckel & Yilmaz ( 2020 ) find that the dynamics of evolution of single and two layer networks under gradient descent , can be perceived to be the superposition of two bias/variance curves with different minima times , thus leading to non-monotonic test error curves . In this work , we build on Bös et al . ( 1993 ) ; Bös ( 1998 ) ; Advani & Saxe ( 2017 ) ; Mei & Montanari ( 2019 ) which analyze model-wise double descent through the lens of linear models , to probe the origins of epoch-wise double descent . Particularly , • We introduce a linear teacher-student model which , despite its simplicity , exhibits some of intriguing properties of generalization dynamics in deep neural networks . ( Section 2.1 ) • In the limit of high dimensions , we leverage the replica method developed in statistical physics to derive closed-form expressions for the generalization dynamics of our teacherstudent setup , as a function of training time and regularization strength . ( Section 2.2 ) • Consistent with recent findings , we provide an explanation for the existence of epoch-wise double descent through the lens of multi-scale feature learning . ( Figure 1 ) • We perform simulation experiments to validate our analytical predictions . We also conduct experiments with deep networks , showing that our teacher-student setup exhibits generalization behavior which is qualitatively similar to that of deep networks . ( Figure 2 ) 2 ANALYTICAL RESULTS . Stochastic Gradient Descent ( SGD ) — the de facto optimization algorithm for neural networks — exhibits complex dynamics arising from a large number of parameters ( Kunin et al. , 2020 ) . However , it is possible to describe some aspects of the high-dimensional microscopic dynamics of neural networks in terms of low-dimensional understandable macroscopic entities . In a series of seminal papers by Gardner ( Gardner , 1988 ; Gardner & Derrida , 1988 ; 1989 ) , the replica method of statistical physics was adopted to derive expressions describing the generalization behavior of large linear models trained using SGD . In this paper , we employ Gardner ’ s analysis to build upon an established line of work studying linear and generalized linear models ( Seung et al. , 1992 ; Kabashima et al. , 2009 ; Krzakala et al. , 2012 ) . While most of previous work study the asymptotic ( t → ∞ ) generalization behavior , we adapt these methods to study transient learning dynamics of generalization for finite training time . In the following , we first introduce a teacher-student model that exhibits interesting characteristics of modern neural networks . We then adapt the replica method to study the generalization performance as a function of training time and amount of regularization . 2.1 A TEACHER-STUDENT SETUP . Teacher : We study a supervised linear regression problem in which the training labels y , are generated by a noisy linear model ( Figure 1 ) , y : = y∗ + , y∗ : = zTW , zi ∼ N ( 0 , 1√ d ) , ( 1 ) where z ∈ Rd is the teacher ’ s input and y∗ , y ∈ R are the teacher ’ s noiseless and noisy outputs , respectively . W ∈ Rd represents the ( fixed ) weights of the teacher and ∈ R is the noise . Both W and are drawn i.i.d . from Gaussian distributions with zero means and variances of 1 and σ2 , respectively . Student : A student model is correspondingly chosen to be a similar shallow network with trainable weights Ŵ ∈ Rd . The student model is trained on n training pairs { ( xµ , yµ ) } nµ=1 , with the labels yµ being generated by the above teacher network , as , ŷ : = xT Ŵ , s.t . x : = FTz , ( 2 ) where the matrix F ∈ Rd×d is a predefined and fixed modulation matrix regulating the student ’ s access to the true input z . One can think of z as the latent factors of variation on which the teacher operates , while x can be thought as the pixels that the student learns from . Learning paradigm : To train our student network , we use stochastic gradient descent ( SGD ) on the regularized mean squared loss , evaluated on the n training examples as , LT : = 1 2n n∑ µ=1 ( yµ − ŷµ ) 2 + λ 2 ||Ŵ ||22 ( 3 ) where λ ∈ [ 0 , ∞ ) is the regularization coefficient . Optimizing Eq . 3 with stochastic gradient descent ( SGD ) yields the typical update rule , Ŵt ← Ŵt−1 − η∇ŴLT + ξ , ( 4 ) in which t denotes the training step and η is the learning rate . Additionally , ξ ∼ N ( 0 , σ2ξ ) models the stochasticity noise of the optimization algorithm ( Bottou et al. , 1991 ) . Macroscopic variables : The quantity of interest in this work , is the expected generalization error of the student , determined by averaging the student ’ s error over all possible input-target pairs and noise realizations , as , LG : = 1 2 Ez [ ( y∗ − ŷ ) 2 ] . ( 5 ) As shown in Bös et al . ( 1993 ) , if n , d→∞ with a constant ratio nd < ∞ , Eq . 5 can be written as a function of two macroscopic scalar variables R , Q ∈ R , LG = 1 2 ( 1 +Q− 2R ) , ( 6 ) where σ2 is the variance of the teacher ’ s output noise and , R : = 1 d WTFŴ , Q : = 1 d ŴTFTFŴ , ( 7 ) See App . B.1 for the proof . Both R and Q have clear interpretations ; R is the dot-product between the teacher ’ s weights W and the student ’ s modulated weights FŴ , hence can be interpreted as the alignment between the teacher and the student . Similarly , Q can be interpreted as the student ’ s modulated norm . The negative sign of R in Eq . 6 suggests that the larger R is , the smaller the generalization error gets . At the same time , Q appears with a positive sign suggesting the students with smaller ( modulated ) norm generalize better . As a remark , note that bothR andQ are functions of Ŵ which itself is a function of training iteration t and the regularization strength λ . Therefore , hereafter , we denote the above quantities as LG ( t , λ ) , R ( t , λ ) , and Q ( t , λ ) . 2.2 MAIN RESULTS . In this Section , we present our main analytical results , with Section 2.3 containing a sketch of our derivations . For brevity of the results , here , we only present the results for σ2 = λ = 0 . See App . B for the general case and the detailed proofs . General matrix F . Let Z : = [ zµ ] nµ=1 ∈ Rn×d and X : = [ xµ ] nµ=1 ∈ Rn×d denote the input matrices for the teacher and student such that X : = ZF . For a general modulation matrix F , the input covariance matrix has the following singular value decomposition ( SVD ) , XTX = FTZTZF = V ΛV T , ( 8 ) in which the diagonal matrix Λ contains the eigenvalues of the student ’ s input covariance matrix . Solving the dynamics of gradient descent as in Eq . 4 , we arrive at the following exact analytical expressions for R ( t ) and Q ( t ) , R ( t ) = 1 d Tr ( D ) where , D : = ( I − [ I − ηΛ ] t ) , ( 9 ) Q ( t ) = 1 d Tr ( ATA ) where , A : = FV DV TF−1 , ( 10 ) in which Tr ( . ) is the trace operator . See App . B.2 the proof . Remark : The solution in Eqs . 9 and 10 are exact , however , they require the empirical computation of the eigenvalues Λ . Below , we treat a special case of the dynamics that allow us to derive approximate solutions that do not explicitly depend on Λ . Special case : Fast and slow features . We now study a case where the modulation matrix F has a specific structure described in Assumption 1 . Assumption 1 . The modulation matrix , F , under a SVD , F : = UΣV T has two sets of singular values such that the first p singular values are equal to σ1 and the remaining d− p singular values are equal to σ2 . We let the condition number of F to be denoted by κ : = σ1σ2 > 1 . By employing the replica method of statistical physics ( Gardner , 1988 ; Gardner & Derrida , 1988 ) , we now derive approximate expressions for R ( t ) and Q ( t ) . To begin with , we first define the following auxiliary variables , α1 : = n p , α2 : = n d− p , λ̃1 : = d p 1 ησ21t , λ̃2 : = d d− p 1 ησ22t , ( 11 ) and also let , ai = 1 + 2λ̃i ( 1− αi − λ̃i ) + √ ( 1− αi − λ̃i ) 2 + 4λ̃i , for i ∈ { 1 , 2 } . ( 12 ) The closed-from scalar expression for R ( t ) is then given by , R ( t ) = R1 +R2 , where , R1 : = n a1d , and , R2 : = n a2d ( 13 ) For Q ( t ) , we accordingly define two more auxiliary variables , bi = αi a2i − αi , ci = 1− 2Ri − n d 2− ai ai for i ∈ { 1 , 2 } , ( 14 ) with which the closed-from scalar expression for Q ( t ) reads , Q ( t ) = Q1 +Q2 , where , Q1 : = b1b2c2 + b1c1 1− b1b2 , and , Q2 : = b1b2c1 + b2c2 1− b1b2 . ( 15 ) By plugging Eqs . 13 and 15 into Eq . 6 , one obtains a closed-form expression for LG ( t ) as a function of the training time . See App . B.3 for the proof . R = R1 + R2 R1 R2 t SGD steps tth step on argmin L ( Ŵ ) < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L ( Ŵ ) < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > SGD steps tth step on argmin L ( Ŵ ) < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > L ( Ŵ ) < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > < latexit sha1_base64= '' KrE7GKXcbjd4i3q6mbD83colcc4= '' > AAAB/XicbVDLSsNAFJ34rPUVHzs3g0Wom5KIoMuiGxcuKtgHNKHcTKft0MkkzEyEGoK/4saFIm79D3f+jZM2C209MHA4517umRPEnCntON/W0vLK6tp6aaO8ubW9s2vv7bdUlEhCmyTikewEoChngjY105x2YkkhDDhtB+Pr3G8/UKlYJO71JKZ+CEPBBoyANlLPPvRC0CMCPL3Nqt4IdNrOTnt2xak5U+BF4hakggo0evaX149IElKhCQeluq4Taz8FqRnhNCt7iaIxkDEMaddQASFVfjpNn+ETo/TxIJLmCY2n6u+NFEKlJmFgJvOsat7Lxf+8bqIHl37KRJxoKsjs0CDhWEc4rwL3maRE84khQCQzWTEZgQSiTWFlU4I7/+VF0jqruU7NvTuv1K+KOkroCB2jKnLRBaqjG9RATUTQI3pGr+jNerJerHfrYza6ZBU7B+gPrM8fXfGVJg== < /latexit > L̃ ( Ŵ , t ) < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > < latexit sha1_base64= '' 32x2N2VoNbVPu4FGsSV5PhoASno= '' > AAACCHicbVDLSsNAFJ3UV62vqEsXDhahgpREBF0W3bhwUcE+oAllMpm2QycPZm6EErJ046+4caGIWz/BnX/jpM1CWw9cOJxzL/fe48WCK7Csb6O0tLyyulZer2xsbm3vmLt7bRUlkrIWjUQkux5RTPCQtYCDYN1YMhJ4gnW88XXudx6YVDwK72ESMzcgw5APOCWgpb556AAXPkudgMCIEpHeZlnNGRFIO9kphpO+WbXq1hR4kdgFqaICzb755fgRTQIWAhVEqZ5txeCmRAKngmUVJ1EsJnRMhqynaUgCptx0+kiGj7Xi40EkdYWAp+rviZQESk0CT3fm96p5Lxf/83oJDC7dlIdxAiyks0WDRGCIcJ4K9rlkFMREE0Il17diOiKSUNDZVXQI9vzLi6R9Vretun13Xm1cFXGU0QE6QjVkowvUQDeoiVqIokf0jF7Rm/FkvBjvxsestWQUM/voD4zPH7G3mbo= < /latexit > Remark : Eq . 11 indicates that the singular values of F , are directly multiplied by t. That implies that the learning speed of each feature is scaled by the magnitude of its corresponding singular value . As an illustration , the figure on the right shows the evolution of R1 , R2 , and R = R1 + R2 for a case where p = d/2 , σ1 = 1 , and σ1 = 0.01 implying a condition number of κ = 100 . | This paper theoretically analyzes a student-teacher setting for which epoch-wise double descent occurs. (Epoch-wise double descent, previously discussed in the literature, refers to the non-monotonicity of the population error as a function of training time.) More specifically, the setup is: (a) a linear teacher with Gaussian noise; (b) a linear student whose inputs are a linear transformation F ("modulation matrix") applied to the teacher's inputs. The inputs are d-dimensional and there are n training samples. Exact analytic expressions for the test error can be derived by utilizing the replica method in the limit of n, d -> \infty. The case analyzed in most depth is a setting in which F has two scales for its singular values (with high degeneracy) -- c.f. Assumption 1. Both the theory and finite-size simulations indeed exhibit epoch-wise double descent depending on the choice of setting parameters (e.g. strength of regularization and condition number of F). The intuition behind this is that when the scales are well-separated and learnable (e.g. regularization not too strong), overfitting of the faster features occurs (leading to a rise in the test error) before learning of the slower features (which subsequently decreases the test error). | SP:2b87cea58bd6312f65f20460314818937d8f8bcd |
DreamerPro: Reconstruction-Free Model-Based Reinforcement Learning with Prototypical Representations | 1 INTRODUCTION . Model-Based Reinforcement Learning ( MBRL , Sutton & Barto , 2018 ; Sutton , 1991 ) provides a solution to many problems in contemporary reinforcement learning . It improves sample efficiency by training a policy through simulations of a learned world model . Learning a world model also provides a way to efficiently represent experience data as general knowledge simulatable and reusable in arbitrary downstream tasks . In addition , it allows accurate and safe decisions via planning . Among recent advances in image-based MBRL , DREAMER is particularly notable as the first MBRL model outperforming popular model-free RL algorithms with better sample efficiency in both continuous control ( Hafner et al. , 2020 ) and discrete control ( Hafner et al. , 2021 ) . Unlike some previous model-based RL methods ( Kaiser et al. , 2019 ) , it learns a world model that can be rolled out in a compact latent representation space instead of the high-dimensional observation space . Also , policy learning can be done efficiently via backpropagation through the differentiable dynamics model . In image-based RL , the key problem is to learn low-dimensional state representation and , in the model-based case , also its forward model . Although we can learn such representation directly by maximizing the rewards ( Schrittwieser et al. , 2020 ) , it is usually very slow to do this due to the reward sparsity . Instead , it is more practical to introduce auxiliary tasks providing richer learning signal to facilitate representation learning without reward ( or with sparse reward ) ( Sutton et al. , 2011 ; Jaderberg et al. , 2016 ) . DREAMER achieves this by learning the representation and the dynamics model in a way to reduce the reconstruction error of the observed sequences . However , reconstruction-based representation learning has limitations . First , it is computationally expensive to reconstruct the high-dimensional inputs , especially in models like DREAMER that needs to reconstruct long-range videos . Second , it wastes the representation capacity to learn even the visual signals that are irrelevant to the task or unpredictable such as noisy background ( Burda et al. , 2018 ) . Thus , in MBRL it is of particular interest to realize a version of DREAMER without reconstruction . Recently , there have been remarkable advances in reconstruction-free representation learning in reinforcement learning ( Laskin et al. , 2020a ; b ; Yarats et al. , 2021c ) . The currently dominant approach is via contrastive learning . This approach requires pair-wise comparisons to push apart different instances while pulling close an instance and its augmentation . Therefore , this method usually requires a large batch size ( so computationally expensive ) to perform accurately and robustly . An alternative is the clustering-based or prototype-based approach ( Caron et al. , 2020 ) . By learning a set of clusters represented by prototypes , it replaces the instance-wise comparison by a comparison to the clusters and thereby avoids the problems of contrastive learning . This approach is shown to perform more accurately and robustly in many applications ( Caron et al. , 2020 ; 2021 ; Yarats et al. , 2021b ) than the contrastive method while also alleviating the need for maintaining a large batch size . The prototype structure can also be used to implement an exploration method ( Yarats et al. , 2021b ) . However , for reconstruction-free MBRL only the contrastive approach like Temporal Predictive Coding ( TPC , Nguyen et al. , 2021 ) has been proposed so far . While TPC consistently outperforms DREAMER in the noisy background settings , for standard DeepMind Control suite ( Tassa et al. , 2018 ) it showed quite inconsistent results by performing severely worse than DREAMER on some tasks . Therefore , we hypothesize that this inconsistent behavior may be fixed if the robustness and accuracy of the prototypical representations can be realized in MBRL and further improved with the support of temporal information . In this paper , we propose a reconstruction-free MBRL agent , called DREAMERPRO , by combining the prototypical representation learning with temporal dynamics learning . Similar to SwAV ( Caron et al. , 2020 ) , by encouraging uniform cluster assignment across the batch , we implicitly pull apart the embeddings of different observations . Additionally , we let the temporal latent state to ‘ reconstruct ’ the cluster assignment of the observation , thereby relieving the world model from modeling lowlevel details . We evaluate our model on the standard setting of DeepMind Control suite , and also on a natural background setting , where the background is replaced by natural videos irrelevant to the task . The results show that the proposed model consistently outperforms previous methods . The contributions of the paper are ( 1 ) the first reconstruction-free MBRL agent based on the prototypical representation and its temporal dynamics and ( 2 ) the demonstration of the consistently improved accuracy and robustness of the proposed model in comparison to a contrastive reconstructionfree MBRL agent and Dreamer for both standard and natural background DMC tasks . 2 PRELIMINARIES . In this section , we briefly introduce the world model and learning algorithms used in DREAMERV2 ( Hafner et al. , 2021 ) which our model builds upon . To indicate the general DREAMER framework ( Hafner et al. , 2020 ; 2021 ) , we omit its version number in the rest of the paper . 2.1 RECONSTRUCTION-BASED WORLD MODEL LEARNING . DREAMER learns a recurrent state-space model ( RSSM , Hafner et al. , 2019 ) to predict forward dynamics and rewards in partially observable environments . At each time step t , the agent receives an image observation ot and a scalar reward rt ( obtained by previous actions a < t ) . The agent then chooses an action at based on its policy . The RSSM models the observations , rewards , and transitions through a probabilistic generative process : p ( o1 : T , r1 : T | a1 : T ) = ∫ T∏ t=1 p ( ot | s≤t , a < t ) p ( rt | s≤t , a < t ) p ( st | s < t , a < t ) ds1 : T ( 1 ) = ∫ T∏ t=1 p ( ot | ht , st ) p ( rt | ht , st ) p ( st | ht ) ds1 : T , ( 2 ) where the latent variables s1 : T are the agent states , and ht = GRU ( ht−1 , st−1 , at−1 ) is a deterministic encoding of s < t and a < t . To infer the agent states from past observations and actions , a variational encoder is introduced : q ( s1 : T | o1 : T , a1 : T ) = T∏ t=1 q ( st | s < t , a < t , ot ) = T∏ t=1 q ( st | ht , ot ) . ( 3 ) The training objective is to maximize the evidence lower bound ( ELBO ) : JDREAMER = T∑ t=1 Eq [ log p ( ot | ht , st ) ︸ ︷︷ ︸ J tO + log p ( rt | ht , st ) ︸ ︷︷ ︸ J tR −DKL ( q ( st | ht , ot ) ‖ p ( st | ht ) ) ︸ ︷︷ ︸ J tKL ] . ( 4 ) 2.2 POLICY LEARNING BY LATENT IMAGINATION . DREAMER interleaves policy learning with world model learning . During policy learning , the world model is fixed , and an actor and a critic are trained cooperatively from the latent trajectories imagined by the world model . Specifically , the imagination starts at each non-terminal state ẑt = [ ht , st ] encountered during world model learning . Then , at each imagination step t′ ≥ t , an action is sampled from the actor ’ s stochastic policy : ât′ ∼ π ( ât′ | ẑt′ ) . The corresponding reward r̂t′+1 and next state ẑt′+1 are predicted by the learned world model . Given the imagined trajectories , the actor improves its policy by maximizing the λ-return ( Sutton & Barto , 2018 ; Schulman et al. , 2018 ) plus an entropy regularizer that encourages exploration , while the critic is trained to approximate the λ-return through a squared loss . 3 DREAMERPRO . To compute the DREAMER training objective , more specifically J tO in Equation 4 , a decoder is required to reconstruct the image observation ot from the state zt = [ ht , st ] . Because this reconstruction loss operates in pixel space where all pixels are weighted equally , DREAMER tends to allocate most of its capacity to modeling complex visual patterns that cover a large pixel area ( e.g. , backgrounds ) . This leads to poor task performance when those visual patterns are task irrelevant , as shown in previous work ( Nguyen et al. , 2021 ) . Fortunately , during policy learning , what we need is accurate reward and next state prediction , which are respectively encouraged by J tR and J tKL . In other words , the decoder is not required for policy learning . The main purpose of having the decoder and the associated loss J tO , as shown in DREAMER , is to learn meaningful representations that can not be obtained by J tR and J tKL alone . The above observations motivate us to improve robustness to visual distractions by replacing the reconstruction-based representation learning in DREAMER with reconstruction-free methods . For this , we take inspiration from recent developments in self-supervised image representation learning , which can be divided into contrastive ( van den Oord et al. , 2019 ; Chen et al. , 2020 ; He et al. , 2020 ) and non-contrastive ( Grill et al. , 2020 ; Caron et al. , 2020 ) methods . We prefer non-contrastive methods as they can be applied to small batch sizes . This can speed up both world model learning and policy learning ( in wall clock time ) . Therefore , we propose to combine DREAMER with the prototypical representations used in SWAV ( Caron et al. , 2020 ) , a top-performing non-contrastive representation learning method . We name the resulting model DREAMERPRO , and provide the model description in the following . DREAMERPRO uses the same policy learning algorithm as DREAMER , but learns the world model without reconstructing the observations . This is achieved by clustering the observation into a set of K trainable prototypes { c1 , . . . , cK } , and then predicting the cluster assignment from the state as well as an augmented view of the observation . See Figure 1 for an illustration . Concretely , given a sequence of observations o1 : T sampled from the replay buffer , we obtain two augmented views o ( 1 ) 1 : T , o ( 2 ) 1 : T by applying random shifts ( Laskin et al. , 2020b ; Yarats et al. , 2021c ) with bilinear interpolation ( Yarats et al. , 2021a ) . We ensure that the augmentation is consistent across time steps . Each view i ∈ { 1 , 2 } is fed to the RSSM to obtain the states z ( i ) 1 : T . To predict the cluster assignment from z ( i ) t , we first apply a linear projection followed by ` 2-normalization to obtain a vector x ( i ) t of the same dimension as the prototypes , and then take a softmax over the dot products of x ( i ) t and all the prototypes : ( u ( i ) t,1 , . . . , u ( i ) t , K ) = softmax ( x ( i ) t · c1 τ , . . . , x ( i ) t · cK τ ) . ( 5 ) < latexit sha1_base64= '' KrmYHDjyuqZmm4bzKsDv5hOoqUo= '' > AAAB9HicbVA9SwNBEN2LXzF+RS1tFoNgFe5SqJUEbCwjmA9IjrC3mUuW7O2du3OBcOR32FgoYuuPsfPfuEmu0MQHA4/3ZpiZFyRSGHTdb6ewsbm1vVPcLe3tHxwelY9PWiZONYcmj2WsOwEzIIWCJgqU0Ek0sCiQ0A7Gd3O/PQFtRKwecZqAH7GhEqHgDK3kN3QcsEBIgQJMv1xxq+4CdJ14OamQHI1++as3iHkagUIumTFdz03Qz5hGwSXMSr3UQML4mA2ha6liERg/Wxw9oxdWGdAw1rYU0oX6eyJjkTHTKLCdEcORWfXm4n9eN8Xwxs+ESlIExZeLwlRSjOk8AToQGjjKqSWMa/s5p3zENONocyrZELzVl9dJq1b1rqreQ61Sv83jKJIzck4uiUeuSZ3ckwZpEk6eyDN5JW/OxHlx3p2PZWvByWdOyR84nz8N2JJF < /latexit > Here , u ( i ) t , k is the predicted probability that state z ( i ) t maps to cluster k , τ is a temperature parameter , and the prototypes { c1 , . . . , cK } are also ` 2-normalized . Analogously , to predict the cluster assignment from an augmented observation o ( i ) t , we feed it to a convolutional encoder ( shared with the RSSM ) , apply a linear projection followed by ` 2- normalization , and obtain a vector y ( i ) t . We summarize this process as : y ( i ) t = fθ ( o ( i ) t ) , where θ collectively denotes the parameters of the convolutional encoder and the linear projection layer . The prediction probabilities are again given by a softmax : ( v ( i ) t,1 , . . . , v ( i ) t , K ) = softmax ( y ( i ) t · c1 τ , . . . , y ( i ) t · cK τ ) , ( 6 ) where v ( i ) t , k is the predicted probability that observation o ( i ) t maps to cluster k. To obtain the targets for the above two predictions ( i.e. , Equations 5 and 6 ) , we apply the SinkhornKnopp algorithm ( Cuturi , 2013 ) to the cluster assignment scores computed from the output of a momentum encoder fθ̄ ( He et al. , 2020 ; Grill et al. , 2020 ; Caron et al. , 2021 ) , whose parameters θ̄ are updated using the exponential moving average of θ : θ̄ ← ( 1 − η ) θ̄ + ηθ . For each observation o ( i ) t , the scores are given by the dot products ( ȳ ( i ) t · c1 , . . . , ȳ ( i ) t · cK ) , where ȳ ( i ) t = fθ̄ ( o ( i ) t ) is the momentum encoder output . The Sinkhorn-Knopp algorithm is applied to the two augmented batches { o ( 1 ) 1 : T } , { o ( 2 ) 1 : T } separately to encourage uniform cluster assignment within each augmented batch and avoid trivial solutions . We specifically choose the number of prototypes K = B × T , where B is the batch size , so that the observation embeddings are implicitly pushed apart from each other . The outcome of the Sinkhorn-Knopp algorithm is a set of cluster assignment targets ( w ( i ) t,1 , . . . , w ( i ) t , K ) for each observation o ( i ) t . Now that we have the cluster assignment predictions and targets , the representation learning objective is simply to maximize the prediction accuracies : J tSWAV = 1 2 K∑ k=1 ( w ( 1 ) t , k log v ( 2 ) t , k + w ( 2 ) t , k log v ( 1 ) t , k ) , ( 7 ) J tTemp = 1 2 K∑ k=1 ( w ( 1 ) t , k log u ( 1 ) t , k + w ( 2 ) t , k log u ( 2 ) t , k ) . ( 8 ) Here , J tSWAV improves prediction from an augmented view . This is the same loss as used in SWAV ( Caron et al. , 2020 ) , and is shown to induce useful features for static images . However , it ignores the temporal structure which is crucial in reinforcement learning . Hence , we add a second term , J tTemp , that improves prediction from the state of the same view . This has the effect of making the prototypes close to the states that summarize the past observations and actions , thereby distilling temporal structure into the prototypes . From another perspective , J tTemp is similar toJ tO in the sense that we are now ‘ reconstructing ’ the cluster assignment of the observation instead of the observation itself . This frees the world model from modeling complex visual details , allowing more capacity to be devoted to task-relevant features . The overall world model learning objective for DREAMERPRO can be obtained by replacing J tO in Equation 4 with J tSWAV + J tTemp : JDREAMERPRO = T∑ t=1 Eq [ J tSWAV + J tTemp + J tR − J tKL ] , ( 9 ) where J tR and J tKL are now averaged over the two augmented views . | This paper proposes DreamerPro, an extension to Dreamer where it swaps the reconstruction loss with a prototype learning loss based on SWAV. At each optimization step, DreamerPro augments each batch of observations into two using different augmentations. It uses the Sinkhorn-Knopp algorithm to compute the target clusters for each batch, with the goal of encouraging uniform clustering assignment within each augmented batch. Intuitively, the prototype learning loss rewards prediction accuracy both from across the views, which adapts from the original SWAV approach, and within the same view, which the authors mention help build temporal information into the learned prototypes. DreamerPro outperforms the original Dreamer on most of the tasks on the Deepmind Control benchmark, and drastically improves on the Deepmind Control benchmark with noisy backgrounds. | SP:007cfdff69f09c5edd1df48ad280a2d05cc9862a |
DreamerPro: Reconstruction-Free Model-Based Reinforcement Learning with Prototypical Representations | 1 INTRODUCTION . Model-Based Reinforcement Learning ( MBRL , Sutton & Barto , 2018 ; Sutton , 1991 ) provides a solution to many problems in contemporary reinforcement learning . It improves sample efficiency by training a policy through simulations of a learned world model . Learning a world model also provides a way to efficiently represent experience data as general knowledge simulatable and reusable in arbitrary downstream tasks . In addition , it allows accurate and safe decisions via planning . Among recent advances in image-based MBRL , DREAMER is particularly notable as the first MBRL model outperforming popular model-free RL algorithms with better sample efficiency in both continuous control ( Hafner et al. , 2020 ) and discrete control ( Hafner et al. , 2021 ) . Unlike some previous model-based RL methods ( Kaiser et al. , 2019 ) , it learns a world model that can be rolled out in a compact latent representation space instead of the high-dimensional observation space . Also , policy learning can be done efficiently via backpropagation through the differentiable dynamics model . In image-based RL , the key problem is to learn low-dimensional state representation and , in the model-based case , also its forward model . Although we can learn such representation directly by maximizing the rewards ( Schrittwieser et al. , 2020 ) , it is usually very slow to do this due to the reward sparsity . Instead , it is more practical to introduce auxiliary tasks providing richer learning signal to facilitate representation learning without reward ( or with sparse reward ) ( Sutton et al. , 2011 ; Jaderberg et al. , 2016 ) . DREAMER achieves this by learning the representation and the dynamics model in a way to reduce the reconstruction error of the observed sequences . However , reconstruction-based representation learning has limitations . First , it is computationally expensive to reconstruct the high-dimensional inputs , especially in models like DREAMER that needs to reconstruct long-range videos . Second , it wastes the representation capacity to learn even the visual signals that are irrelevant to the task or unpredictable such as noisy background ( Burda et al. , 2018 ) . Thus , in MBRL it is of particular interest to realize a version of DREAMER without reconstruction . Recently , there have been remarkable advances in reconstruction-free representation learning in reinforcement learning ( Laskin et al. , 2020a ; b ; Yarats et al. , 2021c ) . The currently dominant approach is via contrastive learning . This approach requires pair-wise comparisons to push apart different instances while pulling close an instance and its augmentation . Therefore , this method usually requires a large batch size ( so computationally expensive ) to perform accurately and robustly . An alternative is the clustering-based or prototype-based approach ( Caron et al. , 2020 ) . By learning a set of clusters represented by prototypes , it replaces the instance-wise comparison by a comparison to the clusters and thereby avoids the problems of contrastive learning . This approach is shown to perform more accurately and robustly in many applications ( Caron et al. , 2020 ; 2021 ; Yarats et al. , 2021b ) than the contrastive method while also alleviating the need for maintaining a large batch size . The prototype structure can also be used to implement an exploration method ( Yarats et al. , 2021b ) . However , for reconstruction-free MBRL only the contrastive approach like Temporal Predictive Coding ( TPC , Nguyen et al. , 2021 ) has been proposed so far . While TPC consistently outperforms DREAMER in the noisy background settings , for standard DeepMind Control suite ( Tassa et al. , 2018 ) it showed quite inconsistent results by performing severely worse than DREAMER on some tasks . Therefore , we hypothesize that this inconsistent behavior may be fixed if the robustness and accuracy of the prototypical representations can be realized in MBRL and further improved with the support of temporal information . In this paper , we propose a reconstruction-free MBRL agent , called DREAMERPRO , by combining the prototypical representation learning with temporal dynamics learning . Similar to SwAV ( Caron et al. , 2020 ) , by encouraging uniform cluster assignment across the batch , we implicitly pull apart the embeddings of different observations . Additionally , we let the temporal latent state to ‘ reconstruct ’ the cluster assignment of the observation , thereby relieving the world model from modeling lowlevel details . We evaluate our model on the standard setting of DeepMind Control suite , and also on a natural background setting , where the background is replaced by natural videos irrelevant to the task . The results show that the proposed model consistently outperforms previous methods . The contributions of the paper are ( 1 ) the first reconstruction-free MBRL agent based on the prototypical representation and its temporal dynamics and ( 2 ) the demonstration of the consistently improved accuracy and robustness of the proposed model in comparison to a contrastive reconstructionfree MBRL agent and Dreamer for both standard and natural background DMC tasks . 2 PRELIMINARIES . In this section , we briefly introduce the world model and learning algorithms used in DREAMERV2 ( Hafner et al. , 2021 ) which our model builds upon . To indicate the general DREAMER framework ( Hafner et al. , 2020 ; 2021 ) , we omit its version number in the rest of the paper . 2.1 RECONSTRUCTION-BASED WORLD MODEL LEARNING . DREAMER learns a recurrent state-space model ( RSSM , Hafner et al. , 2019 ) to predict forward dynamics and rewards in partially observable environments . At each time step t , the agent receives an image observation ot and a scalar reward rt ( obtained by previous actions a < t ) . The agent then chooses an action at based on its policy . The RSSM models the observations , rewards , and transitions through a probabilistic generative process : p ( o1 : T , r1 : T | a1 : T ) = ∫ T∏ t=1 p ( ot | s≤t , a < t ) p ( rt | s≤t , a < t ) p ( st | s < t , a < t ) ds1 : T ( 1 ) = ∫ T∏ t=1 p ( ot | ht , st ) p ( rt | ht , st ) p ( st | ht ) ds1 : T , ( 2 ) where the latent variables s1 : T are the agent states , and ht = GRU ( ht−1 , st−1 , at−1 ) is a deterministic encoding of s < t and a < t . To infer the agent states from past observations and actions , a variational encoder is introduced : q ( s1 : T | o1 : T , a1 : T ) = T∏ t=1 q ( st | s < t , a < t , ot ) = T∏ t=1 q ( st | ht , ot ) . ( 3 ) The training objective is to maximize the evidence lower bound ( ELBO ) : JDREAMER = T∑ t=1 Eq [ log p ( ot | ht , st ) ︸ ︷︷ ︸ J tO + log p ( rt | ht , st ) ︸ ︷︷ ︸ J tR −DKL ( q ( st | ht , ot ) ‖ p ( st | ht ) ) ︸ ︷︷ ︸ J tKL ] . ( 4 ) 2.2 POLICY LEARNING BY LATENT IMAGINATION . DREAMER interleaves policy learning with world model learning . During policy learning , the world model is fixed , and an actor and a critic are trained cooperatively from the latent trajectories imagined by the world model . Specifically , the imagination starts at each non-terminal state ẑt = [ ht , st ] encountered during world model learning . Then , at each imagination step t′ ≥ t , an action is sampled from the actor ’ s stochastic policy : ât′ ∼ π ( ât′ | ẑt′ ) . The corresponding reward r̂t′+1 and next state ẑt′+1 are predicted by the learned world model . Given the imagined trajectories , the actor improves its policy by maximizing the λ-return ( Sutton & Barto , 2018 ; Schulman et al. , 2018 ) plus an entropy regularizer that encourages exploration , while the critic is trained to approximate the λ-return through a squared loss . 3 DREAMERPRO . To compute the DREAMER training objective , more specifically J tO in Equation 4 , a decoder is required to reconstruct the image observation ot from the state zt = [ ht , st ] . Because this reconstruction loss operates in pixel space where all pixels are weighted equally , DREAMER tends to allocate most of its capacity to modeling complex visual patterns that cover a large pixel area ( e.g. , backgrounds ) . This leads to poor task performance when those visual patterns are task irrelevant , as shown in previous work ( Nguyen et al. , 2021 ) . Fortunately , during policy learning , what we need is accurate reward and next state prediction , which are respectively encouraged by J tR and J tKL . In other words , the decoder is not required for policy learning . The main purpose of having the decoder and the associated loss J tO , as shown in DREAMER , is to learn meaningful representations that can not be obtained by J tR and J tKL alone . The above observations motivate us to improve robustness to visual distractions by replacing the reconstruction-based representation learning in DREAMER with reconstruction-free methods . For this , we take inspiration from recent developments in self-supervised image representation learning , which can be divided into contrastive ( van den Oord et al. , 2019 ; Chen et al. , 2020 ; He et al. , 2020 ) and non-contrastive ( Grill et al. , 2020 ; Caron et al. , 2020 ) methods . We prefer non-contrastive methods as they can be applied to small batch sizes . This can speed up both world model learning and policy learning ( in wall clock time ) . Therefore , we propose to combine DREAMER with the prototypical representations used in SWAV ( Caron et al. , 2020 ) , a top-performing non-contrastive representation learning method . We name the resulting model DREAMERPRO , and provide the model description in the following . DREAMERPRO uses the same policy learning algorithm as DREAMER , but learns the world model without reconstructing the observations . This is achieved by clustering the observation into a set of K trainable prototypes { c1 , . . . , cK } , and then predicting the cluster assignment from the state as well as an augmented view of the observation . See Figure 1 for an illustration . Concretely , given a sequence of observations o1 : T sampled from the replay buffer , we obtain two augmented views o ( 1 ) 1 : T , o ( 2 ) 1 : T by applying random shifts ( Laskin et al. , 2020b ; Yarats et al. , 2021c ) with bilinear interpolation ( Yarats et al. , 2021a ) . We ensure that the augmentation is consistent across time steps . Each view i ∈ { 1 , 2 } is fed to the RSSM to obtain the states z ( i ) 1 : T . To predict the cluster assignment from z ( i ) t , we first apply a linear projection followed by ` 2-normalization to obtain a vector x ( i ) t of the same dimension as the prototypes , and then take a softmax over the dot products of x ( i ) t and all the prototypes : ( u ( i ) t,1 , . . . , u ( i ) t , K ) = softmax ( x ( i ) t · c1 τ , . . . , x ( i ) t · cK τ ) . ( 5 ) < latexit sha1_base64= '' KrmYHDjyuqZmm4bzKsDv5hOoqUo= '' > AAAB9HicbVA9SwNBEN2LXzF+RS1tFoNgFe5SqJUEbCwjmA9IjrC3mUuW7O2du3OBcOR32FgoYuuPsfPfuEmu0MQHA4/3ZpiZFyRSGHTdb6ewsbm1vVPcLe3tHxwelY9PWiZONYcmj2WsOwEzIIWCJgqU0Ek0sCiQ0A7Gd3O/PQFtRKwecZqAH7GhEqHgDK3kN3QcsEBIgQJMv1xxq+4CdJ14OamQHI1++as3iHkagUIumTFdz03Qz5hGwSXMSr3UQML4mA2ha6liERg/Wxw9oxdWGdAw1rYU0oX6eyJjkTHTKLCdEcORWfXm4n9eN8Xwxs+ESlIExZeLwlRSjOk8AToQGjjKqSWMa/s5p3zENONocyrZELzVl9dJq1b1rqreQ61Sv83jKJIzck4uiUeuSZ3ckwZpEk6eyDN5JW/OxHlx3p2PZWvByWdOyR84nz8N2JJF < /latexit > Here , u ( i ) t , k is the predicted probability that state z ( i ) t maps to cluster k , τ is a temperature parameter , and the prototypes { c1 , . . . , cK } are also ` 2-normalized . Analogously , to predict the cluster assignment from an augmented observation o ( i ) t , we feed it to a convolutional encoder ( shared with the RSSM ) , apply a linear projection followed by ` 2- normalization , and obtain a vector y ( i ) t . We summarize this process as : y ( i ) t = fθ ( o ( i ) t ) , where θ collectively denotes the parameters of the convolutional encoder and the linear projection layer . The prediction probabilities are again given by a softmax : ( v ( i ) t,1 , . . . , v ( i ) t , K ) = softmax ( y ( i ) t · c1 τ , . . . , y ( i ) t · cK τ ) , ( 6 ) where v ( i ) t , k is the predicted probability that observation o ( i ) t maps to cluster k. To obtain the targets for the above two predictions ( i.e. , Equations 5 and 6 ) , we apply the SinkhornKnopp algorithm ( Cuturi , 2013 ) to the cluster assignment scores computed from the output of a momentum encoder fθ̄ ( He et al. , 2020 ; Grill et al. , 2020 ; Caron et al. , 2021 ) , whose parameters θ̄ are updated using the exponential moving average of θ : θ̄ ← ( 1 − η ) θ̄ + ηθ . For each observation o ( i ) t , the scores are given by the dot products ( ȳ ( i ) t · c1 , . . . , ȳ ( i ) t · cK ) , where ȳ ( i ) t = fθ̄ ( o ( i ) t ) is the momentum encoder output . The Sinkhorn-Knopp algorithm is applied to the two augmented batches { o ( 1 ) 1 : T } , { o ( 2 ) 1 : T } separately to encourage uniform cluster assignment within each augmented batch and avoid trivial solutions . We specifically choose the number of prototypes K = B × T , where B is the batch size , so that the observation embeddings are implicitly pushed apart from each other . The outcome of the Sinkhorn-Knopp algorithm is a set of cluster assignment targets ( w ( i ) t,1 , . . . , w ( i ) t , K ) for each observation o ( i ) t . Now that we have the cluster assignment predictions and targets , the representation learning objective is simply to maximize the prediction accuracies : J tSWAV = 1 2 K∑ k=1 ( w ( 1 ) t , k log v ( 2 ) t , k + w ( 2 ) t , k log v ( 1 ) t , k ) , ( 7 ) J tTemp = 1 2 K∑ k=1 ( w ( 1 ) t , k log u ( 1 ) t , k + w ( 2 ) t , k log u ( 2 ) t , k ) . ( 8 ) Here , J tSWAV improves prediction from an augmented view . This is the same loss as used in SWAV ( Caron et al. , 2020 ) , and is shown to induce useful features for static images . However , it ignores the temporal structure which is crucial in reinforcement learning . Hence , we add a second term , J tTemp , that improves prediction from the state of the same view . This has the effect of making the prototypes close to the states that summarize the past observations and actions , thereby distilling temporal structure into the prototypes . From another perspective , J tTemp is similar toJ tO in the sense that we are now ‘ reconstructing ’ the cluster assignment of the observation instead of the observation itself . This frees the world model from modeling complex visual details , allowing more capacity to be devoted to task-relevant features . The overall world model learning objective for DREAMERPRO can be obtained by replacing J tO in Equation 4 with J tSWAV + J tTemp : JDREAMERPRO = T∑ t=1 Eq [ J tSWAV + J tTemp + J tR − J tKL ] , ( 9 ) where J tR and J tKL are now averaged over the two augmented views . | The paper presents DreamerPro, a method for learning a latent dynamics model from image observations without a pixel-based reconstruction loss. The model combines the clustering approach of SwAV with an additional temporal consistency loss. Experimental results show improved performance over baselines in distraction-free and natural-video-background settings on DeepMind Control Suite tasks. | SP:007cfdff69f09c5edd1df48ad280a2d05cc9862a |
DreamerPro: Reconstruction-Free Model-Based Reinforcement Learning with Prototypical Representations | 1 INTRODUCTION . Model-Based Reinforcement Learning ( MBRL , Sutton & Barto , 2018 ; Sutton , 1991 ) provides a solution to many problems in contemporary reinforcement learning . It improves sample efficiency by training a policy through simulations of a learned world model . Learning a world model also provides a way to efficiently represent experience data as general knowledge simulatable and reusable in arbitrary downstream tasks . In addition , it allows accurate and safe decisions via planning . Among recent advances in image-based MBRL , DREAMER is particularly notable as the first MBRL model outperforming popular model-free RL algorithms with better sample efficiency in both continuous control ( Hafner et al. , 2020 ) and discrete control ( Hafner et al. , 2021 ) . Unlike some previous model-based RL methods ( Kaiser et al. , 2019 ) , it learns a world model that can be rolled out in a compact latent representation space instead of the high-dimensional observation space . Also , policy learning can be done efficiently via backpropagation through the differentiable dynamics model . In image-based RL , the key problem is to learn low-dimensional state representation and , in the model-based case , also its forward model . Although we can learn such representation directly by maximizing the rewards ( Schrittwieser et al. , 2020 ) , it is usually very slow to do this due to the reward sparsity . Instead , it is more practical to introduce auxiliary tasks providing richer learning signal to facilitate representation learning without reward ( or with sparse reward ) ( Sutton et al. , 2011 ; Jaderberg et al. , 2016 ) . DREAMER achieves this by learning the representation and the dynamics model in a way to reduce the reconstruction error of the observed sequences . However , reconstruction-based representation learning has limitations . First , it is computationally expensive to reconstruct the high-dimensional inputs , especially in models like DREAMER that needs to reconstruct long-range videos . Second , it wastes the representation capacity to learn even the visual signals that are irrelevant to the task or unpredictable such as noisy background ( Burda et al. , 2018 ) . Thus , in MBRL it is of particular interest to realize a version of DREAMER without reconstruction . Recently , there have been remarkable advances in reconstruction-free representation learning in reinforcement learning ( Laskin et al. , 2020a ; b ; Yarats et al. , 2021c ) . The currently dominant approach is via contrastive learning . This approach requires pair-wise comparisons to push apart different instances while pulling close an instance and its augmentation . Therefore , this method usually requires a large batch size ( so computationally expensive ) to perform accurately and robustly . An alternative is the clustering-based or prototype-based approach ( Caron et al. , 2020 ) . By learning a set of clusters represented by prototypes , it replaces the instance-wise comparison by a comparison to the clusters and thereby avoids the problems of contrastive learning . This approach is shown to perform more accurately and robustly in many applications ( Caron et al. , 2020 ; 2021 ; Yarats et al. , 2021b ) than the contrastive method while also alleviating the need for maintaining a large batch size . The prototype structure can also be used to implement an exploration method ( Yarats et al. , 2021b ) . However , for reconstruction-free MBRL only the contrastive approach like Temporal Predictive Coding ( TPC , Nguyen et al. , 2021 ) has been proposed so far . While TPC consistently outperforms DREAMER in the noisy background settings , for standard DeepMind Control suite ( Tassa et al. , 2018 ) it showed quite inconsistent results by performing severely worse than DREAMER on some tasks . Therefore , we hypothesize that this inconsistent behavior may be fixed if the robustness and accuracy of the prototypical representations can be realized in MBRL and further improved with the support of temporal information . In this paper , we propose a reconstruction-free MBRL agent , called DREAMERPRO , by combining the prototypical representation learning with temporal dynamics learning . Similar to SwAV ( Caron et al. , 2020 ) , by encouraging uniform cluster assignment across the batch , we implicitly pull apart the embeddings of different observations . Additionally , we let the temporal latent state to ‘ reconstruct ’ the cluster assignment of the observation , thereby relieving the world model from modeling lowlevel details . We evaluate our model on the standard setting of DeepMind Control suite , and also on a natural background setting , where the background is replaced by natural videos irrelevant to the task . The results show that the proposed model consistently outperforms previous methods . The contributions of the paper are ( 1 ) the first reconstruction-free MBRL agent based on the prototypical representation and its temporal dynamics and ( 2 ) the demonstration of the consistently improved accuracy and robustness of the proposed model in comparison to a contrastive reconstructionfree MBRL agent and Dreamer for both standard and natural background DMC tasks . 2 PRELIMINARIES . In this section , we briefly introduce the world model and learning algorithms used in DREAMERV2 ( Hafner et al. , 2021 ) which our model builds upon . To indicate the general DREAMER framework ( Hafner et al. , 2020 ; 2021 ) , we omit its version number in the rest of the paper . 2.1 RECONSTRUCTION-BASED WORLD MODEL LEARNING . DREAMER learns a recurrent state-space model ( RSSM , Hafner et al. , 2019 ) to predict forward dynamics and rewards in partially observable environments . At each time step t , the agent receives an image observation ot and a scalar reward rt ( obtained by previous actions a < t ) . The agent then chooses an action at based on its policy . The RSSM models the observations , rewards , and transitions through a probabilistic generative process : p ( o1 : T , r1 : T | a1 : T ) = ∫ T∏ t=1 p ( ot | s≤t , a < t ) p ( rt | s≤t , a < t ) p ( st | s < t , a < t ) ds1 : T ( 1 ) = ∫ T∏ t=1 p ( ot | ht , st ) p ( rt | ht , st ) p ( st | ht ) ds1 : T , ( 2 ) where the latent variables s1 : T are the agent states , and ht = GRU ( ht−1 , st−1 , at−1 ) is a deterministic encoding of s < t and a < t . To infer the agent states from past observations and actions , a variational encoder is introduced : q ( s1 : T | o1 : T , a1 : T ) = T∏ t=1 q ( st | s < t , a < t , ot ) = T∏ t=1 q ( st | ht , ot ) . ( 3 ) The training objective is to maximize the evidence lower bound ( ELBO ) : JDREAMER = T∑ t=1 Eq [ log p ( ot | ht , st ) ︸ ︷︷ ︸ J tO + log p ( rt | ht , st ) ︸ ︷︷ ︸ J tR −DKL ( q ( st | ht , ot ) ‖ p ( st | ht ) ) ︸ ︷︷ ︸ J tKL ] . ( 4 ) 2.2 POLICY LEARNING BY LATENT IMAGINATION . DREAMER interleaves policy learning with world model learning . During policy learning , the world model is fixed , and an actor and a critic are trained cooperatively from the latent trajectories imagined by the world model . Specifically , the imagination starts at each non-terminal state ẑt = [ ht , st ] encountered during world model learning . Then , at each imagination step t′ ≥ t , an action is sampled from the actor ’ s stochastic policy : ât′ ∼ π ( ât′ | ẑt′ ) . The corresponding reward r̂t′+1 and next state ẑt′+1 are predicted by the learned world model . Given the imagined trajectories , the actor improves its policy by maximizing the λ-return ( Sutton & Barto , 2018 ; Schulman et al. , 2018 ) plus an entropy regularizer that encourages exploration , while the critic is trained to approximate the λ-return through a squared loss . 3 DREAMERPRO . To compute the DREAMER training objective , more specifically J tO in Equation 4 , a decoder is required to reconstruct the image observation ot from the state zt = [ ht , st ] . Because this reconstruction loss operates in pixel space where all pixels are weighted equally , DREAMER tends to allocate most of its capacity to modeling complex visual patterns that cover a large pixel area ( e.g. , backgrounds ) . This leads to poor task performance when those visual patterns are task irrelevant , as shown in previous work ( Nguyen et al. , 2021 ) . Fortunately , during policy learning , what we need is accurate reward and next state prediction , which are respectively encouraged by J tR and J tKL . In other words , the decoder is not required for policy learning . The main purpose of having the decoder and the associated loss J tO , as shown in DREAMER , is to learn meaningful representations that can not be obtained by J tR and J tKL alone . The above observations motivate us to improve robustness to visual distractions by replacing the reconstruction-based representation learning in DREAMER with reconstruction-free methods . For this , we take inspiration from recent developments in self-supervised image representation learning , which can be divided into contrastive ( van den Oord et al. , 2019 ; Chen et al. , 2020 ; He et al. , 2020 ) and non-contrastive ( Grill et al. , 2020 ; Caron et al. , 2020 ) methods . We prefer non-contrastive methods as they can be applied to small batch sizes . This can speed up both world model learning and policy learning ( in wall clock time ) . Therefore , we propose to combine DREAMER with the prototypical representations used in SWAV ( Caron et al. , 2020 ) , a top-performing non-contrastive representation learning method . We name the resulting model DREAMERPRO , and provide the model description in the following . DREAMERPRO uses the same policy learning algorithm as DREAMER , but learns the world model without reconstructing the observations . This is achieved by clustering the observation into a set of K trainable prototypes { c1 , . . . , cK } , and then predicting the cluster assignment from the state as well as an augmented view of the observation . See Figure 1 for an illustration . Concretely , given a sequence of observations o1 : T sampled from the replay buffer , we obtain two augmented views o ( 1 ) 1 : T , o ( 2 ) 1 : T by applying random shifts ( Laskin et al. , 2020b ; Yarats et al. , 2021c ) with bilinear interpolation ( Yarats et al. , 2021a ) . We ensure that the augmentation is consistent across time steps . Each view i ∈ { 1 , 2 } is fed to the RSSM to obtain the states z ( i ) 1 : T . To predict the cluster assignment from z ( i ) t , we first apply a linear projection followed by ` 2-normalization to obtain a vector x ( i ) t of the same dimension as the prototypes , and then take a softmax over the dot products of x ( i ) t and all the prototypes : ( u ( i ) t,1 , . . . , u ( i ) t , K ) = softmax ( x ( i ) t · c1 τ , . . . , x ( i ) t · cK τ ) . ( 5 ) < latexit sha1_base64= '' KrmYHDjyuqZmm4bzKsDv5hOoqUo= '' > AAAB9HicbVA9SwNBEN2LXzF+RS1tFoNgFe5SqJUEbCwjmA9IjrC3mUuW7O2du3OBcOR32FgoYuuPsfPfuEmu0MQHA4/3ZpiZFyRSGHTdb6ewsbm1vVPcLe3tHxwelY9PWiZONYcmj2WsOwEzIIWCJgqU0Ek0sCiQ0A7Gd3O/PQFtRKwecZqAH7GhEqHgDK3kN3QcsEBIgQJMv1xxq+4CdJ14OamQHI1++as3iHkagUIumTFdz03Qz5hGwSXMSr3UQML4mA2ha6liERg/Wxw9oxdWGdAw1rYU0oX6eyJjkTHTKLCdEcORWfXm4n9eN8Xwxs+ESlIExZeLwlRSjOk8AToQGjjKqSWMa/s5p3zENONocyrZELzVl9dJq1b1rqreQ61Sv83jKJIzck4uiUeuSZ3ckwZpEk6eyDN5JW/OxHlx3p2PZWvByWdOyR84nz8N2JJF < /latexit > Here , u ( i ) t , k is the predicted probability that state z ( i ) t maps to cluster k , τ is a temperature parameter , and the prototypes { c1 , . . . , cK } are also ` 2-normalized . Analogously , to predict the cluster assignment from an augmented observation o ( i ) t , we feed it to a convolutional encoder ( shared with the RSSM ) , apply a linear projection followed by ` 2- normalization , and obtain a vector y ( i ) t . We summarize this process as : y ( i ) t = fθ ( o ( i ) t ) , where θ collectively denotes the parameters of the convolutional encoder and the linear projection layer . The prediction probabilities are again given by a softmax : ( v ( i ) t,1 , . . . , v ( i ) t , K ) = softmax ( y ( i ) t · c1 τ , . . . , y ( i ) t · cK τ ) , ( 6 ) where v ( i ) t , k is the predicted probability that observation o ( i ) t maps to cluster k. To obtain the targets for the above two predictions ( i.e. , Equations 5 and 6 ) , we apply the SinkhornKnopp algorithm ( Cuturi , 2013 ) to the cluster assignment scores computed from the output of a momentum encoder fθ̄ ( He et al. , 2020 ; Grill et al. , 2020 ; Caron et al. , 2021 ) , whose parameters θ̄ are updated using the exponential moving average of θ : θ̄ ← ( 1 − η ) θ̄ + ηθ . For each observation o ( i ) t , the scores are given by the dot products ( ȳ ( i ) t · c1 , . . . , ȳ ( i ) t · cK ) , where ȳ ( i ) t = fθ̄ ( o ( i ) t ) is the momentum encoder output . The Sinkhorn-Knopp algorithm is applied to the two augmented batches { o ( 1 ) 1 : T } , { o ( 2 ) 1 : T } separately to encourage uniform cluster assignment within each augmented batch and avoid trivial solutions . We specifically choose the number of prototypes K = B × T , where B is the batch size , so that the observation embeddings are implicitly pushed apart from each other . The outcome of the Sinkhorn-Knopp algorithm is a set of cluster assignment targets ( w ( i ) t,1 , . . . , w ( i ) t , K ) for each observation o ( i ) t . Now that we have the cluster assignment predictions and targets , the representation learning objective is simply to maximize the prediction accuracies : J tSWAV = 1 2 K∑ k=1 ( w ( 1 ) t , k log v ( 2 ) t , k + w ( 2 ) t , k log v ( 1 ) t , k ) , ( 7 ) J tTemp = 1 2 K∑ k=1 ( w ( 1 ) t , k log u ( 1 ) t , k + w ( 2 ) t , k log u ( 2 ) t , k ) . ( 8 ) Here , J tSWAV improves prediction from an augmented view . This is the same loss as used in SWAV ( Caron et al. , 2020 ) , and is shown to induce useful features for static images . However , it ignores the temporal structure which is crucial in reinforcement learning . Hence , we add a second term , J tTemp , that improves prediction from the state of the same view . This has the effect of making the prototypes close to the states that summarize the past observations and actions , thereby distilling temporal structure into the prototypes . From another perspective , J tTemp is similar toJ tO in the sense that we are now ‘ reconstructing ’ the cluster assignment of the observation instead of the observation itself . This frees the world model from modeling complex visual details , allowing more capacity to be devoted to task-relevant features . The overall world model learning objective for DREAMERPRO can be obtained by replacing J tO in Equation 4 with J tSWAV + J tTemp : JDREAMERPRO = T∑ t=1 Eq [ J tSWAV + J tTemp + J tR − J tKL ] , ( 9 ) where J tR and J tKL are now averaged over the two augmented views . | The paper proposes DreamerPro, a clustering based (i.e. prototype-based) version of Dreamer, which learns the latent representations by prototypical representation learning instead of image reconstruction. In other words, the proposed method is Dreamer without reconstruction replaced by SwAV template prototypical method. The authors test their method on a subset of six DeepMind Control tasks from pixels, with an without distracting backgrounds, to demonstrate that it is capable of outperforming Dreamer and TPC in almost all cases. | SP:007cfdff69f09c5edd1df48ad280a2d05cc9862a |
ZeroSARAH: Efficient Nonconvex Finite-Sum Optimization with Zero Full Gradient Computations | ∑n i=1 fi ( x ) . To the best of our knowledge , in this noncon- vex finite-sum regime , all existing variance-reduced methods , including SARAH , SVRG , SAGA and their variants , need to compute the full gradient over all n data samples at the initial point x0 , and then periodically compute the full gradient once every few iterations ( for SVRG , SARAH and their variants ) . Note that SVRG , SAGA and their variants typically achieve weaker convergence results than variants of SARAH : n2/3/ 2 vs. n1/2/ 2 . Thus we focus on the variant of SARAH . The proposed ZeroSARAH and its distributed variant D-ZeroSARAH are the first variance-reduced algorithms which do not require any full gradient computations , not even for the initial point . Moreover , for both standard and distributed settings , we show that ZeroSARAH and D-ZeroSARAH obtain new state-of-the-art convergence results , which can improve the previous best-known result ( given by e.g. , SPIDER , SARAH , and PAGE ) in certain regimes . Avoiding any full gradient computations ( which are time-consuming steps ) is important in many applications as the number of data samples n usually is very large . Especially in the distributed setting , periodic computation of full gradient over all data samples needs to periodically synchronize all clients/devices/machines , which may be impossible or unaffordable . Thus , we expect that ZeroSARAH/D-ZeroSARAH will have a practical impact in distributed and federated learning where full device participation is impractical . 1 INTRODUCTION . Nonconvex optimization is ubiquitous across many domains of machine learning ( Jain & Kar , 2017 ) , especially in training deep neural networks . In this paper , we consider the nonconvex finite-sum problems of the form min x∈Rd { f ( x ) : = 1 n n∑ i=1 fi ( x ) } , ( 1 ) where f : Rd → R is a differentiable and possibly nonconvex function . Problem ( 1 ) captures the standard empirical risk minimization problems in machine learning ( Shalev-Shwartz & Ben-David , 2014 ) . There are n data samples and fi denotes the loss associated with i-th data sample . We assume the functions fi : Rd → R for all i ∈ [ n ] : = { 1 , 2 , . . . , n } are also differentiable and possibly nonconvex functions . Beyond the standard/centralized problem ( 1 ) , we further consider the distributed/federated nonconvex problems : min x∈Rd { f ( x ) : = 1 n n∑ i=1 fi ( x ) } , fi ( x ) : = 1 m m∑ j=1 fi , j ( x ) , ( 2 ) where n denotes the number of clients/devices/machines , fi denotes the loss associated with m data samples stored on client i , and all functions are differentiable and can be nonconvex . Avoiding any full gradient computations is important especially in this distributed setting ( 2 ) , periodic computation of full gradient over all data samples needs to periodically synchronize all clients , which may be impossible or very hard to achieve . There has been extensive research in designing first-order ( gradient-type ) methods for solving centralized/distributed nonconvex problems ( 1 ) and ( 2 ) such as SGD , SVRG , SAGA , SCSG , SARAH and their variants , e.g. , ( Ghadimi & Lan , 2013 ; Ghadimi et al. , 2016 ; Allen-Zhu & Hazan , 2016 ; Reddi et al. , 2016 ; Lei et al. , 2017 ; Li & Li , 2018 ; Zhou et al. , 2018 ; Fang et al. , 2018 ; Wang et al. , 2018 ; Ge et al. , 2019 ; Pham et al. , 2019 ; Li , 2019 ; Li & Richtárik , 2020 ; Horváth et al. , 2020 ; Li et al. , 2021 ) . Note that SVRG and SAGA variants typically achieve weaker convergence results than SARAH variants , i.e. , n2/3/ 2 vs. √ n/ 2 . Thus the current best convergence results are achieved by SARAH variants such as SPIDER ( Fang et al. , 2018 ) , SARAH ( Pham et al. , 2019 ) and PAGE ( Li et al. , 2021 ; Li , 2021 ) . However , all of these variance-reduced algorithms ( no matter based on SVRG , SAGA or SARAH ) require full gradient computations ( i.e. , compute ∇f ( x ) = 1n ∑n i=1∇fi ( x ) ) without assuming additional assumptions except standard L-smoothness assumptions . We would like to point out that under an additional bounded variance assumption ( e.g. , Ei [ ‖∇fi ( x ) −∇f ( x ) ‖2 ] ≤ σ2 , ∀x ∈ Rd ) , some of them ( such as SCSG ( Lei et al. , 2017 ) , SVRG+ ( Li & Li , 2018 ) , PAGE ( Li et al. , 2021 ) ) may avoid full gradient computations by using a large minibatch of stochastic gradients instead ( usually the minibatch size is O ( σ2/ 2 ) ) . Clearly , there exist some drawbacks : i ) σ2 usually is not known ; ii ) if the target error is very small ( defined as E [ ‖∇f ( x̂ ) ‖2 ] ≤ 2 in Definition 1 ) or σ is very large , then the minibatch size O ( σ2/ 2 ) is still very large for replacing full gradient computations . In this paper , we only consider algorithms under the standard L-smoothness assumptions , without assuming any other additional assumptions ( such as bounded variance assumption mentioned above ) . Thus , all existing variance-reduced methods , including SARAH , SVRG , SAGA and their variants , need to compute the full gradient over all n data samples at the initial point x0 , and then periodically compute the full gradient once every few iterations ( for SVRG , SARAH and their variants ) . However , full gradient computations are time-consuming steps in many applications as the number of data samples n usually is very large . Especially in the distributed setting , periodic computation of full gradient needs to periodically synchronize all clients/devices , which usually is impractical . Motivated by this , we focus on designing new algorithms which do not require any full gradient computations for solving standard and distributed nonconvex problems ( 1 ) – ( 2 ) . 2 OUR CONTRIBUTIONS . In this paper , we propose the first variance-reduced algorithm ZeroSARAH ( and also its distributed variant D-ZeroSARAH ) without computing any full gradients for solving both standard and distributed nonconvex finite-sum problems ( 1 ) – ( 2 ) . Moreover , ZeroSARAH and Distributed D-ZeroSARAH can obtain new state-of-the-art convergence results which improve previous bestknown results ( given by e.g. , SPIDER , SARAH and PAGE ) in certain regimes ( see Tables 1–2 for the comparison with previous algorithms ) . ZeroSARAH is formally described in Algorithm 2 , which is a variant of SARAH ( Nguyen et al. , 2017 ) . See Section 4 for more details and comparisons between ZeroSARAH and SARAH . Then , D-ZeroSARAH is formally described in Algorithm 3 of Section 5 , which is a distributed variant of our ZeroSARAH . Now , we highlight the following results achieved by ZeroSARAH and D-ZeroSARAH : • ZeroSARAH and D-ZeroSARAH are the first variance-reduced algorithms which do not require any full gradient computations , not even for the initial point ( see Algorithms 2–3 or Tables 1–2 ) . Avoiding any full gradient computations is important in many applications as the number of data samples n usually is very large . Especially in the distributed setting , periodic computation of full gradient over all data samples stored in all clients/devices may be impossible or very hard to achieve . We expect that ZeroSARAH/D-ZeroSARAH will have a practical impact in distributed and federated learning where full device participation is impractical . • Moreover , ZeroSARAH can recover the previous best-known convergence result O ( n + √ nL∆0 2 ) ( see Table 1 or Corollary 1 ) , and also provide new state-of-the-art convergence results without any full gradient computations ( see Table 1 or Corollary 2 ) which can improve the previous best result in certain regimes . • Besides , for the distributed nonconvex setting ( 2 ) , the distributed D-ZeroSARAH ( Algorithm 3 ) enjoys similar benefits as our ZeroSARAH , i.e. , D-ZeroSARAH does not need to periodically synchronize all n clients to compute any full gradients , and also provides new state-of-the-art convergence results . See Table 2 and Section 5 for more details . • Finally , the experimental results in Section 6 show that ZeroSARAH is slightly better than the previous state-of-the-art SARAH . However , we should point out that ZeroSARAH does not compute any full gradients while SARAH needs to periodically compute the full gradients for every l iterations ( here l = √ n ) . Thus the experiments validate our theoretical results ( can be slightly better than SARAH ( see Table 1 ) ) and confirm the practical superiority of ZeroSARAH ( avoid any full gradient computations ) . Similar experimental results of D-ZeroSARAH for the distributed setting are provided in Appendix A.2 . 3 PRELIMINARIES . Notation : Let [ n ] denote the set { 1 , 2 , · · · , n } and ‖ · ‖ denote the Euclidean norm for a vector and the spectral norm for a matrix . Let 〈u , v〉 denote the inner product of two vectors u and v. We use O ( · ) and Ω ( · ) to hide the absolute constant , and Õ ( · ) to hide the logarithmic factor . We will write ∆0 : = f ( x0 ) − f∗ , f∗ : = minx∈Rd f ( x ) , G0 : = 1n ∑n i=1 ‖∇fi ( x0 ) ‖2 , ∆̂0 : = f ( x0 ) − f̂∗ , f̂∗ : = 1n ∑n i=1 minx∈Rd fi ( x ) and G ′ 0 : = 1 nm ∑n , m i , j=1,1 ‖∇fi , j ( x0 ) ‖2 . Definition 1 A point x̂ is called an -approximate solution for nonconvex problems ( 1 ) and ( 2 ) if E [ ‖∇f ( x̂ ) ‖2 ] ≤ 2 . To show the convergence results , we assume the following standard smoothness assumption for nonconvex problems ( 1 ) . Assumption 1 ( L-smoothness ) A function fi : Rd → R is L-smooth if ∃L > 0 , such that ‖∇fi ( x ) −∇fi ( y ) ‖ ≤ L‖x− y‖ , ∀x , y ∈ Rd . ( 3 ) It is easy to see that f ( x ) = 1n ∑n i=1 fi ( x ) is also L-smooth under Assumption 1 . We can also relax Assumption 1 by defining Li-smoothness for each fi . Then if we further define the average L2 : = 1n ∑n i=1 L 2 i , we know that f ( x ) = 1 n ∑n i=1 fi ( x ) is also L-smooth . Here we use the same L just for simple representation . For the distributed nonconvex problems ( 2 ) , we use the following Assumption 2 instead of Assumption 1 . Similarly , we can also relax it by defining Li , j-smoothness for different fi , j . Here we use the same L just for simple representation . Assumption 2 ( L-smoothness ) A function fi , j : Rd → R is L-smooth if ∃L > 0 , such that ‖∇fi , j ( x ) −∇fi , j ( y ) ‖ ≤ L‖x− y‖ , ∀x , y ∈ Rd . ( 4 ) Algorithm 1 SARAH ( Nguyen et al. , 2017 ; Pham et al. , 2019 ) Input : initial point x0 , epoch length l , stepsize η , minibatch size b 1 : x̃ = x0 2 : for s = 0 , 1 , 2 , . . . do 3 : x0 = x̃ 4 : v0 = ∇f ( x0 ) = 1n n∑ i=1 ∇fi ( x0 ) // compute the full gradient once for every l iterations 5 : x1 = x0 − ηv0 6 : for k = 1 , 2 , . . . , l do 7 : Randomly sample a minibatch data samples Ib with |Ib| = b 8 : vk = 1b ∑ i∈Ib ( ∇fi ( xk ) −∇fi ( xk−1 ) ) + vk−1 9 : xk+1 = xk − ηvk 10 : end for 11 : x̃ randomly chosen from { xk } k∈ [ l ] or x̃ = xl+1 12 : end for Algorithm 2 SARAH without full gradient computations ( ZeroSARAH ) Input : initial point x0 , stepsize { ηk } , minibatch size { bk } , parameter { λk } 1 : x−1 = x0 2 : v−1 = 0 , y−11 = y −1 2 = · · · = y−1n = 0 // no full gradient computation 3 : for k = 0 , 1 , 2 , . . . do 4 : Randomly sample a minibatch data samples Ikb with |Ikb | = bk 5 : vk = 1bk ∑ i∈Ikb ( ∇fi ( xk ) −∇fi ( xk−1 ) ) + ( 1− λk ) vk−1 + λk ( 1 bk ∑ i∈Ikb ( ∇fi ( xk−1 ) − yk−1i ) + 1n n∑ j=1 yk−1j ) // no full gradient computations for vks 6 : xk+1 = xk − ηkvk 7 : yki = { ∇fi ( xk ) for i ∈ Ikb yk−1i for i /∈ Ikb // the update of { yki } directly follows from the stochastic gradients computed in Line 5 8 : end for 4 ZeroSARAH ALGORITHM AND ITS CONVERGENCE RESULTS In this section , we consider the standard/centralized nonconvex problems ( 1 ) . The distributed setting ( 2 ) is considered in the following Section 5 . 4.1 ZeroSARAH ALGORITHM We first describe the proposed ZeroSARAH in Algorithm 2 , which is a variant of SARAH ( Nguyen et al. , 2017 ) . To better compare with SARAH and ZeroSARAH , we also recall the original SARAH in Algorithm 1 . Now , we highlight some points for the difference between SARAH and our ZeroSARAH : • SARAH requires the full gradient computations for every epoch ( see Line 4 of Algorithm 1 ) . However , ZeroSARAH combines the past gradient estimator vk−1 with another estimator to avoid periodically computing the full gradient . See the difference between Line 8 of Algorithm 1 and Line 5 of Algorithm 2 ( also highlighted with blue color ) . • The gradient estimator vk in ZeroSARAH ( Line 5 of Algorithm 2 ) does not require more stochastic gradient computations compared with vk in SARAH ( Line 8 of Algorithm 1 ) if the minibatch size bk = b . • The new gradient estimator vk of ZeroSARAH also leads to simpler algorithmic structure , i.e. , single-loop in ZeroSARAH vs. double-loop in SARAH . •Moreover , the difference of gradient estimator vk also leads to different results in expectation , i.e. , 1 ) for SARAH : Ek [ vk −∇f ( xk ) ] = vk−1 −∇f ( xk−1 ) ; 2 ) for ZeroSARAH : Ek [ vk −∇f ( xk ) ] = ( 1− λk ) ( vk−1 −∇f ( xk−1 ) ) . 4.2 CONVERGENCE RESULTS FOR ZeroSARAH Now , we present the main convergence theorem ( Theorem 1 ) of ZeroSARAH ( Algorithm 2 ) for solving nonconvex finite-sum problems ( 1 ) . Subsequently , we formulate two corollaries which present the detailed convergence results by specifying the choice of parameters . In particular , we list the results of these two Corollaries 1–2 in Table 1 for comparing with convergence results of previous works . Theorem 1 Suppose that Assumption 1 holds . Choose stepsize ηk ≤ 1 L ( 1+ √ Mk+1 ) for any k ≥ 0 , where Mk+1 : = 2λk+1bk+1 + 8λk+1n 2 b3k+1 . Moreover , let λ0 = 1 , γ0 ≥ η02λ1 and α0 ≥ 2nλ1η0 b21 . Then the following equation holds for ZeroSARAH ( Algorithm 2 ) for solving problem ( 1 ) , for any iteration K ≥ 0 : E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2∆0∑K−1 k=0 ηk + ( n− b0 ) ( 4γ0 + 2α0b0 ) G0 nb0 ∑K−1 k=0 ηk . ( 5 ) Remark : Note that we can upper bound both terms on the right-hand side of ( 5 ) . It means that there is no convergence neighborhood of ZeroSARAH and hence , ZeroSARAH can find an -approximate solution for any > 0 . In the following , we provide two detailed convergence results in Corollaries 1 and 2 by specifying two kinds of parameter settings . Note that the algorithm computes full gradient in iteration k if the minibatch bk = n. Our convergence results show that without computing any full gradients actually does not hurt the convergence performance of algorithms ( see Table 1 ) . In particular , we note that the second term of ( 5 ) will be deleted if we choose minibatch size b0 = n for the initial point x0 ( see Corollary 1 for more details ) . Here Corollary 1 only needs to compute the full gradient once for the initialization , and does not compute any full gradients later ( i.e. , bk ≡ √ n for all k > 0 ) . Also note that even if we choose b0 < n , we can also upper bound the second term of ( 5 ) . It means that ZeroSARAH can find an -approximate solution without computing any full gradients even for the initial point , i.e. , minibatch size bk < n for all iterations k ≥ 0 . For instance , we choose bk ≡ √ n for all k ≥ 0 in Corollary 2 , i.e. , ZeroSARAH never computes any full gradients even for the initial point . Corollary 1 Suppose that Assumption 1 holds . Choose stepsize ηk ≤ 1 ( 1+√8 ) L for any k ≥ 0 , minibatch size bk ≡ √ n and parameter λk = bk2n for any k ≥ 1 . Moreover , let b0 = n and λ0 = 1 . Then ZeroSARAH ( Algorithm 2 ) can find an -approximate solution for problem ( 1 ) such that E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2 and the number of stochastic gradient computations can be bounded by # grad : = K−1∑ k=0 bk ≤ n+ 2 ( 1 + √ 8 ) √ nL∆0 2 = O ( n+ √ nL∆0 2 ) . Remark : In Corollary 1 , ZeroSARAH only computes the full gradient ∇f ( x0 ) = 1n ∑n i=1∇fi ( x0 ) once for the initial point x0 , i.e. , minibatch size b0 = n , and then bk ≡ √ n for all iterations k ≥ 1 in Algorithm 2 . In the following Corollary 2 , we show that ZeroSARAH without computing any full gradients even for the initial point does not hurt its convergence performance . Corollary 2 Suppose that Assumption 1 holds . Choose stepsize ηk ≤ 1 ( 1+√8 ) L for any k ≥ 0 , minibatch size bk ≡ √ n for any k ≥ 0 , and parameter λ0 = 1 and λk = bk2n for any k ≥ 1 . Then ZeroSARAH ( Algorithm 2 ) can find an -approximate solution for problem ( 1 ) such that E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2 and the number of stochastic gradient computations can be bounded by # grad = O ( √ n ( L∆0 +G0 ) 2 ) . Note that G0 can be bounded by G0 ≤ 2L∆̂0 via L-smoothness Assumption 1 , then we also have # grad = O ( √ n ( L∆0 + L∆̂0 ) 2 ) . Remark : In Corollary 2 , ZeroSARAH never computes any full gradients even for the initial point , i.e. , minibatch size bk ≡ √ n for all iterations k ≥ 0 in Algorithm 2 . If we consider L , ∆0 , G0 or ∆̂0 as constant values then the stochastic gradient complexity in Corollary 2 is # grad = O ( √ n 2 ) , i.e. , full gradient computations do not appear in ZeroSARAH ( Algorithm 2 ) and the term ‘ n ’ also does not appear in its convergence result . Also note that the parameter settings ( i.e. , { ηk } , { bk } and { λk } in Algorithm 2 ) of Corollaries 1 and 2 are exactly the same except for b0 = n ( in Corollary 1 ) and b0 = √ n ( in Corollary 2 ) . Moreover , the parameter settings ( i.e. , { ηk } , { bk } and { λk } ) for Corollaries 1 and 2 only require the values of L and n , which is the same as all previous algorithms . If one further allows other values , e.g. , , G0 or ∆̂0 , for setting the initial b0 , then the gradient complexity can be further improved ( see Appendix D for more details ) . 5 D-ZeroSARAH ALGORITHM AND ITS CONVERGENCE RESULTS Now , we consider the distributed nonconvex problems ( 2 ) , i.e. , minx∈Rd { f ( x ) : = 1n ∑n i=1 fi ( x ) } with fi ( x ) : = 1m ∑m j=1 fi , j ( x ) , where n denotes the number of clients/devices/machines , fi denotes the loss associated with m data samples stored on client i . 5.1 D-ZeroSARAH ALGORITHM To solve distributed nonconvex problems ( 2 ) , we propose a distributed variant of ZeroSARAH ( called D-ZeroSARAH ) and describe it in Algorithm 3 . Same as our ZeroSARAH , D-ZeroSARAH also does not need to compute any full gradients at all . Avoiding any full gradient computations is important especially in this distributed setting , periodic computation of full gradient across all n clients may be impossible or unaffordable . Thus , we expect the proposed D-ZeroSARAH ( Algorithm 3 ) will have a practical impact in distributed and federated learning where full device participation is impractical . 5.2 CONVERGENCE RESULTS FOR D-ZeroSARAH Similar to ZeroSARAH in Section 4.2 , we also first present the main convergence theorem ( Theorem 2 ) of D-ZeroSARAH ( Algorithm 3 ) for solving distributed nonconvex problems ( 2 ) . Subsequently , we formulate two corollaries which present the detailed convergence results by specifying the choice of parameters . In particular , we list the results of these two Corollaries 3–4 in Table 2 for comparing with convergence results of previous works . Note that here we use the smoothness Assumption 2 instead of Assumption 1 for this distributed setting ( 2 ) . Theorem 2 Suppose that Assumption 2 holds . Choose stepsize ηk ≤ 1 L ( 1+ √ Wk+1 ) for any k ≥ 0 , whereWk+1 : = 2λk+1sk+1bk+1 + 8λk+1n 2m2 s3k+1b 3 k+1 . Moreover , let λ0 = 1 and θ0 : = nm ( nm−1 ) λ1 + 4nmλ1s0b0 s21b 2 1 . Then the following equation holds for D-ZeroSARAH ( Algorithm 3 ) for solving distributed problem ( 2 ) , for any iteration K ≥ 0 : E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2∆0∑K−1 k=0 ηk + ( nm− s0b0 ) η0θ0G′0 nms0b0 ∑K−1 k=0 ηk . ( 6 ) Algorithm 3 Distributed ZeroSARAH ( D-ZeroSARAH ) Input : initial point x0 , parameters { ηk } , { sk } , { bk } , { λk } 1 : x−1 = x0 2 : v−1 = 0 , y−11 = y −1 2 = · · · = y−1n = 0 // no full gradient computation 3 : for k = 0 , 1 , 2 , . . . do 4 : Randomly sample a subset of clients Sk from n clients with size |Sk| = sk 5 : for each client i ∈ Sk do 6 : Sample the data minibatch Ikbi ( with size |I k bi | = bk ) from the m data samples in client i 7 : Compute its local minibatch gradient information : gki , curr = 1 bk ∑ j∈Ikbi ∇fi , j ( xk ) , gki , prev = 1bk ∑ j∈Ikbi ∇fi , j ( xk−1 ) , yki , prev = 1bk ∑ j∈Ikbi yk−1i , j yki , j = { ∇fi , j ( xk ) for j ∈ Ikbi yk−1i , j for j /∈ Ikbi , yki = 1 m m∑ j=1 yki , j 8 : end for 9 : vk = 1sk ∑ i∈Sk ( gki , curr − gki , prev ) + ( 1− λk ) vk−1 + λk 1sk ∑ i∈Sk ( gki , prev − yki , prev ) + λky k−1 // no full gradient computations for vks 10 : xk+1 = xk − ηkvk 11 : yk = 1n n∑ i=1 yki // here y k i = y k−1 i for client i /∈ S k 12 : end for Corollary 3 Suppose that Assumption 2 holds . Choose stepsize ηk ≤ 1 ( 1+√8 ) L for any k ≥ 0 , clients subset size sk ≡ √ n , minibatch size bk ≡ √ m and parameter λk = skbk2nm for any k ≥ 1 . Moreover , let s0 = n , b0 = m , and λ0 = 1 . Then D-ZeroSARAH ( Algorithm 3 ) can find an -approximate solution for distributed problem ( 2 ) such that E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2 and the number of stochastic gradient computations for each client can be bounded by # grad = O ( m+ √ m n L∆0 2 ) . Corollary 4 Suppose that Assumption 2 holds . Choose stepsize ηk ≤ 1 ( 1+√8 ) L for any k ≥ 0 , clients subset size sk ≡ √ n and minibatch size bk ≡ √ m for any k ≥ 0 , and parameter λ0 = 1 and λk = skbk 2nm for any k ≥ 1 . Then D-ZeroSARAH ( Algorithm 3 ) can find an -approximate solution for distributed problem ( 2 ) such that E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2 and the number of stochastic gradient computations for each client can be bounded by # grad = O ( √ m n L∆0 +G ′ 0 2 ) . Remark : Similar discussions and remarks of Theorem 1 and Corollaries 1–2 for ZeroSARAH in Section 4.2 also hold for the results of D-ZeroSARAH ( i.e. , Theorem 2 and Corollaries 3–4 ) . | The paper proposes ZeroSARAH (and its distributed version D-ZeroSARAH), a variant of the well-known variance-reduced method SARAH, for non convex finite-sum optimization. The main benefit of ZeroSARAH and D-ZeroSARAH is that they do not require any full gradient computations, in contrast to other known variance reduction algorithms. In distributed setting, this can avoid the burden of synchronizing all clients. | SP:dab48ca112e4b792d5f7579fbe020e7efd114eac |
ZeroSARAH: Efficient Nonconvex Finite-Sum Optimization with Zero Full Gradient Computations | ∑n i=1 fi ( x ) . To the best of our knowledge , in this noncon- vex finite-sum regime , all existing variance-reduced methods , including SARAH , SVRG , SAGA and their variants , need to compute the full gradient over all n data samples at the initial point x0 , and then periodically compute the full gradient once every few iterations ( for SVRG , SARAH and their variants ) . Note that SVRG , SAGA and their variants typically achieve weaker convergence results than variants of SARAH : n2/3/ 2 vs. n1/2/ 2 . Thus we focus on the variant of SARAH . The proposed ZeroSARAH and its distributed variant D-ZeroSARAH are the first variance-reduced algorithms which do not require any full gradient computations , not even for the initial point . Moreover , for both standard and distributed settings , we show that ZeroSARAH and D-ZeroSARAH obtain new state-of-the-art convergence results , which can improve the previous best-known result ( given by e.g. , SPIDER , SARAH , and PAGE ) in certain regimes . Avoiding any full gradient computations ( which are time-consuming steps ) is important in many applications as the number of data samples n usually is very large . Especially in the distributed setting , periodic computation of full gradient over all data samples needs to periodically synchronize all clients/devices/machines , which may be impossible or unaffordable . Thus , we expect that ZeroSARAH/D-ZeroSARAH will have a practical impact in distributed and federated learning where full device participation is impractical . 1 INTRODUCTION . Nonconvex optimization is ubiquitous across many domains of machine learning ( Jain & Kar , 2017 ) , especially in training deep neural networks . In this paper , we consider the nonconvex finite-sum problems of the form min x∈Rd { f ( x ) : = 1 n n∑ i=1 fi ( x ) } , ( 1 ) where f : Rd → R is a differentiable and possibly nonconvex function . Problem ( 1 ) captures the standard empirical risk minimization problems in machine learning ( Shalev-Shwartz & Ben-David , 2014 ) . There are n data samples and fi denotes the loss associated with i-th data sample . We assume the functions fi : Rd → R for all i ∈ [ n ] : = { 1 , 2 , . . . , n } are also differentiable and possibly nonconvex functions . Beyond the standard/centralized problem ( 1 ) , we further consider the distributed/federated nonconvex problems : min x∈Rd { f ( x ) : = 1 n n∑ i=1 fi ( x ) } , fi ( x ) : = 1 m m∑ j=1 fi , j ( x ) , ( 2 ) where n denotes the number of clients/devices/machines , fi denotes the loss associated with m data samples stored on client i , and all functions are differentiable and can be nonconvex . Avoiding any full gradient computations is important especially in this distributed setting ( 2 ) , periodic computation of full gradient over all data samples needs to periodically synchronize all clients , which may be impossible or very hard to achieve . There has been extensive research in designing first-order ( gradient-type ) methods for solving centralized/distributed nonconvex problems ( 1 ) and ( 2 ) such as SGD , SVRG , SAGA , SCSG , SARAH and their variants , e.g. , ( Ghadimi & Lan , 2013 ; Ghadimi et al. , 2016 ; Allen-Zhu & Hazan , 2016 ; Reddi et al. , 2016 ; Lei et al. , 2017 ; Li & Li , 2018 ; Zhou et al. , 2018 ; Fang et al. , 2018 ; Wang et al. , 2018 ; Ge et al. , 2019 ; Pham et al. , 2019 ; Li , 2019 ; Li & Richtárik , 2020 ; Horváth et al. , 2020 ; Li et al. , 2021 ) . Note that SVRG and SAGA variants typically achieve weaker convergence results than SARAH variants , i.e. , n2/3/ 2 vs. √ n/ 2 . Thus the current best convergence results are achieved by SARAH variants such as SPIDER ( Fang et al. , 2018 ) , SARAH ( Pham et al. , 2019 ) and PAGE ( Li et al. , 2021 ; Li , 2021 ) . However , all of these variance-reduced algorithms ( no matter based on SVRG , SAGA or SARAH ) require full gradient computations ( i.e. , compute ∇f ( x ) = 1n ∑n i=1∇fi ( x ) ) without assuming additional assumptions except standard L-smoothness assumptions . We would like to point out that under an additional bounded variance assumption ( e.g. , Ei [ ‖∇fi ( x ) −∇f ( x ) ‖2 ] ≤ σ2 , ∀x ∈ Rd ) , some of them ( such as SCSG ( Lei et al. , 2017 ) , SVRG+ ( Li & Li , 2018 ) , PAGE ( Li et al. , 2021 ) ) may avoid full gradient computations by using a large minibatch of stochastic gradients instead ( usually the minibatch size is O ( σ2/ 2 ) ) . Clearly , there exist some drawbacks : i ) σ2 usually is not known ; ii ) if the target error is very small ( defined as E [ ‖∇f ( x̂ ) ‖2 ] ≤ 2 in Definition 1 ) or σ is very large , then the minibatch size O ( σ2/ 2 ) is still very large for replacing full gradient computations . In this paper , we only consider algorithms under the standard L-smoothness assumptions , without assuming any other additional assumptions ( such as bounded variance assumption mentioned above ) . Thus , all existing variance-reduced methods , including SARAH , SVRG , SAGA and their variants , need to compute the full gradient over all n data samples at the initial point x0 , and then periodically compute the full gradient once every few iterations ( for SVRG , SARAH and their variants ) . However , full gradient computations are time-consuming steps in many applications as the number of data samples n usually is very large . Especially in the distributed setting , periodic computation of full gradient needs to periodically synchronize all clients/devices , which usually is impractical . Motivated by this , we focus on designing new algorithms which do not require any full gradient computations for solving standard and distributed nonconvex problems ( 1 ) – ( 2 ) . 2 OUR CONTRIBUTIONS . In this paper , we propose the first variance-reduced algorithm ZeroSARAH ( and also its distributed variant D-ZeroSARAH ) without computing any full gradients for solving both standard and distributed nonconvex finite-sum problems ( 1 ) – ( 2 ) . Moreover , ZeroSARAH and Distributed D-ZeroSARAH can obtain new state-of-the-art convergence results which improve previous bestknown results ( given by e.g. , SPIDER , SARAH and PAGE ) in certain regimes ( see Tables 1–2 for the comparison with previous algorithms ) . ZeroSARAH is formally described in Algorithm 2 , which is a variant of SARAH ( Nguyen et al. , 2017 ) . See Section 4 for more details and comparisons between ZeroSARAH and SARAH . Then , D-ZeroSARAH is formally described in Algorithm 3 of Section 5 , which is a distributed variant of our ZeroSARAH . Now , we highlight the following results achieved by ZeroSARAH and D-ZeroSARAH : • ZeroSARAH and D-ZeroSARAH are the first variance-reduced algorithms which do not require any full gradient computations , not even for the initial point ( see Algorithms 2–3 or Tables 1–2 ) . Avoiding any full gradient computations is important in many applications as the number of data samples n usually is very large . Especially in the distributed setting , periodic computation of full gradient over all data samples stored in all clients/devices may be impossible or very hard to achieve . We expect that ZeroSARAH/D-ZeroSARAH will have a practical impact in distributed and federated learning where full device participation is impractical . • Moreover , ZeroSARAH can recover the previous best-known convergence result O ( n + √ nL∆0 2 ) ( see Table 1 or Corollary 1 ) , and also provide new state-of-the-art convergence results without any full gradient computations ( see Table 1 or Corollary 2 ) which can improve the previous best result in certain regimes . • Besides , for the distributed nonconvex setting ( 2 ) , the distributed D-ZeroSARAH ( Algorithm 3 ) enjoys similar benefits as our ZeroSARAH , i.e. , D-ZeroSARAH does not need to periodically synchronize all n clients to compute any full gradients , and also provides new state-of-the-art convergence results . See Table 2 and Section 5 for more details . • Finally , the experimental results in Section 6 show that ZeroSARAH is slightly better than the previous state-of-the-art SARAH . However , we should point out that ZeroSARAH does not compute any full gradients while SARAH needs to periodically compute the full gradients for every l iterations ( here l = √ n ) . Thus the experiments validate our theoretical results ( can be slightly better than SARAH ( see Table 1 ) ) and confirm the practical superiority of ZeroSARAH ( avoid any full gradient computations ) . Similar experimental results of D-ZeroSARAH for the distributed setting are provided in Appendix A.2 . 3 PRELIMINARIES . Notation : Let [ n ] denote the set { 1 , 2 , · · · , n } and ‖ · ‖ denote the Euclidean norm for a vector and the spectral norm for a matrix . Let 〈u , v〉 denote the inner product of two vectors u and v. We use O ( · ) and Ω ( · ) to hide the absolute constant , and Õ ( · ) to hide the logarithmic factor . We will write ∆0 : = f ( x0 ) − f∗ , f∗ : = minx∈Rd f ( x ) , G0 : = 1n ∑n i=1 ‖∇fi ( x0 ) ‖2 , ∆̂0 : = f ( x0 ) − f̂∗ , f̂∗ : = 1n ∑n i=1 minx∈Rd fi ( x ) and G ′ 0 : = 1 nm ∑n , m i , j=1,1 ‖∇fi , j ( x0 ) ‖2 . Definition 1 A point x̂ is called an -approximate solution for nonconvex problems ( 1 ) and ( 2 ) if E [ ‖∇f ( x̂ ) ‖2 ] ≤ 2 . To show the convergence results , we assume the following standard smoothness assumption for nonconvex problems ( 1 ) . Assumption 1 ( L-smoothness ) A function fi : Rd → R is L-smooth if ∃L > 0 , such that ‖∇fi ( x ) −∇fi ( y ) ‖ ≤ L‖x− y‖ , ∀x , y ∈ Rd . ( 3 ) It is easy to see that f ( x ) = 1n ∑n i=1 fi ( x ) is also L-smooth under Assumption 1 . We can also relax Assumption 1 by defining Li-smoothness for each fi . Then if we further define the average L2 : = 1n ∑n i=1 L 2 i , we know that f ( x ) = 1 n ∑n i=1 fi ( x ) is also L-smooth . Here we use the same L just for simple representation . For the distributed nonconvex problems ( 2 ) , we use the following Assumption 2 instead of Assumption 1 . Similarly , we can also relax it by defining Li , j-smoothness for different fi , j . Here we use the same L just for simple representation . Assumption 2 ( L-smoothness ) A function fi , j : Rd → R is L-smooth if ∃L > 0 , such that ‖∇fi , j ( x ) −∇fi , j ( y ) ‖ ≤ L‖x− y‖ , ∀x , y ∈ Rd . ( 4 ) Algorithm 1 SARAH ( Nguyen et al. , 2017 ; Pham et al. , 2019 ) Input : initial point x0 , epoch length l , stepsize η , minibatch size b 1 : x̃ = x0 2 : for s = 0 , 1 , 2 , . . . do 3 : x0 = x̃ 4 : v0 = ∇f ( x0 ) = 1n n∑ i=1 ∇fi ( x0 ) // compute the full gradient once for every l iterations 5 : x1 = x0 − ηv0 6 : for k = 1 , 2 , . . . , l do 7 : Randomly sample a minibatch data samples Ib with |Ib| = b 8 : vk = 1b ∑ i∈Ib ( ∇fi ( xk ) −∇fi ( xk−1 ) ) + vk−1 9 : xk+1 = xk − ηvk 10 : end for 11 : x̃ randomly chosen from { xk } k∈ [ l ] or x̃ = xl+1 12 : end for Algorithm 2 SARAH without full gradient computations ( ZeroSARAH ) Input : initial point x0 , stepsize { ηk } , minibatch size { bk } , parameter { λk } 1 : x−1 = x0 2 : v−1 = 0 , y−11 = y −1 2 = · · · = y−1n = 0 // no full gradient computation 3 : for k = 0 , 1 , 2 , . . . do 4 : Randomly sample a minibatch data samples Ikb with |Ikb | = bk 5 : vk = 1bk ∑ i∈Ikb ( ∇fi ( xk ) −∇fi ( xk−1 ) ) + ( 1− λk ) vk−1 + λk ( 1 bk ∑ i∈Ikb ( ∇fi ( xk−1 ) − yk−1i ) + 1n n∑ j=1 yk−1j ) // no full gradient computations for vks 6 : xk+1 = xk − ηkvk 7 : yki = { ∇fi ( xk ) for i ∈ Ikb yk−1i for i /∈ Ikb // the update of { yki } directly follows from the stochastic gradients computed in Line 5 8 : end for 4 ZeroSARAH ALGORITHM AND ITS CONVERGENCE RESULTS In this section , we consider the standard/centralized nonconvex problems ( 1 ) . The distributed setting ( 2 ) is considered in the following Section 5 . 4.1 ZeroSARAH ALGORITHM We first describe the proposed ZeroSARAH in Algorithm 2 , which is a variant of SARAH ( Nguyen et al. , 2017 ) . To better compare with SARAH and ZeroSARAH , we also recall the original SARAH in Algorithm 1 . Now , we highlight some points for the difference between SARAH and our ZeroSARAH : • SARAH requires the full gradient computations for every epoch ( see Line 4 of Algorithm 1 ) . However , ZeroSARAH combines the past gradient estimator vk−1 with another estimator to avoid periodically computing the full gradient . See the difference between Line 8 of Algorithm 1 and Line 5 of Algorithm 2 ( also highlighted with blue color ) . • The gradient estimator vk in ZeroSARAH ( Line 5 of Algorithm 2 ) does not require more stochastic gradient computations compared with vk in SARAH ( Line 8 of Algorithm 1 ) if the minibatch size bk = b . • The new gradient estimator vk of ZeroSARAH also leads to simpler algorithmic structure , i.e. , single-loop in ZeroSARAH vs. double-loop in SARAH . •Moreover , the difference of gradient estimator vk also leads to different results in expectation , i.e. , 1 ) for SARAH : Ek [ vk −∇f ( xk ) ] = vk−1 −∇f ( xk−1 ) ; 2 ) for ZeroSARAH : Ek [ vk −∇f ( xk ) ] = ( 1− λk ) ( vk−1 −∇f ( xk−1 ) ) . 4.2 CONVERGENCE RESULTS FOR ZeroSARAH Now , we present the main convergence theorem ( Theorem 1 ) of ZeroSARAH ( Algorithm 2 ) for solving nonconvex finite-sum problems ( 1 ) . Subsequently , we formulate two corollaries which present the detailed convergence results by specifying the choice of parameters . In particular , we list the results of these two Corollaries 1–2 in Table 1 for comparing with convergence results of previous works . Theorem 1 Suppose that Assumption 1 holds . Choose stepsize ηk ≤ 1 L ( 1+ √ Mk+1 ) for any k ≥ 0 , where Mk+1 : = 2λk+1bk+1 + 8λk+1n 2 b3k+1 . Moreover , let λ0 = 1 , γ0 ≥ η02λ1 and α0 ≥ 2nλ1η0 b21 . Then the following equation holds for ZeroSARAH ( Algorithm 2 ) for solving problem ( 1 ) , for any iteration K ≥ 0 : E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2∆0∑K−1 k=0 ηk + ( n− b0 ) ( 4γ0 + 2α0b0 ) G0 nb0 ∑K−1 k=0 ηk . ( 5 ) Remark : Note that we can upper bound both terms on the right-hand side of ( 5 ) . It means that there is no convergence neighborhood of ZeroSARAH and hence , ZeroSARAH can find an -approximate solution for any > 0 . In the following , we provide two detailed convergence results in Corollaries 1 and 2 by specifying two kinds of parameter settings . Note that the algorithm computes full gradient in iteration k if the minibatch bk = n. Our convergence results show that without computing any full gradients actually does not hurt the convergence performance of algorithms ( see Table 1 ) . In particular , we note that the second term of ( 5 ) will be deleted if we choose minibatch size b0 = n for the initial point x0 ( see Corollary 1 for more details ) . Here Corollary 1 only needs to compute the full gradient once for the initialization , and does not compute any full gradients later ( i.e. , bk ≡ √ n for all k > 0 ) . Also note that even if we choose b0 < n , we can also upper bound the second term of ( 5 ) . It means that ZeroSARAH can find an -approximate solution without computing any full gradients even for the initial point , i.e. , minibatch size bk < n for all iterations k ≥ 0 . For instance , we choose bk ≡ √ n for all k ≥ 0 in Corollary 2 , i.e. , ZeroSARAH never computes any full gradients even for the initial point . Corollary 1 Suppose that Assumption 1 holds . Choose stepsize ηk ≤ 1 ( 1+√8 ) L for any k ≥ 0 , minibatch size bk ≡ √ n and parameter λk = bk2n for any k ≥ 1 . Moreover , let b0 = n and λ0 = 1 . Then ZeroSARAH ( Algorithm 2 ) can find an -approximate solution for problem ( 1 ) such that E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2 and the number of stochastic gradient computations can be bounded by # grad : = K−1∑ k=0 bk ≤ n+ 2 ( 1 + √ 8 ) √ nL∆0 2 = O ( n+ √ nL∆0 2 ) . Remark : In Corollary 1 , ZeroSARAH only computes the full gradient ∇f ( x0 ) = 1n ∑n i=1∇fi ( x0 ) once for the initial point x0 , i.e. , minibatch size b0 = n , and then bk ≡ √ n for all iterations k ≥ 1 in Algorithm 2 . In the following Corollary 2 , we show that ZeroSARAH without computing any full gradients even for the initial point does not hurt its convergence performance . Corollary 2 Suppose that Assumption 1 holds . Choose stepsize ηk ≤ 1 ( 1+√8 ) L for any k ≥ 0 , minibatch size bk ≡ √ n for any k ≥ 0 , and parameter λ0 = 1 and λk = bk2n for any k ≥ 1 . Then ZeroSARAH ( Algorithm 2 ) can find an -approximate solution for problem ( 1 ) such that E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2 and the number of stochastic gradient computations can be bounded by # grad = O ( √ n ( L∆0 +G0 ) 2 ) . Note that G0 can be bounded by G0 ≤ 2L∆̂0 via L-smoothness Assumption 1 , then we also have # grad = O ( √ n ( L∆0 + L∆̂0 ) 2 ) . Remark : In Corollary 2 , ZeroSARAH never computes any full gradients even for the initial point , i.e. , minibatch size bk ≡ √ n for all iterations k ≥ 0 in Algorithm 2 . If we consider L , ∆0 , G0 or ∆̂0 as constant values then the stochastic gradient complexity in Corollary 2 is # grad = O ( √ n 2 ) , i.e. , full gradient computations do not appear in ZeroSARAH ( Algorithm 2 ) and the term ‘ n ’ also does not appear in its convergence result . Also note that the parameter settings ( i.e. , { ηk } , { bk } and { λk } in Algorithm 2 ) of Corollaries 1 and 2 are exactly the same except for b0 = n ( in Corollary 1 ) and b0 = √ n ( in Corollary 2 ) . Moreover , the parameter settings ( i.e. , { ηk } , { bk } and { λk } ) for Corollaries 1 and 2 only require the values of L and n , which is the same as all previous algorithms . If one further allows other values , e.g. , , G0 or ∆̂0 , for setting the initial b0 , then the gradient complexity can be further improved ( see Appendix D for more details ) . 5 D-ZeroSARAH ALGORITHM AND ITS CONVERGENCE RESULTS Now , we consider the distributed nonconvex problems ( 2 ) , i.e. , minx∈Rd { f ( x ) : = 1n ∑n i=1 fi ( x ) } with fi ( x ) : = 1m ∑m j=1 fi , j ( x ) , where n denotes the number of clients/devices/machines , fi denotes the loss associated with m data samples stored on client i . 5.1 D-ZeroSARAH ALGORITHM To solve distributed nonconvex problems ( 2 ) , we propose a distributed variant of ZeroSARAH ( called D-ZeroSARAH ) and describe it in Algorithm 3 . Same as our ZeroSARAH , D-ZeroSARAH also does not need to compute any full gradients at all . Avoiding any full gradient computations is important especially in this distributed setting , periodic computation of full gradient across all n clients may be impossible or unaffordable . Thus , we expect the proposed D-ZeroSARAH ( Algorithm 3 ) will have a practical impact in distributed and federated learning where full device participation is impractical . 5.2 CONVERGENCE RESULTS FOR D-ZeroSARAH Similar to ZeroSARAH in Section 4.2 , we also first present the main convergence theorem ( Theorem 2 ) of D-ZeroSARAH ( Algorithm 3 ) for solving distributed nonconvex problems ( 2 ) . Subsequently , we formulate two corollaries which present the detailed convergence results by specifying the choice of parameters . In particular , we list the results of these two Corollaries 3–4 in Table 2 for comparing with convergence results of previous works . Note that here we use the smoothness Assumption 2 instead of Assumption 1 for this distributed setting ( 2 ) . Theorem 2 Suppose that Assumption 2 holds . Choose stepsize ηk ≤ 1 L ( 1+ √ Wk+1 ) for any k ≥ 0 , whereWk+1 : = 2λk+1sk+1bk+1 + 8λk+1n 2m2 s3k+1b 3 k+1 . Moreover , let λ0 = 1 and θ0 : = nm ( nm−1 ) λ1 + 4nmλ1s0b0 s21b 2 1 . Then the following equation holds for D-ZeroSARAH ( Algorithm 3 ) for solving distributed problem ( 2 ) , for any iteration K ≥ 0 : E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2∆0∑K−1 k=0 ηk + ( nm− s0b0 ) η0θ0G′0 nms0b0 ∑K−1 k=0 ηk . ( 6 ) Algorithm 3 Distributed ZeroSARAH ( D-ZeroSARAH ) Input : initial point x0 , parameters { ηk } , { sk } , { bk } , { λk } 1 : x−1 = x0 2 : v−1 = 0 , y−11 = y −1 2 = · · · = y−1n = 0 // no full gradient computation 3 : for k = 0 , 1 , 2 , . . . do 4 : Randomly sample a subset of clients Sk from n clients with size |Sk| = sk 5 : for each client i ∈ Sk do 6 : Sample the data minibatch Ikbi ( with size |I k bi | = bk ) from the m data samples in client i 7 : Compute its local minibatch gradient information : gki , curr = 1 bk ∑ j∈Ikbi ∇fi , j ( xk ) , gki , prev = 1bk ∑ j∈Ikbi ∇fi , j ( xk−1 ) , yki , prev = 1bk ∑ j∈Ikbi yk−1i , j yki , j = { ∇fi , j ( xk ) for j ∈ Ikbi yk−1i , j for j /∈ Ikbi , yki = 1 m m∑ j=1 yki , j 8 : end for 9 : vk = 1sk ∑ i∈Sk ( gki , curr − gki , prev ) + ( 1− λk ) vk−1 + λk 1sk ∑ i∈Sk ( gki , prev − yki , prev ) + λky k−1 // no full gradient computations for vks 10 : xk+1 = xk − ηkvk 11 : yk = 1n n∑ i=1 yki // here y k i = y k−1 i for client i /∈ S k 12 : end for Corollary 3 Suppose that Assumption 2 holds . Choose stepsize ηk ≤ 1 ( 1+√8 ) L for any k ≥ 0 , clients subset size sk ≡ √ n , minibatch size bk ≡ √ m and parameter λk = skbk2nm for any k ≥ 1 . Moreover , let s0 = n , b0 = m , and λ0 = 1 . Then D-ZeroSARAH ( Algorithm 3 ) can find an -approximate solution for distributed problem ( 2 ) such that E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2 and the number of stochastic gradient computations for each client can be bounded by # grad = O ( m+ √ m n L∆0 2 ) . Corollary 4 Suppose that Assumption 2 holds . Choose stepsize ηk ≤ 1 ( 1+√8 ) L for any k ≥ 0 , clients subset size sk ≡ √ n and minibatch size bk ≡ √ m for any k ≥ 0 , and parameter λ0 = 1 and λk = skbk 2nm for any k ≥ 1 . Then D-ZeroSARAH ( Algorithm 3 ) can find an -approximate solution for distributed problem ( 2 ) such that E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2 and the number of stochastic gradient computations for each client can be bounded by # grad = O ( √ m n L∆0 +G ′ 0 2 ) . Remark : Similar discussions and remarks of Theorem 1 and Corollaries 1–2 for ZeroSARAH in Section 4.2 also hold for the results of D-ZeroSARAH ( i.e. , Theorem 2 and Corollaries 3–4 ) . | The authors propose a variance-reduced algorithm ZeroSARAH for solving the nonconvex finite-sum problems. They also propose a distributed variant D-ZeroSARAH for the corresponding distributed framework. They provide the state-of-the-art convergence results for these methods using standard assumptions. The authors claim that both methods does not require computing full gradients, which gives a major advantage when the number of samples $n$ is large. They further validate ZeroSARAH using nonconvex linear regression and binary classification for neural networks. | SP:dab48ca112e4b792d5f7579fbe020e7efd114eac |
ZeroSARAH: Efficient Nonconvex Finite-Sum Optimization with Zero Full Gradient Computations | ∑n i=1 fi ( x ) . To the best of our knowledge , in this noncon- vex finite-sum regime , all existing variance-reduced methods , including SARAH , SVRG , SAGA and their variants , need to compute the full gradient over all n data samples at the initial point x0 , and then periodically compute the full gradient once every few iterations ( for SVRG , SARAH and their variants ) . Note that SVRG , SAGA and their variants typically achieve weaker convergence results than variants of SARAH : n2/3/ 2 vs. n1/2/ 2 . Thus we focus on the variant of SARAH . The proposed ZeroSARAH and its distributed variant D-ZeroSARAH are the first variance-reduced algorithms which do not require any full gradient computations , not even for the initial point . Moreover , for both standard and distributed settings , we show that ZeroSARAH and D-ZeroSARAH obtain new state-of-the-art convergence results , which can improve the previous best-known result ( given by e.g. , SPIDER , SARAH , and PAGE ) in certain regimes . Avoiding any full gradient computations ( which are time-consuming steps ) is important in many applications as the number of data samples n usually is very large . Especially in the distributed setting , periodic computation of full gradient over all data samples needs to periodically synchronize all clients/devices/machines , which may be impossible or unaffordable . Thus , we expect that ZeroSARAH/D-ZeroSARAH will have a practical impact in distributed and federated learning where full device participation is impractical . 1 INTRODUCTION . Nonconvex optimization is ubiquitous across many domains of machine learning ( Jain & Kar , 2017 ) , especially in training deep neural networks . In this paper , we consider the nonconvex finite-sum problems of the form min x∈Rd { f ( x ) : = 1 n n∑ i=1 fi ( x ) } , ( 1 ) where f : Rd → R is a differentiable and possibly nonconvex function . Problem ( 1 ) captures the standard empirical risk minimization problems in machine learning ( Shalev-Shwartz & Ben-David , 2014 ) . There are n data samples and fi denotes the loss associated with i-th data sample . We assume the functions fi : Rd → R for all i ∈ [ n ] : = { 1 , 2 , . . . , n } are also differentiable and possibly nonconvex functions . Beyond the standard/centralized problem ( 1 ) , we further consider the distributed/federated nonconvex problems : min x∈Rd { f ( x ) : = 1 n n∑ i=1 fi ( x ) } , fi ( x ) : = 1 m m∑ j=1 fi , j ( x ) , ( 2 ) where n denotes the number of clients/devices/machines , fi denotes the loss associated with m data samples stored on client i , and all functions are differentiable and can be nonconvex . Avoiding any full gradient computations is important especially in this distributed setting ( 2 ) , periodic computation of full gradient over all data samples needs to periodically synchronize all clients , which may be impossible or very hard to achieve . There has been extensive research in designing first-order ( gradient-type ) methods for solving centralized/distributed nonconvex problems ( 1 ) and ( 2 ) such as SGD , SVRG , SAGA , SCSG , SARAH and their variants , e.g. , ( Ghadimi & Lan , 2013 ; Ghadimi et al. , 2016 ; Allen-Zhu & Hazan , 2016 ; Reddi et al. , 2016 ; Lei et al. , 2017 ; Li & Li , 2018 ; Zhou et al. , 2018 ; Fang et al. , 2018 ; Wang et al. , 2018 ; Ge et al. , 2019 ; Pham et al. , 2019 ; Li , 2019 ; Li & Richtárik , 2020 ; Horváth et al. , 2020 ; Li et al. , 2021 ) . Note that SVRG and SAGA variants typically achieve weaker convergence results than SARAH variants , i.e. , n2/3/ 2 vs. √ n/ 2 . Thus the current best convergence results are achieved by SARAH variants such as SPIDER ( Fang et al. , 2018 ) , SARAH ( Pham et al. , 2019 ) and PAGE ( Li et al. , 2021 ; Li , 2021 ) . However , all of these variance-reduced algorithms ( no matter based on SVRG , SAGA or SARAH ) require full gradient computations ( i.e. , compute ∇f ( x ) = 1n ∑n i=1∇fi ( x ) ) without assuming additional assumptions except standard L-smoothness assumptions . We would like to point out that under an additional bounded variance assumption ( e.g. , Ei [ ‖∇fi ( x ) −∇f ( x ) ‖2 ] ≤ σ2 , ∀x ∈ Rd ) , some of them ( such as SCSG ( Lei et al. , 2017 ) , SVRG+ ( Li & Li , 2018 ) , PAGE ( Li et al. , 2021 ) ) may avoid full gradient computations by using a large minibatch of stochastic gradients instead ( usually the minibatch size is O ( σ2/ 2 ) ) . Clearly , there exist some drawbacks : i ) σ2 usually is not known ; ii ) if the target error is very small ( defined as E [ ‖∇f ( x̂ ) ‖2 ] ≤ 2 in Definition 1 ) or σ is very large , then the minibatch size O ( σ2/ 2 ) is still very large for replacing full gradient computations . In this paper , we only consider algorithms under the standard L-smoothness assumptions , without assuming any other additional assumptions ( such as bounded variance assumption mentioned above ) . Thus , all existing variance-reduced methods , including SARAH , SVRG , SAGA and their variants , need to compute the full gradient over all n data samples at the initial point x0 , and then periodically compute the full gradient once every few iterations ( for SVRG , SARAH and their variants ) . However , full gradient computations are time-consuming steps in many applications as the number of data samples n usually is very large . Especially in the distributed setting , periodic computation of full gradient needs to periodically synchronize all clients/devices , which usually is impractical . Motivated by this , we focus on designing new algorithms which do not require any full gradient computations for solving standard and distributed nonconvex problems ( 1 ) – ( 2 ) . 2 OUR CONTRIBUTIONS . In this paper , we propose the first variance-reduced algorithm ZeroSARAH ( and also its distributed variant D-ZeroSARAH ) without computing any full gradients for solving both standard and distributed nonconvex finite-sum problems ( 1 ) – ( 2 ) . Moreover , ZeroSARAH and Distributed D-ZeroSARAH can obtain new state-of-the-art convergence results which improve previous bestknown results ( given by e.g. , SPIDER , SARAH and PAGE ) in certain regimes ( see Tables 1–2 for the comparison with previous algorithms ) . ZeroSARAH is formally described in Algorithm 2 , which is a variant of SARAH ( Nguyen et al. , 2017 ) . See Section 4 for more details and comparisons between ZeroSARAH and SARAH . Then , D-ZeroSARAH is formally described in Algorithm 3 of Section 5 , which is a distributed variant of our ZeroSARAH . Now , we highlight the following results achieved by ZeroSARAH and D-ZeroSARAH : • ZeroSARAH and D-ZeroSARAH are the first variance-reduced algorithms which do not require any full gradient computations , not even for the initial point ( see Algorithms 2–3 or Tables 1–2 ) . Avoiding any full gradient computations is important in many applications as the number of data samples n usually is very large . Especially in the distributed setting , periodic computation of full gradient over all data samples stored in all clients/devices may be impossible or very hard to achieve . We expect that ZeroSARAH/D-ZeroSARAH will have a practical impact in distributed and federated learning where full device participation is impractical . • Moreover , ZeroSARAH can recover the previous best-known convergence result O ( n + √ nL∆0 2 ) ( see Table 1 or Corollary 1 ) , and also provide new state-of-the-art convergence results without any full gradient computations ( see Table 1 or Corollary 2 ) which can improve the previous best result in certain regimes . • Besides , for the distributed nonconvex setting ( 2 ) , the distributed D-ZeroSARAH ( Algorithm 3 ) enjoys similar benefits as our ZeroSARAH , i.e. , D-ZeroSARAH does not need to periodically synchronize all n clients to compute any full gradients , and also provides new state-of-the-art convergence results . See Table 2 and Section 5 for more details . • Finally , the experimental results in Section 6 show that ZeroSARAH is slightly better than the previous state-of-the-art SARAH . However , we should point out that ZeroSARAH does not compute any full gradients while SARAH needs to periodically compute the full gradients for every l iterations ( here l = √ n ) . Thus the experiments validate our theoretical results ( can be slightly better than SARAH ( see Table 1 ) ) and confirm the practical superiority of ZeroSARAH ( avoid any full gradient computations ) . Similar experimental results of D-ZeroSARAH for the distributed setting are provided in Appendix A.2 . 3 PRELIMINARIES . Notation : Let [ n ] denote the set { 1 , 2 , · · · , n } and ‖ · ‖ denote the Euclidean norm for a vector and the spectral norm for a matrix . Let 〈u , v〉 denote the inner product of two vectors u and v. We use O ( · ) and Ω ( · ) to hide the absolute constant , and Õ ( · ) to hide the logarithmic factor . We will write ∆0 : = f ( x0 ) − f∗ , f∗ : = minx∈Rd f ( x ) , G0 : = 1n ∑n i=1 ‖∇fi ( x0 ) ‖2 , ∆̂0 : = f ( x0 ) − f̂∗ , f̂∗ : = 1n ∑n i=1 minx∈Rd fi ( x ) and G ′ 0 : = 1 nm ∑n , m i , j=1,1 ‖∇fi , j ( x0 ) ‖2 . Definition 1 A point x̂ is called an -approximate solution for nonconvex problems ( 1 ) and ( 2 ) if E [ ‖∇f ( x̂ ) ‖2 ] ≤ 2 . To show the convergence results , we assume the following standard smoothness assumption for nonconvex problems ( 1 ) . Assumption 1 ( L-smoothness ) A function fi : Rd → R is L-smooth if ∃L > 0 , such that ‖∇fi ( x ) −∇fi ( y ) ‖ ≤ L‖x− y‖ , ∀x , y ∈ Rd . ( 3 ) It is easy to see that f ( x ) = 1n ∑n i=1 fi ( x ) is also L-smooth under Assumption 1 . We can also relax Assumption 1 by defining Li-smoothness for each fi . Then if we further define the average L2 : = 1n ∑n i=1 L 2 i , we know that f ( x ) = 1 n ∑n i=1 fi ( x ) is also L-smooth . Here we use the same L just for simple representation . For the distributed nonconvex problems ( 2 ) , we use the following Assumption 2 instead of Assumption 1 . Similarly , we can also relax it by defining Li , j-smoothness for different fi , j . Here we use the same L just for simple representation . Assumption 2 ( L-smoothness ) A function fi , j : Rd → R is L-smooth if ∃L > 0 , such that ‖∇fi , j ( x ) −∇fi , j ( y ) ‖ ≤ L‖x− y‖ , ∀x , y ∈ Rd . ( 4 ) Algorithm 1 SARAH ( Nguyen et al. , 2017 ; Pham et al. , 2019 ) Input : initial point x0 , epoch length l , stepsize η , minibatch size b 1 : x̃ = x0 2 : for s = 0 , 1 , 2 , . . . do 3 : x0 = x̃ 4 : v0 = ∇f ( x0 ) = 1n n∑ i=1 ∇fi ( x0 ) // compute the full gradient once for every l iterations 5 : x1 = x0 − ηv0 6 : for k = 1 , 2 , . . . , l do 7 : Randomly sample a minibatch data samples Ib with |Ib| = b 8 : vk = 1b ∑ i∈Ib ( ∇fi ( xk ) −∇fi ( xk−1 ) ) + vk−1 9 : xk+1 = xk − ηvk 10 : end for 11 : x̃ randomly chosen from { xk } k∈ [ l ] or x̃ = xl+1 12 : end for Algorithm 2 SARAH without full gradient computations ( ZeroSARAH ) Input : initial point x0 , stepsize { ηk } , minibatch size { bk } , parameter { λk } 1 : x−1 = x0 2 : v−1 = 0 , y−11 = y −1 2 = · · · = y−1n = 0 // no full gradient computation 3 : for k = 0 , 1 , 2 , . . . do 4 : Randomly sample a minibatch data samples Ikb with |Ikb | = bk 5 : vk = 1bk ∑ i∈Ikb ( ∇fi ( xk ) −∇fi ( xk−1 ) ) + ( 1− λk ) vk−1 + λk ( 1 bk ∑ i∈Ikb ( ∇fi ( xk−1 ) − yk−1i ) + 1n n∑ j=1 yk−1j ) // no full gradient computations for vks 6 : xk+1 = xk − ηkvk 7 : yki = { ∇fi ( xk ) for i ∈ Ikb yk−1i for i /∈ Ikb // the update of { yki } directly follows from the stochastic gradients computed in Line 5 8 : end for 4 ZeroSARAH ALGORITHM AND ITS CONVERGENCE RESULTS In this section , we consider the standard/centralized nonconvex problems ( 1 ) . The distributed setting ( 2 ) is considered in the following Section 5 . 4.1 ZeroSARAH ALGORITHM We first describe the proposed ZeroSARAH in Algorithm 2 , which is a variant of SARAH ( Nguyen et al. , 2017 ) . To better compare with SARAH and ZeroSARAH , we also recall the original SARAH in Algorithm 1 . Now , we highlight some points for the difference between SARAH and our ZeroSARAH : • SARAH requires the full gradient computations for every epoch ( see Line 4 of Algorithm 1 ) . However , ZeroSARAH combines the past gradient estimator vk−1 with another estimator to avoid periodically computing the full gradient . See the difference between Line 8 of Algorithm 1 and Line 5 of Algorithm 2 ( also highlighted with blue color ) . • The gradient estimator vk in ZeroSARAH ( Line 5 of Algorithm 2 ) does not require more stochastic gradient computations compared with vk in SARAH ( Line 8 of Algorithm 1 ) if the minibatch size bk = b . • The new gradient estimator vk of ZeroSARAH also leads to simpler algorithmic structure , i.e. , single-loop in ZeroSARAH vs. double-loop in SARAH . •Moreover , the difference of gradient estimator vk also leads to different results in expectation , i.e. , 1 ) for SARAH : Ek [ vk −∇f ( xk ) ] = vk−1 −∇f ( xk−1 ) ; 2 ) for ZeroSARAH : Ek [ vk −∇f ( xk ) ] = ( 1− λk ) ( vk−1 −∇f ( xk−1 ) ) . 4.2 CONVERGENCE RESULTS FOR ZeroSARAH Now , we present the main convergence theorem ( Theorem 1 ) of ZeroSARAH ( Algorithm 2 ) for solving nonconvex finite-sum problems ( 1 ) . Subsequently , we formulate two corollaries which present the detailed convergence results by specifying the choice of parameters . In particular , we list the results of these two Corollaries 1–2 in Table 1 for comparing with convergence results of previous works . Theorem 1 Suppose that Assumption 1 holds . Choose stepsize ηk ≤ 1 L ( 1+ √ Mk+1 ) for any k ≥ 0 , where Mk+1 : = 2λk+1bk+1 + 8λk+1n 2 b3k+1 . Moreover , let λ0 = 1 , γ0 ≥ η02λ1 and α0 ≥ 2nλ1η0 b21 . Then the following equation holds for ZeroSARAH ( Algorithm 2 ) for solving problem ( 1 ) , for any iteration K ≥ 0 : E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2∆0∑K−1 k=0 ηk + ( n− b0 ) ( 4γ0 + 2α0b0 ) G0 nb0 ∑K−1 k=0 ηk . ( 5 ) Remark : Note that we can upper bound both terms on the right-hand side of ( 5 ) . It means that there is no convergence neighborhood of ZeroSARAH and hence , ZeroSARAH can find an -approximate solution for any > 0 . In the following , we provide two detailed convergence results in Corollaries 1 and 2 by specifying two kinds of parameter settings . Note that the algorithm computes full gradient in iteration k if the minibatch bk = n. Our convergence results show that without computing any full gradients actually does not hurt the convergence performance of algorithms ( see Table 1 ) . In particular , we note that the second term of ( 5 ) will be deleted if we choose minibatch size b0 = n for the initial point x0 ( see Corollary 1 for more details ) . Here Corollary 1 only needs to compute the full gradient once for the initialization , and does not compute any full gradients later ( i.e. , bk ≡ √ n for all k > 0 ) . Also note that even if we choose b0 < n , we can also upper bound the second term of ( 5 ) . It means that ZeroSARAH can find an -approximate solution without computing any full gradients even for the initial point , i.e. , minibatch size bk < n for all iterations k ≥ 0 . For instance , we choose bk ≡ √ n for all k ≥ 0 in Corollary 2 , i.e. , ZeroSARAH never computes any full gradients even for the initial point . Corollary 1 Suppose that Assumption 1 holds . Choose stepsize ηk ≤ 1 ( 1+√8 ) L for any k ≥ 0 , minibatch size bk ≡ √ n and parameter λk = bk2n for any k ≥ 1 . Moreover , let b0 = n and λ0 = 1 . Then ZeroSARAH ( Algorithm 2 ) can find an -approximate solution for problem ( 1 ) such that E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2 and the number of stochastic gradient computations can be bounded by # grad : = K−1∑ k=0 bk ≤ n+ 2 ( 1 + √ 8 ) √ nL∆0 2 = O ( n+ √ nL∆0 2 ) . Remark : In Corollary 1 , ZeroSARAH only computes the full gradient ∇f ( x0 ) = 1n ∑n i=1∇fi ( x0 ) once for the initial point x0 , i.e. , minibatch size b0 = n , and then bk ≡ √ n for all iterations k ≥ 1 in Algorithm 2 . In the following Corollary 2 , we show that ZeroSARAH without computing any full gradients even for the initial point does not hurt its convergence performance . Corollary 2 Suppose that Assumption 1 holds . Choose stepsize ηk ≤ 1 ( 1+√8 ) L for any k ≥ 0 , minibatch size bk ≡ √ n for any k ≥ 0 , and parameter λ0 = 1 and λk = bk2n for any k ≥ 1 . Then ZeroSARAH ( Algorithm 2 ) can find an -approximate solution for problem ( 1 ) such that E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2 and the number of stochastic gradient computations can be bounded by # grad = O ( √ n ( L∆0 +G0 ) 2 ) . Note that G0 can be bounded by G0 ≤ 2L∆̂0 via L-smoothness Assumption 1 , then we also have # grad = O ( √ n ( L∆0 + L∆̂0 ) 2 ) . Remark : In Corollary 2 , ZeroSARAH never computes any full gradients even for the initial point , i.e. , minibatch size bk ≡ √ n for all iterations k ≥ 0 in Algorithm 2 . If we consider L , ∆0 , G0 or ∆̂0 as constant values then the stochastic gradient complexity in Corollary 2 is # grad = O ( √ n 2 ) , i.e. , full gradient computations do not appear in ZeroSARAH ( Algorithm 2 ) and the term ‘ n ’ also does not appear in its convergence result . Also note that the parameter settings ( i.e. , { ηk } , { bk } and { λk } in Algorithm 2 ) of Corollaries 1 and 2 are exactly the same except for b0 = n ( in Corollary 1 ) and b0 = √ n ( in Corollary 2 ) . Moreover , the parameter settings ( i.e. , { ηk } , { bk } and { λk } ) for Corollaries 1 and 2 only require the values of L and n , which is the same as all previous algorithms . If one further allows other values , e.g. , , G0 or ∆̂0 , for setting the initial b0 , then the gradient complexity can be further improved ( see Appendix D for more details ) . 5 D-ZeroSARAH ALGORITHM AND ITS CONVERGENCE RESULTS Now , we consider the distributed nonconvex problems ( 2 ) , i.e. , minx∈Rd { f ( x ) : = 1n ∑n i=1 fi ( x ) } with fi ( x ) : = 1m ∑m j=1 fi , j ( x ) , where n denotes the number of clients/devices/machines , fi denotes the loss associated with m data samples stored on client i . 5.1 D-ZeroSARAH ALGORITHM To solve distributed nonconvex problems ( 2 ) , we propose a distributed variant of ZeroSARAH ( called D-ZeroSARAH ) and describe it in Algorithm 3 . Same as our ZeroSARAH , D-ZeroSARAH also does not need to compute any full gradients at all . Avoiding any full gradient computations is important especially in this distributed setting , periodic computation of full gradient across all n clients may be impossible or unaffordable . Thus , we expect the proposed D-ZeroSARAH ( Algorithm 3 ) will have a practical impact in distributed and federated learning where full device participation is impractical . 5.2 CONVERGENCE RESULTS FOR D-ZeroSARAH Similar to ZeroSARAH in Section 4.2 , we also first present the main convergence theorem ( Theorem 2 ) of D-ZeroSARAH ( Algorithm 3 ) for solving distributed nonconvex problems ( 2 ) . Subsequently , we formulate two corollaries which present the detailed convergence results by specifying the choice of parameters . In particular , we list the results of these two Corollaries 3–4 in Table 2 for comparing with convergence results of previous works . Note that here we use the smoothness Assumption 2 instead of Assumption 1 for this distributed setting ( 2 ) . Theorem 2 Suppose that Assumption 2 holds . Choose stepsize ηk ≤ 1 L ( 1+ √ Wk+1 ) for any k ≥ 0 , whereWk+1 : = 2λk+1sk+1bk+1 + 8λk+1n 2m2 s3k+1b 3 k+1 . Moreover , let λ0 = 1 and θ0 : = nm ( nm−1 ) λ1 + 4nmλ1s0b0 s21b 2 1 . Then the following equation holds for D-ZeroSARAH ( Algorithm 3 ) for solving distributed problem ( 2 ) , for any iteration K ≥ 0 : E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2∆0∑K−1 k=0 ηk + ( nm− s0b0 ) η0θ0G′0 nms0b0 ∑K−1 k=0 ηk . ( 6 ) Algorithm 3 Distributed ZeroSARAH ( D-ZeroSARAH ) Input : initial point x0 , parameters { ηk } , { sk } , { bk } , { λk } 1 : x−1 = x0 2 : v−1 = 0 , y−11 = y −1 2 = · · · = y−1n = 0 // no full gradient computation 3 : for k = 0 , 1 , 2 , . . . do 4 : Randomly sample a subset of clients Sk from n clients with size |Sk| = sk 5 : for each client i ∈ Sk do 6 : Sample the data minibatch Ikbi ( with size |I k bi | = bk ) from the m data samples in client i 7 : Compute its local minibatch gradient information : gki , curr = 1 bk ∑ j∈Ikbi ∇fi , j ( xk ) , gki , prev = 1bk ∑ j∈Ikbi ∇fi , j ( xk−1 ) , yki , prev = 1bk ∑ j∈Ikbi yk−1i , j yki , j = { ∇fi , j ( xk ) for j ∈ Ikbi yk−1i , j for j /∈ Ikbi , yki = 1 m m∑ j=1 yki , j 8 : end for 9 : vk = 1sk ∑ i∈Sk ( gki , curr − gki , prev ) + ( 1− λk ) vk−1 + λk 1sk ∑ i∈Sk ( gki , prev − yki , prev ) + λky k−1 // no full gradient computations for vks 10 : xk+1 = xk − ηkvk 11 : yk = 1n n∑ i=1 yki // here y k i = y k−1 i for client i /∈ S k 12 : end for Corollary 3 Suppose that Assumption 2 holds . Choose stepsize ηk ≤ 1 ( 1+√8 ) L for any k ≥ 0 , clients subset size sk ≡ √ n , minibatch size bk ≡ √ m and parameter λk = skbk2nm for any k ≥ 1 . Moreover , let s0 = n , b0 = m , and λ0 = 1 . Then D-ZeroSARAH ( Algorithm 3 ) can find an -approximate solution for distributed problem ( 2 ) such that E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2 and the number of stochastic gradient computations for each client can be bounded by # grad = O ( m+ √ m n L∆0 2 ) . Corollary 4 Suppose that Assumption 2 holds . Choose stepsize ηk ≤ 1 ( 1+√8 ) L for any k ≥ 0 , clients subset size sk ≡ √ n and minibatch size bk ≡ √ m for any k ≥ 0 , and parameter λ0 = 1 and λk = skbk 2nm for any k ≥ 1 . Then D-ZeroSARAH ( Algorithm 3 ) can find an -approximate solution for distributed problem ( 2 ) such that E [ ‖∇f ( x̂K ) ‖2 ] ≤ 2 and the number of stochastic gradient computations for each client can be bounded by # grad = O ( √ m n L∆0 +G ′ 0 2 ) . Remark : Similar discussions and remarks of Theorem 1 and Corollaries 1–2 for ZeroSARAH in Section 4.2 also hold for the results of D-ZeroSARAH ( i.e. , Theorem 2 and Corollaries 3–4 ) . | This paper introduce ZeroSARAH which is a variant of variance reduced SARAH algorithm, for solving $\min_x 1/n \sum_{i=1}^n f_i(x)$ with nonconvex and smooth $f_i$. ZeroSARAH and its distributed version are the first algorithms that do not require any full gradient computations. Most algorithms for this setting either required computing the full gradient once in the beginning or periodically. The paper also argues that in distributed optimization, computation of full gradients can be a bottleneck and therefore avoiding it is important. | SP:dab48ca112e4b792d5f7579fbe020e7efd114eac |
DPP-TTS: Diversifying prosodic features of speech via determinantal point processes | 1 INTRODUCTION . In the past few years , text-to-speech models have made a lot of progress in synthesizing human-like speech ( Shen et al. , 2018 ; Ping et al. , 2018 ; Li et al. , 2019 ; Ren et al. , 2019 ) . Furthermore , in the latest studies , several text-to-speech models made high-quality speech samples even in the end-toend setting without a two-stage synthesis process ( Donahue et al. , 2021 ; Kim et al. , 2021 ) . Based on these technical developments , text-to-speech models are now able to generate high-fidelity speech . However , human speech contains many prosodic features like intonation , stress , and rhythm beyond textual features . Therefore , it is crucial to generate speech samples with rich prosody . There have been many attempts to synthesize speech with rich prosodic features . To incorporate rich prosodic features into speech , reference acoustic samples like mel-spectrograms are processed through reference encoder ( Skerry-Ryan et al. , 2018 ; Wang et al. , 2018 ) or text-to-speech models are conditioned on prosodic features like duration , pitch and energy then these features are predicted or manually controlled at inference ( Ren et al. , 2021 ; Lańcucki , 2021 ) . However , these methods have drawbacks that the bottleneck dimension should be carefully tuned for desirable results , or the prosody predictor just learns averaged prosodic features of training sets . Meanwhile , generative models like VAEs and flow models ( Hsu et al. , 2019 ; Sun et al. , 2020 ; VallésPérez et al. , 2021 ; Lee et al. , 2021 ; Valle et al. , 2021 ) have been recently used for speech synthesis and their latent spaces are manipulated for generating more expressive speech . Controlling the amount of variation in the speech is achieved by generating samples in Gaussian prior with an adequate temperature , however , it has two major drawbacks . First , generating latent samples with high variance often make generated samples to be unstable in terms of the naturalness and intelligibility of speech . Second , sampling in the latent space might only cover major modes learned during the training stage and only monotonous prosodic patterns can occur in some segments of speech . Determinantal point processes ( DPPs ) have shown great results for modeling diversity in various machine learning tasks and their applications . Its uses include text summarization ( Cho et al. , 2019 ) , recommendation systems ( Gartrell et al. , 2021 ) , multi-modal output generation ( Elfeki et al. , 2019 ) , diverse trajectory forecasting ( Yuan & Kitani , 2020 ) , and machine translation ( Meister et al. , 2021 ) . Determinantal point process ( DPPs ) offers us an efficient subset selection method by considering both the quality and diversity of items within a set . Specifically , items within a set are sampled according to DPPs kernel which reflects the quality and diversity of items in the ground set . In some cases , we may need to incorporate the conditional information into the sampling process . To this end , conditional DPP ( Kulesza & Taskar , 2012 ) has been widely used for sampling subset by setting the kernel conditioned on the specific information . To use conditional DPP for sampling prosodic features of speech , two main issues should be considered . First , prosodic features are usually varying in length . Second , it is ambiguous what the ground set is in this problem . In this work , we resolve these issues by using a new similarity metric between prosodic features and adding a prosodic diversifying module ( PDM ) into the framework . Specifically , PDM generates candidates of prosodic features of speech by mapping latent codes from normal distribution to a new latent space and these candidates are used as the ground set in the sampling process . In addition , the similarity between two prosodic features is evaluated using soft dynamic time warping discrepancy ( Soft-DTW ) ( Cuturi & Blondel , 2017 ) which enables to evaluate the similarity between features in different lengths . The kernel matrix of conditional DPP is learned during the training by parameters of PDM getting updated . Specifically , parameters of the prosody diversifying module ( PDM ) are updated in the training stage with conditional maximum induced cardinality ( MIC ) objective which is adapted from MIC objective introduced in Gillenwater et al . ( 2018 ) . We formally introduce the conditional MIC objective and its derivative for clarity in Section 4 . To implement the aforementioned DPP , a stochastic duration predictor and pitch predictor are introduced in this work . Both the duration and pitch predictor are built upon normalizing flows trained with the maximum likelihood ( MLE ) objective . At inference , the prosody predictor maps latent codes from a latent space to feature spaces with the inverse flow . In experiments , we compare DPP-TTS with the state-of-the-art models including VITS ( Kim et al. , 2021 ) and Flowtron ( Valle et al. , 2021 ) in terms of prosody diversity and speech quality . The results demonstrate that our model generates speech with richer prosody than baselines while maintaining speech naturalness . We also demonstrate that our DPP-TTS can be used in real-time applications by evaluating the inference speed of our model . In summary , our contributions follow : • We propose a novel method for diversifying prosodic features of speech based on conditional DPPs by considering prosodic features of context words as conditions . • To learn the kernel matrix of conditional DPPs , we propose to train prosody diversifying module ( PDM ) with the conditional maximum induced cardinality ( MIC ) objective . • Experiments on the side-by-side comparison and the MOS test verify that our model outperforms the two baseline models in terms of prosodic diversity while maintaining the naturalness of speech . 2 BACKGROUND . 2.1 DETERMINANTAL POINT PROCESSES . DPPs encourage diversity within a set by discouraging sampling similar items within the ground set . Formally , point process P is called a determinantal point process when Y is a random subset drawn according to P , we have , for every A ⊆ Y , P ( A ⊆ Y ) ∝ det ( KA ) , ( 1 ) whereK is a positive definite matrix whose eigenvalues are all between 0 and 1 andKA is a positive a definite matrix indexed by elements in A . The marginal probability of including two elements ei and ej is KiiKjj − K2ij = p ( ei ∈ Y ) p ( ej ∈ Y ) − K2ij . Therefore , the value of K2ij models the extent of negative correlation between item i and j . More frequently , DPPs are defined by L-ensemble through real and symmetric matrix L instead of the marginal kernelK : PL ( Y = Y ) = det ( LY ) det ( L+ I ) , ( 2 ) where det ( L+ I ) in the denominator acts as a normalization constant . The marginal kernel K and kernel L has the following relation : K = L ( L+ I ) −1 = I − ( L+ I ) −1 ( 3 ) To model diversity between items , the DPP kernelL is usually constructed as a symmetric similarity matrix , where Sij represents the similarity between two items xi and xj . In Kulesza & Taskar ( 2010 ) , authors proposed decomposing the kernel L as a a Gram matrix incorporating a quality vector to weigh each item according to its quality : P ( J ⊆ Y ) ∝ det ( φ ( J ) Tφ ( J ) ) ∏ ei∈J q2 ( ei ) = Diag ( q ) · S · Diag ( q ) , ( 4 ) where φi ∈ RD ; D ≤ N and ||φi||2 = 1 . In this manner , the similarity matrix S is guaranteed to be real positive semidefinite matrix . 2.2 CONDITIONAL DETERMINANTAL POINT PROCESSES . If DPPs are used for diversifying prosodic features by setting targets of DPPs as prosodic features of sentences , it would result in diversity among generated samples . However , there still can be monotonous patterns in each generated speech . To resolve this issue , it is required to diversify prosodic features accounting into their neighbor prosodic features . Therefore , we need conditional DPPs to take into account neighboring prosodic features ( contexts ) . By setting conditions of point process P , DPPs can be extended to conditional DPPs , For a subset B ⊆ Y not intersecting with A we have P ( Y = A ∪B|A ⊆ Y ) = P ( Y = A ∪B ) P ( A ⊆ Y ) = det ( LA∪B ) det ( L+ IĀ ) , ( 5 ) where IĀ is the matrix with ones in the diagonal entries indexed by elements of Y − A and zeros elsewhere . In Borodin & Rains ( 2004 ) , authors showed that this conditional distribution is again a DPP , with a kernel given by LA = ( [ ( L+ IĀ ) −1 ] Ā ) −1 − I . ( 6 ) In conditional DPPs , items in the ground set Y are sampled according to kernel given contexts . In this work , contexts of target words are used as conditions for conditional DPPs . 2.3 SOFT DYNAMIC TIME WARPING . To build the kernel of conditional DPPs , we need a measure of similarity between two temporal signals . Simple Euclidean distance is not applicable because two time signals often vary in their lengths . In this work , soft dynamic time warping ( Soft DTW ) discrepancy which allows measuring the similarity of shape between time series of different lengths is adapted to calculate the similarity between prosodic sequences . DTW computes the best possible alignment between two temporal signals . First , for the length of n and m signals , DTW computes n by m pairwise distance matrix between these points with a specific metric ( e.g. , Euclidean distance , L1 distance ) . After that , this matrix is used to solve the dynamic program using Bellman ’ s recursion with a quadratic O ( mn ) cost . Unfortunately , vanilla DTW cost is not easy to optimize because it only considers a single alignment between two temporal signals . Cuturi & Blondel ( 2017 ) proposed differentiable Soft-DTW which considers all possible alignments between two temporal series . Soft-DTW is differentiable in all of its arguments with quadratic cost . Formally , Soft-DTW is defined as follows : dtwγ ( x , y ) : = minγ { 〈A , δ ( x , y ) 〉 , A ∈ An , m } , ( 7 ) where An , m denotes all possible alignments between x and y and minγ is defined as minγ { a1 , ... , an } : = { mini≤nai , if γ = 0 −γ log ∑n i=1 e −ai γ , otherwise ( 8 ) A small magnitude of γ reflects the true discrepancy of two temporal signals , however , optimization becomes unstable . 3 DPP-TTS . Our model DPP-TTS is composed of a Seq2Seq module for generating the mel-spectrogram , a prosody predictor for predicting duration and pitch sequences , and a prosody diversifying module ( PDM ) . At the first stage , the base TTS model which consists of the Seq2Seq module and the prosody predictor is trained as shown in Figure 1a . Once the base TTS is trained , PDM is inserted in front of the prosody predictor and trained with the method which will be described in detail in Section 4 . We describe the main modules of DPP-TTS and their roles in the following subsection . | The goal of this paper is to build a text-to-speech model that can generate diverse prosodic features (in particular pitch and duration patterns) without sacrificing the audio quality. The authors propose to cast the prosody selection problem as a determinantal point process, which explicitly takes quality and diversity between elements into account when sampling a subset. To formulate the problem as such, the authors present a prosody diversifying module to generate candidate prosodies for selection, and use soft-DTW as the similarity metric. | SP:71b7f47d26c0abd1ee30a70f18a8ffaab5d40702 |
DPP-TTS: Diversifying prosodic features of speech via determinantal point processes | 1 INTRODUCTION . In the past few years , text-to-speech models have made a lot of progress in synthesizing human-like speech ( Shen et al. , 2018 ; Ping et al. , 2018 ; Li et al. , 2019 ; Ren et al. , 2019 ) . Furthermore , in the latest studies , several text-to-speech models made high-quality speech samples even in the end-toend setting without a two-stage synthesis process ( Donahue et al. , 2021 ; Kim et al. , 2021 ) . Based on these technical developments , text-to-speech models are now able to generate high-fidelity speech . However , human speech contains many prosodic features like intonation , stress , and rhythm beyond textual features . Therefore , it is crucial to generate speech samples with rich prosody . There have been many attempts to synthesize speech with rich prosodic features . To incorporate rich prosodic features into speech , reference acoustic samples like mel-spectrograms are processed through reference encoder ( Skerry-Ryan et al. , 2018 ; Wang et al. , 2018 ) or text-to-speech models are conditioned on prosodic features like duration , pitch and energy then these features are predicted or manually controlled at inference ( Ren et al. , 2021 ; Lańcucki , 2021 ) . However , these methods have drawbacks that the bottleneck dimension should be carefully tuned for desirable results , or the prosody predictor just learns averaged prosodic features of training sets . Meanwhile , generative models like VAEs and flow models ( Hsu et al. , 2019 ; Sun et al. , 2020 ; VallésPérez et al. , 2021 ; Lee et al. , 2021 ; Valle et al. , 2021 ) have been recently used for speech synthesis and their latent spaces are manipulated for generating more expressive speech . Controlling the amount of variation in the speech is achieved by generating samples in Gaussian prior with an adequate temperature , however , it has two major drawbacks . First , generating latent samples with high variance often make generated samples to be unstable in terms of the naturalness and intelligibility of speech . Second , sampling in the latent space might only cover major modes learned during the training stage and only monotonous prosodic patterns can occur in some segments of speech . Determinantal point processes ( DPPs ) have shown great results for modeling diversity in various machine learning tasks and their applications . Its uses include text summarization ( Cho et al. , 2019 ) , recommendation systems ( Gartrell et al. , 2021 ) , multi-modal output generation ( Elfeki et al. , 2019 ) , diverse trajectory forecasting ( Yuan & Kitani , 2020 ) , and machine translation ( Meister et al. , 2021 ) . Determinantal point process ( DPPs ) offers us an efficient subset selection method by considering both the quality and diversity of items within a set . Specifically , items within a set are sampled according to DPPs kernel which reflects the quality and diversity of items in the ground set . In some cases , we may need to incorporate the conditional information into the sampling process . To this end , conditional DPP ( Kulesza & Taskar , 2012 ) has been widely used for sampling subset by setting the kernel conditioned on the specific information . To use conditional DPP for sampling prosodic features of speech , two main issues should be considered . First , prosodic features are usually varying in length . Second , it is ambiguous what the ground set is in this problem . In this work , we resolve these issues by using a new similarity metric between prosodic features and adding a prosodic diversifying module ( PDM ) into the framework . Specifically , PDM generates candidates of prosodic features of speech by mapping latent codes from normal distribution to a new latent space and these candidates are used as the ground set in the sampling process . In addition , the similarity between two prosodic features is evaluated using soft dynamic time warping discrepancy ( Soft-DTW ) ( Cuturi & Blondel , 2017 ) which enables to evaluate the similarity between features in different lengths . The kernel matrix of conditional DPP is learned during the training by parameters of PDM getting updated . Specifically , parameters of the prosody diversifying module ( PDM ) are updated in the training stage with conditional maximum induced cardinality ( MIC ) objective which is adapted from MIC objective introduced in Gillenwater et al . ( 2018 ) . We formally introduce the conditional MIC objective and its derivative for clarity in Section 4 . To implement the aforementioned DPP , a stochastic duration predictor and pitch predictor are introduced in this work . Both the duration and pitch predictor are built upon normalizing flows trained with the maximum likelihood ( MLE ) objective . At inference , the prosody predictor maps latent codes from a latent space to feature spaces with the inverse flow . In experiments , we compare DPP-TTS with the state-of-the-art models including VITS ( Kim et al. , 2021 ) and Flowtron ( Valle et al. , 2021 ) in terms of prosody diversity and speech quality . The results demonstrate that our model generates speech with richer prosody than baselines while maintaining speech naturalness . We also demonstrate that our DPP-TTS can be used in real-time applications by evaluating the inference speed of our model . In summary , our contributions follow : • We propose a novel method for diversifying prosodic features of speech based on conditional DPPs by considering prosodic features of context words as conditions . • To learn the kernel matrix of conditional DPPs , we propose to train prosody diversifying module ( PDM ) with the conditional maximum induced cardinality ( MIC ) objective . • Experiments on the side-by-side comparison and the MOS test verify that our model outperforms the two baseline models in terms of prosodic diversity while maintaining the naturalness of speech . 2 BACKGROUND . 2.1 DETERMINANTAL POINT PROCESSES . DPPs encourage diversity within a set by discouraging sampling similar items within the ground set . Formally , point process P is called a determinantal point process when Y is a random subset drawn according to P , we have , for every A ⊆ Y , P ( A ⊆ Y ) ∝ det ( KA ) , ( 1 ) whereK is a positive definite matrix whose eigenvalues are all between 0 and 1 andKA is a positive a definite matrix indexed by elements in A . The marginal probability of including two elements ei and ej is KiiKjj − K2ij = p ( ei ∈ Y ) p ( ej ∈ Y ) − K2ij . Therefore , the value of K2ij models the extent of negative correlation between item i and j . More frequently , DPPs are defined by L-ensemble through real and symmetric matrix L instead of the marginal kernelK : PL ( Y = Y ) = det ( LY ) det ( L+ I ) , ( 2 ) where det ( L+ I ) in the denominator acts as a normalization constant . The marginal kernel K and kernel L has the following relation : K = L ( L+ I ) −1 = I − ( L+ I ) −1 ( 3 ) To model diversity between items , the DPP kernelL is usually constructed as a symmetric similarity matrix , where Sij represents the similarity between two items xi and xj . In Kulesza & Taskar ( 2010 ) , authors proposed decomposing the kernel L as a a Gram matrix incorporating a quality vector to weigh each item according to its quality : P ( J ⊆ Y ) ∝ det ( φ ( J ) Tφ ( J ) ) ∏ ei∈J q2 ( ei ) = Diag ( q ) · S · Diag ( q ) , ( 4 ) where φi ∈ RD ; D ≤ N and ||φi||2 = 1 . In this manner , the similarity matrix S is guaranteed to be real positive semidefinite matrix . 2.2 CONDITIONAL DETERMINANTAL POINT PROCESSES . If DPPs are used for diversifying prosodic features by setting targets of DPPs as prosodic features of sentences , it would result in diversity among generated samples . However , there still can be monotonous patterns in each generated speech . To resolve this issue , it is required to diversify prosodic features accounting into their neighbor prosodic features . Therefore , we need conditional DPPs to take into account neighboring prosodic features ( contexts ) . By setting conditions of point process P , DPPs can be extended to conditional DPPs , For a subset B ⊆ Y not intersecting with A we have P ( Y = A ∪B|A ⊆ Y ) = P ( Y = A ∪B ) P ( A ⊆ Y ) = det ( LA∪B ) det ( L+ IĀ ) , ( 5 ) where IĀ is the matrix with ones in the diagonal entries indexed by elements of Y − A and zeros elsewhere . In Borodin & Rains ( 2004 ) , authors showed that this conditional distribution is again a DPP , with a kernel given by LA = ( [ ( L+ IĀ ) −1 ] Ā ) −1 − I . ( 6 ) In conditional DPPs , items in the ground set Y are sampled according to kernel given contexts . In this work , contexts of target words are used as conditions for conditional DPPs . 2.3 SOFT DYNAMIC TIME WARPING . To build the kernel of conditional DPPs , we need a measure of similarity between two temporal signals . Simple Euclidean distance is not applicable because two time signals often vary in their lengths . In this work , soft dynamic time warping ( Soft DTW ) discrepancy which allows measuring the similarity of shape between time series of different lengths is adapted to calculate the similarity between prosodic sequences . DTW computes the best possible alignment between two temporal signals . First , for the length of n and m signals , DTW computes n by m pairwise distance matrix between these points with a specific metric ( e.g. , Euclidean distance , L1 distance ) . After that , this matrix is used to solve the dynamic program using Bellman ’ s recursion with a quadratic O ( mn ) cost . Unfortunately , vanilla DTW cost is not easy to optimize because it only considers a single alignment between two temporal signals . Cuturi & Blondel ( 2017 ) proposed differentiable Soft-DTW which considers all possible alignments between two temporal series . Soft-DTW is differentiable in all of its arguments with quadratic cost . Formally , Soft-DTW is defined as follows : dtwγ ( x , y ) : = minγ { 〈A , δ ( x , y ) 〉 , A ∈ An , m } , ( 7 ) where An , m denotes all possible alignments between x and y and minγ is defined as minγ { a1 , ... , an } : = { mini≤nai , if γ = 0 −γ log ∑n i=1 e −ai γ , otherwise ( 8 ) A small magnitude of γ reflects the true discrepancy of two temporal signals , however , optimization becomes unstable . 3 DPP-TTS . Our model DPP-TTS is composed of a Seq2Seq module for generating the mel-spectrogram , a prosody predictor for predicting duration and pitch sequences , and a prosody diversifying module ( PDM ) . At the first stage , the base TTS model which consists of the Seq2Seq module and the prosody predictor is trained as shown in Figure 1a . Once the base TTS is trained , PDM is inserted in front of the prosody predictor and trained with the method which will be described in detail in Section 4 . We describe the main modules of DPP-TTS and their roles in the following subsection . | This paper addresses the problem of generating expressive speech using Determinantal Point Processes (DPP). Compared to a baseline Fastspeech2 baseline, the authors extend the duration and pitch predictors with a DPP model to favor more diverse candidates. Given that such candidates are variable-length sequences, comparing them is conducted through the differentiable soft-DTW algorithm. The paper shows Mean Opinion Scores (MOS) comparing the proposed approach against the ground-truth audio and two strong models for naturalness. Subjective studies were also conducted to measure the system's ability to generate more speech variability than baselines. | SP:71b7f47d26c0abd1ee30a70f18a8ffaab5d40702 |
DPP-TTS: Diversifying prosodic features of speech via determinantal point processes | 1 INTRODUCTION . In the past few years , text-to-speech models have made a lot of progress in synthesizing human-like speech ( Shen et al. , 2018 ; Ping et al. , 2018 ; Li et al. , 2019 ; Ren et al. , 2019 ) . Furthermore , in the latest studies , several text-to-speech models made high-quality speech samples even in the end-toend setting without a two-stage synthesis process ( Donahue et al. , 2021 ; Kim et al. , 2021 ) . Based on these technical developments , text-to-speech models are now able to generate high-fidelity speech . However , human speech contains many prosodic features like intonation , stress , and rhythm beyond textual features . Therefore , it is crucial to generate speech samples with rich prosody . There have been many attempts to synthesize speech with rich prosodic features . To incorporate rich prosodic features into speech , reference acoustic samples like mel-spectrograms are processed through reference encoder ( Skerry-Ryan et al. , 2018 ; Wang et al. , 2018 ) or text-to-speech models are conditioned on prosodic features like duration , pitch and energy then these features are predicted or manually controlled at inference ( Ren et al. , 2021 ; Lańcucki , 2021 ) . However , these methods have drawbacks that the bottleneck dimension should be carefully tuned for desirable results , or the prosody predictor just learns averaged prosodic features of training sets . Meanwhile , generative models like VAEs and flow models ( Hsu et al. , 2019 ; Sun et al. , 2020 ; VallésPérez et al. , 2021 ; Lee et al. , 2021 ; Valle et al. , 2021 ) have been recently used for speech synthesis and their latent spaces are manipulated for generating more expressive speech . Controlling the amount of variation in the speech is achieved by generating samples in Gaussian prior with an adequate temperature , however , it has two major drawbacks . First , generating latent samples with high variance often make generated samples to be unstable in terms of the naturalness and intelligibility of speech . Second , sampling in the latent space might only cover major modes learned during the training stage and only monotonous prosodic patterns can occur in some segments of speech . Determinantal point processes ( DPPs ) have shown great results for modeling diversity in various machine learning tasks and their applications . Its uses include text summarization ( Cho et al. , 2019 ) , recommendation systems ( Gartrell et al. , 2021 ) , multi-modal output generation ( Elfeki et al. , 2019 ) , diverse trajectory forecasting ( Yuan & Kitani , 2020 ) , and machine translation ( Meister et al. , 2021 ) . Determinantal point process ( DPPs ) offers us an efficient subset selection method by considering both the quality and diversity of items within a set . Specifically , items within a set are sampled according to DPPs kernel which reflects the quality and diversity of items in the ground set . In some cases , we may need to incorporate the conditional information into the sampling process . To this end , conditional DPP ( Kulesza & Taskar , 2012 ) has been widely used for sampling subset by setting the kernel conditioned on the specific information . To use conditional DPP for sampling prosodic features of speech , two main issues should be considered . First , prosodic features are usually varying in length . Second , it is ambiguous what the ground set is in this problem . In this work , we resolve these issues by using a new similarity metric between prosodic features and adding a prosodic diversifying module ( PDM ) into the framework . Specifically , PDM generates candidates of prosodic features of speech by mapping latent codes from normal distribution to a new latent space and these candidates are used as the ground set in the sampling process . In addition , the similarity between two prosodic features is evaluated using soft dynamic time warping discrepancy ( Soft-DTW ) ( Cuturi & Blondel , 2017 ) which enables to evaluate the similarity between features in different lengths . The kernel matrix of conditional DPP is learned during the training by parameters of PDM getting updated . Specifically , parameters of the prosody diversifying module ( PDM ) are updated in the training stage with conditional maximum induced cardinality ( MIC ) objective which is adapted from MIC objective introduced in Gillenwater et al . ( 2018 ) . We formally introduce the conditional MIC objective and its derivative for clarity in Section 4 . To implement the aforementioned DPP , a stochastic duration predictor and pitch predictor are introduced in this work . Both the duration and pitch predictor are built upon normalizing flows trained with the maximum likelihood ( MLE ) objective . At inference , the prosody predictor maps latent codes from a latent space to feature spaces with the inverse flow . In experiments , we compare DPP-TTS with the state-of-the-art models including VITS ( Kim et al. , 2021 ) and Flowtron ( Valle et al. , 2021 ) in terms of prosody diversity and speech quality . The results demonstrate that our model generates speech with richer prosody than baselines while maintaining speech naturalness . We also demonstrate that our DPP-TTS can be used in real-time applications by evaluating the inference speed of our model . In summary , our contributions follow : • We propose a novel method for diversifying prosodic features of speech based on conditional DPPs by considering prosodic features of context words as conditions . • To learn the kernel matrix of conditional DPPs , we propose to train prosody diversifying module ( PDM ) with the conditional maximum induced cardinality ( MIC ) objective . • Experiments on the side-by-side comparison and the MOS test verify that our model outperforms the two baseline models in terms of prosodic diversity while maintaining the naturalness of speech . 2 BACKGROUND . 2.1 DETERMINANTAL POINT PROCESSES . DPPs encourage diversity within a set by discouraging sampling similar items within the ground set . Formally , point process P is called a determinantal point process when Y is a random subset drawn according to P , we have , for every A ⊆ Y , P ( A ⊆ Y ) ∝ det ( KA ) , ( 1 ) whereK is a positive definite matrix whose eigenvalues are all between 0 and 1 andKA is a positive a definite matrix indexed by elements in A . The marginal probability of including two elements ei and ej is KiiKjj − K2ij = p ( ei ∈ Y ) p ( ej ∈ Y ) − K2ij . Therefore , the value of K2ij models the extent of negative correlation between item i and j . More frequently , DPPs are defined by L-ensemble through real and symmetric matrix L instead of the marginal kernelK : PL ( Y = Y ) = det ( LY ) det ( L+ I ) , ( 2 ) where det ( L+ I ) in the denominator acts as a normalization constant . The marginal kernel K and kernel L has the following relation : K = L ( L+ I ) −1 = I − ( L+ I ) −1 ( 3 ) To model diversity between items , the DPP kernelL is usually constructed as a symmetric similarity matrix , where Sij represents the similarity between two items xi and xj . In Kulesza & Taskar ( 2010 ) , authors proposed decomposing the kernel L as a a Gram matrix incorporating a quality vector to weigh each item according to its quality : P ( J ⊆ Y ) ∝ det ( φ ( J ) Tφ ( J ) ) ∏ ei∈J q2 ( ei ) = Diag ( q ) · S · Diag ( q ) , ( 4 ) where φi ∈ RD ; D ≤ N and ||φi||2 = 1 . In this manner , the similarity matrix S is guaranteed to be real positive semidefinite matrix . 2.2 CONDITIONAL DETERMINANTAL POINT PROCESSES . If DPPs are used for diversifying prosodic features by setting targets of DPPs as prosodic features of sentences , it would result in diversity among generated samples . However , there still can be monotonous patterns in each generated speech . To resolve this issue , it is required to diversify prosodic features accounting into their neighbor prosodic features . Therefore , we need conditional DPPs to take into account neighboring prosodic features ( contexts ) . By setting conditions of point process P , DPPs can be extended to conditional DPPs , For a subset B ⊆ Y not intersecting with A we have P ( Y = A ∪B|A ⊆ Y ) = P ( Y = A ∪B ) P ( A ⊆ Y ) = det ( LA∪B ) det ( L+ IĀ ) , ( 5 ) where IĀ is the matrix with ones in the diagonal entries indexed by elements of Y − A and zeros elsewhere . In Borodin & Rains ( 2004 ) , authors showed that this conditional distribution is again a DPP , with a kernel given by LA = ( [ ( L+ IĀ ) −1 ] Ā ) −1 − I . ( 6 ) In conditional DPPs , items in the ground set Y are sampled according to kernel given contexts . In this work , contexts of target words are used as conditions for conditional DPPs . 2.3 SOFT DYNAMIC TIME WARPING . To build the kernel of conditional DPPs , we need a measure of similarity between two temporal signals . Simple Euclidean distance is not applicable because two time signals often vary in their lengths . In this work , soft dynamic time warping ( Soft DTW ) discrepancy which allows measuring the similarity of shape between time series of different lengths is adapted to calculate the similarity between prosodic sequences . DTW computes the best possible alignment between two temporal signals . First , for the length of n and m signals , DTW computes n by m pairwise distance matrix between these points with a specific metric ( e.g. , Euclidean distance , L1 distance ) . After that , this matrix is used to solve the dynamic program using Bellman ’ s recursion with a quadratic O ( mn ) cost . Unfortunately , vanilla DTW cost is not easy to optimize because it only considers a single alignment between two temporal signals . Cuturi & Blondel ( 2017 ) proposed differentiable Soft-DTW which considers all possible alignments between two temporal series . Soft-DTW is differentiable in all of its arguments with quadratic cost . Formally , Soft-DTW is defined as follows : dtwγ ( x , y ) : = minγ { 〈A , δ ( x , y ) 〉 , A ∈ An , m } , ( 7 ) where An , m denotes all possible alignments between x and y and minγ is defined as minγ { a1 , ... , an } : = { mini≤nai , if γ = 0 −γ log ∑n i=1 e −ai γ , otherwise ( 8 ) A small magnitude of γ reflects the true discrepancy of two temporal signals , however , optimization becomes unstable . 3 DPP-TTS . Our model DPP-TTS is composed of a Seq2Seq module for generating the mel-spectrogram , a prosody predictor for predicting duration and pitch sequences , and a prosody diversifying module ( PDM ) . At the first stage , the base TTS model which consists of the Seq2Seq module and the prosody predictor is trained as shown in Figure 1a . Once the base TTS is trained , PDM is inserted in front of the prosody predictor and trained with the method which will be described in detail in Section 4 . We describe the main modules of DPP-TTS and their roles in the following subsection . | The paper addresses the challenge of synthesizing diverse prosody in text-to-speech systems. Most recent works have now successfully modeled human speech but the delivery usually ends up being monotonous or the average of the training set, and that is the problem that this paper attempts to solve. The authors propose a prosody diversifying module (PDM) which is based on conditional determinantal point processes (DPP). This module is utilized in tandem with a Fastspeech 2-based TTS model. They modified the base TTS model to incorporate a stochastic duration and pitch predictor. Once this TTS model is trained, the PDM model is trained separately using the prosody feature predictors and text encoder. The authors focus only on noun phrases for where the PDM operates on to diversify prosody. Additionally, the authors use soft-DTW cost to measure the distance between predicted prosody features for context and focused-on phrases which is vital to the construction of the DPP kernel. The authors compare their approach to other methods of TTS which claim to have prosodic diversity, i.e. VITS and Flowtron. They compare the diversity as well as the naturalness of the samples. The DPP model generally outperforms the baselines in terms of diversity but suffers from loss of naturalness. | SP:71b7f47d26c0abd1ee30a70f18a8ffaab5d40702 |
Non-deep Networks | 1 INTRODUCTION . Deep Neural Networks ( DNNs ) have revolutionized the fields of machine learning , computer vision , and natural language processing . As their name suggests , a key characteristic of DNNs is that they are deep . That is , they have a large depth , which can be defined as the length of the longest path from an input neuron to an output neuron . Often a neural network can be described as a linear sequence of layers , i.e . groups of neurons with no intra-group connections . In such cases , the depth of a network is its number of layers . It has been generally accepted that large depth is an essential component for high-performing networks because depth increases the representational ability of a network and helps learn increasingly abstract features ( He et al. , 2016a ) . In fact , one of the primary reasons given for the success of ResNets is that they allow training very deep networks with as many as 1000 layers ( He et al. , 2016a ) . As such , state-of-the-art performance is increasingly achieved by training models with large depth , and what qualifies as “ deep ” has shifted from “ 2 or more layers ” in the early days of deep learning to the “ tens or hundreds of layers ” routinely used in today ’ s models . For example , as shown in Figure 1 , competitive benchmarks such as ImageNet are dominated by very deep models ( He et al. , 2016a ; Huang et al. , 2017 ; Tan & Le , 2019 ) with at least 30 layers , whereas models with fewer than 30 layers perform substantially worse . The best-performing model with fewer than 20 layers has a top-1 accuracy of only 75.2 , substantially lower than accuracies achievable with 30 or more layers when evaluated with a single image crop ( He et al. , 2015 ; Tan & Le , 2019 ) . But is large depth always necessary ? This question is worth asking because large depth is not without drawbacks . A deeper network leads to more sequential processing and higher latency ; it is harder to parallelize and less suitable for applications that require fast responses . In this paper , we study whether it is possible to achieve high performance with “ non-deep ” neural networks , especially networks with ∼10 layers . We find that , contrary to conventional wisdom , this is indeed possible . We present a network design that is non-deep and performs competitively against its deep counterparts . We refer to our architecture as ParNet ( Parallel Networks ) . We show , for the first time , that a classification network with a depth of just 12 can achieve accuracy greater than 80 % on ImageNet , 96 % on CIFAR10 , and 81 % on CIFAR100 . We also show that a detection network with a low-depth ( 12 ) backbone can achieve an AP of 48 % on MS-COCO . Note that the number of parameters in ParNet is comparable to state-of-the-art models , as illustrated in Figure 1 . A key design choice in ParNet is the use of parallel subnetworks . Instead of arranging layers sequentially , we arrange layers in parallel subnetworks . This design is “ embarrassingly parallel ” , in the sense that there are no connections between the subnetworks except at the beginning and the end . This allows us to reduce the depth of the network while maintaining high accuracy . It is worth noting that our parallel structures are distinct from “ widening ” a network by increasing the number of neurons in a layer . ParNet not only helps us answer a scientific question about the necessity of large depth , but also offers practical advantages . Due to the parallel substructures , ParNet can be efficiently parallelized across multiple processors . We find that ParNet can be effectively parallelized and outperforms ResNets in terms of both speed and accuracy . Note that this is achieved despite the extra latency introduced by the communication between processing units . This shows that in the future , with possibly specialized hardware to further mitigate communication latency , ParNet-like architectures could be used for creating extremely fast recognition systems . We also study the scaling rules for ParNet . Specifically , we show that ParNet can be effectively scaled by increasing width , resolution , and number of branches , all while keeping depth constant . We observe that the performance of ParNet does not saturate and increases as we increase computational throughput . This suggests that by increasing compute further , one can achieve even higher performance while maintaining small depth ( ∼10 ) and low latency . To summarize , our contributions are three-fold : • We show , for the first time , that a neural network with a depth of only 12 can achieve high performance on very competitive benchmarks ( 80.7 % on ImageNet , 96 % on CIFAR10 , 81 % on CIFAR100 ) . • We show how parallel structures in ParNet can be utilized for fast , low-latency inference . • We study the scaling rules for ParNet and demonstrate effective scaling with constant low depth . 2 RELATED WORK . Analyzing importance of depth . There exists a rich literature analyzing the importance of depth in neural networks . The classic work of Cybenko et al . showed that a single-layer neural network with sigmoid activations can approximate any function with arbitrarily small error ( Cybenko , 1989 ) . However , one needs to use a network with sufficiently large width , which can drastically increase the parameter count . Subsequent works have shown that , to approximate a function , a deep network with non-linearity needs exponentially fewer parameters than its shallow counterpart ( Liang & Srikant , 2017 ) . This is often cited as one of the major advantages of large depth . Several works have also empirically analyzed the importance of depth and came to the conclusion that under a fixed parameter budget , deeper networks perform better than their shallow counter- parts ( Eigen et al. , 2013 ; Urban et al. , 2017 ) . However , in such analysis , prior works have only studied shallow networks with a linear , sequential structure , and it is unclear whether the conclusion still holds with alternative designs . In this work , we show that , contrary to conventional wisdom , a shallow network can perform surprisingly well , and the key is to have parallel substructures . Scaling DNNs . There have been many exciting works that have studied the problem of scaling neural networks . Tan & Le ( 2019 ) showed that increasing depth , width , and resolution leads to effective scaling of convolutional networks . We also study scaling rules but focus on the low-depth regime . We find that one can increase the number of branches , width , and resolution to effectively scale ParNet while keeping depth constant and low . Zagoruyko & Komodakis ( 2016 ) showed that shallower networks with a large width can achieve similar performance to deeper ResNets . We also scale our networks by increasing their width . However , we consider networks that are much shallower – a depth of just 12 compared to 50 considered for ImageNet by Zagoruyko & Komodakis ( 2016 ) – and introduce parallel substructures . Shallow networks . Shallow networks have attracted attention in theoretical machine learning . With infinite width , a single-layer neural network behaves like a Gaussian Process , and one can understand the training procedure in terms of kernel methods ( Jacot et al. , 2018 ) . However , such models do not perform competitively when compared to state-of-the-art networks ( Li et al. , 2019 ) . We provide empirical proof that non-deep networks can be competitive with their deep counterparts . Multi-stream networks . Multi-stream neural networks have been used in a variety of computer vision tasks such as segmentation ( Chen et al. , 2016 ; 2017 ) , detection ( Lin et al. , 2017 ) , and video classification ( Wu et al. , 2016 ) . The HRNet architecture maintains multi-resolution streams throughout the forward pass ( Wang et al. , 2020 ) ; these streams are fused together at regular intervals to exchange information . We also use streams with different resolutions , but our network is much shallower ( 12 vs. 38 for the smallest HRNet for classification ) and the streams are fused only once , at the very end , making parallelization easier . 3 METHOD . In this section , we develop and analyze ParNet , a network architecture that is much less deep but still achieves high performance on competitive benchmarks . ParNet consists of parallel substructures that process features at different resolutions . We refer to these parallel substructures as streams . Features from different streams are fused at a later stage in the network , and these fused features are used for the downstream task . Figure 2a provides a schematic representation of ParNet . 3.1 PARNET BLOCK . In ParNet , we utilize VGG-style blocks ( Simonyan & Zisserman , 2015 ) . To see whether non-deep networks can achieve high performance , we empirically find that VGG-style blocks are more suitable than ResNet-style blocks ( Table 8 ) . In general , training VGG-style networks is more difficult than their ResNet counterparts ( He et al. , 2016a ) . But recent work shows that it is easier to train net- works with such blocks if one uses a “ structural reparameterization ” technique ( Ding et al. , 2021 ) . During training , one uses multiple branches over the 3×3 convolution blocks . Once trained , the multiple branches can be fused into one 3×3 convolution . Hence , one ends up with a plain network consisting of only 3×3 block and non-linearity . This reparameterization or fusion of blocks helps reduce latency during inference . We borrow our initial block design from Rep-VGG ( Ding et al. , 2021 ) and modify it to make it more suitable for our non-deep architecture . One challenge with a non-deep network with only 3×3 convolutions is that the receptive field is rather limited . To address this , we build a SkipSqueeze-Excitation ( SSE ) layer which is based on the Squeeze-and-Excitation ( SE ) design ( Hu et al. , 2018 ) . Vanilla Squeeze-and-Excitation is not suitable for our purpose as it increases the depth of the network . Hence we use a Skip-Squeeze-Excitation design which is applied alongside the skip connection and uses a single fully-connected layer . We find that this design helps increase performance ( Table 7 ) . Figure 2b provides a schematic representation of our modified Rep-VGG block with the Skip-Squeeze-Excitation module . We refer to this block as the RepVGG-SSE . One concern , especially with large-scale datasets such as ImageNet , is that a non-deep network may not have sufficient non-linearity , limiting its representational power . Thus we replace the ReLU activation with SiLU ( Ramachandran et al. , 2017 ) . 3.2 DOWNSAMPLING AND FUSION BLOCK . Apart from the RepVGG-SSE block , whose input and output have the same size , ParNet also contains Downsampling and Fusion blocks . The Downsampling block reduces resolution and increases width to enable multi-scale processing , while the Fusion block combines information from multiple resolutions . In the Downsampling block , there is no skip connection ; instead , we add a single-layered SE module parallel to the convolution layer . Additionally , we add 2D average pooling in the 1×1 convolution branch . The Fusion block is similar to the Downsampling block but contains an extra concatenation layer . Because of concatenation , the input to the Fusion block has twice as many channels as a Downsampling block . Hence , to reduce the parameter count , we use convolution with group 2 . Please refer to Figure A1 in the appendix for a schematic representation of the Downsampling and Fusion blocks . | The paper proposes to manually design a new 12-depth CNN architecture ParNet based on parallel subnetworks instead of traditionally deeply stacked blocks. Experiments show that ParNet is the first CNN achieving over 80% accuracy on ImageNet with 12 depth only. ParNet also achieves a competitive AP of 48% on MS-COCO for object detection. | SP:22acf52a7e17f34145c127491d0ed9219916a81f |
Non-deep Networks | 1 INTRODUCTION . Deep Neural Networks ( DNNs ) have revolutionized the fields of machine learning , computer vision , and natural language processing . As their name suggests , a key characteristic of DNNs is that they are deep . That is , they have a large depth , which can be defined as the length of the longest path from an input neuron to an output neuron . Often a neural network can be described as a linear sequence of layers , i.e . groups of neurons with no intra-group connections . In such cases , the depth of a network is its number of layers . It has been generally accepted that large depth is an essential component for high-performing networks because depth increases the representational ability of a network and helps learn increasingly abstract features ( He et al. , 2016a ) . In fact , one of the primary reasons given for the success of ResNets is that they allow training very deep networks with as many as 1000 layers ( He et al. , 2016a ) . As such , state-of-the-art performance is increasingly achieved by training models with large depth , and what qualifies as “ deep ” has shifted from “ 2 or more layers ” in the early days of deep learning to the “ tens or hundreds of layers ” routinely used in today ’ s models . For example , as shown in Figure 1 , competitive benchmarks such as ImageNet are dominated by very deep models ( He et al. , 2016a ; Huang et al. , 2017 ; Tan & Le , 2019 ) with at least 30 layers , whereas models with fewer than 30 layers perform substantially worse . The best-performing model with fewer than 20 layers has a top-1 accuracy of only 75.2 , substantially lower than accuracies achievable with 30 or more layers when evaluated with a single image crop ( He et al. , 2015 ; Tan & Le , 2019 ) . But is large depth always necessary ? This question is worth asking because large depth is not without drawbacks . A deeper network leads to more sequential processing and higher latency ; it is harder to parallelize and less suitable for applications that require fast responses . In this paper , we study whether it is possible to achieve high performance with “ non-deep ” neural networks , especially networks with ∼10 layers . We find that , contrary to conventional wisdom , this is indeed possible . We present a network design that is non-deep and performs competitively against its deep counterparts . We refer to our architecture as ParNet ( Parallel Networks ) . We show , for the first time , that a classification network with a depth of just 12 can achieve accuracy greater than 80 % on ImageNet , 96 % on CIFAR10 , and 81 % on CIFAR100 . We also show that a detection network with a low-depth ( 12 ) backbone can achieve an AP of 48 % on MS-COCO . Note that the number of parameters in ParNet is comparable to state-of-the-art models , as illustrated in Figure 1 . A key design choice in ParNet is the use of parallel subnetworks . Instead of arranging layers sequentially , we arrange layers in parallel subnetworks . This design is “ embarrassingly parallel ” , in the sense that there are no connections between the subnetworks except at the beginning and the end . This allows us to reduce the depth of the network while maintaining high accuracy . It is worth noting that our parallel structures are distinct from “ widening ” a network by increasing the number of neurons in a layer . ParNet not only helps us answer a scientific question about the necessity of large depth , but also offers practical advantages . Due to the parallel substructures , ParNet can be efficiently parallelized across multiple processors . We find that ParNet can be effectively parallelized and outperforms ResNets in terms of both speed and accuracy . Note that this is achieved despite the extra latency introduced by the communication between processing units . This shows that in the future , with possibly specialized hardware to further mitigate communication latency , ParNet-like architectures could be used for creating extremely fast recognition systems . We also study the scaling rules for ParNet . Specifically , we show that ParNet can be effectively scaled by increasing width , resolution , and number of branches , all while keeping depth constant . We observe that the performance of ParNet does not saturate and increases as we increase computational throughput . This suggests that by increasing compute further , one can achieve even higher performance while maintaining small depth ( ∼10 ) and low latency . To summarize , our contributions are three-fold : • We show , for the first time , that a neural network with a depth of only 12 can achieve high performance on very competitive benchmarks ( 80.7 % on ImageNet , 96 % on CIFAR10 , 81 % on CIFAR100 ) . • We show how parallel structures in ParNet can be utilized for fast , low-latency inference . • We study the scaling rules for ParNet and demonstrate effective scaling with constant low depth . 2 RELATED WORK . Analyzing importance of depth . There exists a rich literature analyzing the importance of depth in neural networks . The classic work of Cybenko et al . showed that a single-layer neural network with sigmoid activations can approximate any function with arbitrarily small error ( Cybenko , 1989 ) . However , one needs to use a network with sufficiently large width , which can drastically increase the parameter count . Subsequent works have shown that , to approximate a function , a deep network with non-linearity needs exponentially fewer parameters than its shallow counterpart ( Liang & Srikant , 2017 ) . This is often cited as one of the major advantages of large depth . Several works have also empirically analyzed the importance of depth and came to the conclusion that under a fixed parameter budget , deeper networks perform better than their shallow counter- parts ( Eigen et al. , 2013 ; Urban et al. , 2017 ) . However , in such analysis , prior works have only studied shallow networks with a linear , sequential structure , and it is unclear whether the conclusion still holds with alternative designs . In this work , we show that , contrary to conventional wisdom , a shallow network can perform surprisingly well , and the key is to have parallel substructures . Scaling DNNs . There have been many exciting works that have studied the problem of scaling neural networks . Tan & Le ( 2019 ) showed that increasing depth , width , and resolution leads to effective scaling of convolutional networks . We also study scaling rules but focus on the low-depth regime . We find that one can increase the number of branches , width , and resolution to effectively scale ParNet while keeping depth constant and low . Zagoruyko & Komodakis ( 2016 ) showed that shallower networks with a large width can achieve similar performance to deeper ResNets . We also scale our networks by increasing their width . However , we consider networks that are much shallower – a depth of just 12 compared to 50 considered for ImageNet by Zagoruyko & Komodakis ( 2016 ) – and introduce parallel substructures . Shallow networks . Shallow networks have attracted attention in theoretical machine learning . With infinite width , a single-layer neural network behaves like a Gaussian Process , and one can understand the training procedure in terms of kernel methods ( Jacot et al. , 2018 ) . However , such models do not perform competitively when compared to state-of-the-art networks ( Li et al. , 2019 ) . We provide empirical proof that non-deep networks can be competitive with their deep counterparts . Multi-stream networks . Multi-stream neural networks have been used in a variety of computer vision tasks such as segmentation ( Chen et al. , 2016 ; 2017 ) , detection ( Lin et al. , 2017 ) , and video classification ( Wu et al. , 2016 ) . The HRNet architecture maintains multi-resolution streams throughout the forward pass ( Wang et al. , 2020 ) ; these streams are fused together at regular intervals to exchange information . We also use streams with different resolutions , but our network is much shallower ( 12 vs. 38 for the smallest HRNet for classification ) and the streams are fused only once , at the very end , making parallelization easier . 3 METHOD . In this section , we develop and analyze ParNet , a network architecture that is much less deep but still achieves high performance on competitive benchmarks . ParNet consists of parallel substructures that process features at different resolutions . We refer to these parallel substructures as streams . Features from different streams are fused at a later stage in the network , and these fused features are used for the downstream task . Figure 2a provides a schematic representation of ParNet . 3.1 PARNET BLOCK . In ParNet , we utilize VGG-style blocks ( Simonyan & Zisserman , 2015 ) . To see whether non-deep networks can achieve high performance , we empirically find that VGG-style blocks are more suitable than ResNet-style blocks ( Table 8 ) . In general , training VGG-style networks is more difficult than their ResNet counterparts ( He et al. , 2016a ) . But recent work shows that it is easier to train net- works with such blocks if one uses a “ structural reparameterization ” technique ( Ding et al. , 2021 ) . During training , one uses multiple branches over the 3×3 convolution blocks . Once trained , the multiple branches can be fused into one 3×3 convolution . Hence , one ends up with a plain network consisting of only 3×3 block and non-linearity . This reparameterization or fusion of blocks helps reduce latency during inference . We borrow our initial block design from Rep-VGG ( Ding et al. , 2021 ) and modify it to make it more suitable for our non-deep architecture . One challenge with a non-deep network with only 3×3 convolutions is that the receptive field is rather limited . To address this , we build a SkipSqueeze-Excitation ( SSE ) layer which is based on the Squeeze-and-Excitation ( SE ) design ( Hu et al. , 2018 ) . Vanilla Squeeze-and-Excitation is not suitable for our purpose as it increases the depth of the network . Hence we use a Skip-Squeeze-Excitation design which is applied alongside the skip connection and uses a single fully-connected layer . We find that this design helps increase performance ( Table 7 ) . Figure 2b provides a schematic representation of our modified Rep-VGG block with the Skip-Squeeze-Excitation module . We refer to this block as the RepVGG-SSE . One concern , especially with large-scale datasets such as ImageNet , is that a non-deep network may not have sufficient non-linearity , limiting its representational power . Thus we replace the ReLU activation with SiLU ( Ramachandran et al. , 2017 ) . 3.2 DOWNSAMPLING AND FUSION BLOCK . Apart from the RepVGG-SSE block , whose input and output have the same size , ParNet also contains Downsampling and Fusion blocks . The Downsampling block reduces resolution and increases width to enable multi-scale processing , while the Fusion block combines information from multiple resolutions . In the Downsampling block , there is no skip connection ; instead , we add a single-layered SE module parallel to the convolution layer . Additionally , we add 2D average pooling in the 1×1 convolution branch . The Fusion block is similar to the Downsampling block but contains an extra concatenation layer . Because of concatenation , the input to the Fusion block has twice as many channels as a Downsampling block . Hence , to reduce the parameter count , we use convolution with group 2 . Please refer to Figure A1 in the appendix for a schematic representation of the Downsampling and Fusion blocks . | - **Motivation**. The paper argues that deep networks have several limitations - (a) deep nets have a higher latency; - (b) deep nets are hard to parallelize; - (c) deep nets are not suitable for applications. - **Method**. Motivated by these observations, the paper aims to fill the performance gap between shallow networks and deep networks. The paper proposed a 12-layer shallow model framework, which contains proposed RepVGG-SSE blocks, fusion modules for multi-scale processing, and parallel streams. - **Experiments**. The proposed model, ParNet, is verified on CIFAR-10, CIFAR-100, and ImageNet for classification, MS-COCO for detection. | SP:22acf52a7e17f34145c127491d0ed9219916a81f |
Non-deep Networks | 1 INTRODUCTION . Deep Neural Networks ( DNNs ) have revolutionized the fields of machine learning , computer vision , and natural language processing . As their name suggests , a key characteristic of DNNs is that they are deep . That is , they have a large depth , which can be defined as the length of the longest path from an input neuron to an output neuron . Often a neural network can be described as a linear sequence of layers , i.e . groups of neurons with no intra-group connections . In such cases , the depth of a network is its number of layers . It has been generally accepted that large depth is an essential component for high-performing networks because depth increases the representational ability of a network and helps learn increasingly abstract features ( He et al. , 2016a ) . In fact , one of the primary reasons given for the success of ResNets is that they allow training very deep networks with as many as 1000 layers ( He et al. , 2016a ) . As such , state-of-the-art performance is increasingly achieved by training models with large depth , and what qualifies as “ deep ” has shifted from “ 2 or more layers ” in the early days of deep learning to the “ tens or hundreds of layers ” routinely used in today ’ s models . For example , as shown in Figure 1 , competitive benchmarks such as ImageNet are dominated by very deep models ( He et al. , 2016a ; Huang et al. , 2017 ; Tan & Le , 2019 ) with at least 30 layers , whereas models with fewer than 30 layers perform substantially worse . The best-performing model with fewer than 20 layers has a top-1 accuracy of only 75.2 , substantially lower than accuracies achievable with 30 or more layers when evaluated with a single image crop ( He et al. , 2015 ; Tan & Le , 2019 ) . But is large depth always necessary ? This question is worth asking because large depth is not without drawbacks . A deeper network leads to more sequential processing and higher latency ; it is harder to parallelize and less suitable for applications that require fast responses . In this paper , we study whether it is possible to achieve high performance with “ non-deep ” neural networks , especially networks with ∼10 layers . We find that , contrary to conventional wisdom , this is indeed possible . We present a network design that is non-deep and performs competitively against its deep counterparts . We refer to our architecture as ParNet ( Parallel Networks ) . We show , for the first time , that a classification network with a depth of just 12 can achieve accuracy greater than 80 % on ImageNet , 96 % on CIFAR10 , and 81 % on CIFAR100 . We also show that a detection network with a low-depth ( 12 ) backbone can achieve an AP of 48 % on MS-COCO . Note that the number of parameters in ParNet is comparable to state-of-the-art models , as illustrated in Figure 1 . A key design choice in ParNet is the use of parallel subnetworks . Instead of arranging layers sequentially , we arrange layers in parallel subnetworks . This design is “ embarrassingly parallel ” , in the sense that there are no connections between the subnetworks except at the beginning and the end . This allows us to reduce the depth of the network while maintaining high accuracy . It is worth noting that our parallel structures are distinct from “ widening ” a network by increasing the number of neurons in a layer . ParNet not only helps us answer a scientific question about the necessity of large depth , but also offers practical advantages . Due to the parallel substructures , ParNet can be efficiently parallelized across multiple processors . We find that ParNet can be effectively parallelized and outperforms ResNets in terms of both speed and accuracy . Note that this is achieved despite the extra latency introduced by the communication between processing units . This shows that in the future , with possibly specialized hardware to further mitigate communication latency , ParNet-like architectures could be used for creating extremely fast recognition systems . We also study the scaling rules for ParNet . Specifically , we show that ParNet can be effectively scaled by increasing width , resolution , and number of branches , all while keeping depth constant . We observe that the performance of ParNet does not saturate and increases as we increase computational throughput . This suggests that by increasing compute further , one can achieve even higher performance while maintaining small depth ( ∼10 ) and low latency . To summarize , our contributions are three-fold : • We show , for the first time , that a neural network with a depth of only 12 can achieve high performance on very competitive benchmarks ( 80.7 % on ImageNet , 96 % on CIFAR10 , 81 % on CIFAR100 ) . • We show how parallel structures in ParNet can be utilized for fast , low-latency inference . • We study the scaling rules for ParNet and demonstrate effective scaling with constant low depth . 2 RELATED WORK . Analyzing importance of depth . There exists a rich literature analyzing the importance of depth in neural networks . The classic work of Cybenko et al . showed that a single-layer neural network with sigmoid activations can approximate any function with arbitrarily small error ( Cybenko , 1989 ) . However , one needs to use a network with sufficiently large width , which can drastically increase the parameter count . Subsequent works have shown that , to approximate a function , a deep network with non-linearity needs exponentially fewer parameters than its shallow counterpart ( Liang & Srikant , 2017 ) . This is often cited as one of the major advantages of large depth . Several works have also empirically analyzed the importance of depth and came to the conclusion that under a fixed parameter budget , deeper networks perform better than their shallow counter- parts ( Eigen et al. , 2013 ; Urban et al. , 2017 ) . However , in such analysis , prior works have only studied shallow networks with a linear , sequential structure , and it is unclear whether the conclusion still holds with alternative designs . In this work , we show that , contrary to conventional wisdom , a shallow network can perform surprisingly well , and the key is to have parallel substructures . Scaling DNNs . There have been many exciting works that have studied the problem of scaling neural networks . Tan & Le ( 2019 ) showed that increasing depth , width , and resolution leads to effective scaling of convolutional networks . We also study scaling rules but focus on the low-depth regime . We find that one can increase the number of branches , width , and resolution to effectively scale ParNet while keeping depth constant and low . Zagoruyko & Komodakis ( 2016 ) showed that shallower networks with a large width can achieve similar performance to deeper ResNets . We also scale our networks by increasing their width . However , we consider networks that are much shallower – a depth of just 12 compared to 50 considered for ImageNet by Zagoruyko & Komodakis ( 2016 ) – and introduce parallel substructures . Shallow networks . Shallow networks have attracted attention in theoretical machine learning . With infinite width , a single-layer neural network behaves like a Gaussian Process , and one can understand the training procedure in terms of kernel methods ( Jacot et al. , 2018 ) . However , such models do not perform competitively when compared to state-of-the-art networks ( Li et al. , 2019 ) . We provide empirical proof that non-deep networks can be competitive with their deep counterparts . Multi-stream networks . Multi-stream neural networks have been used in a variety of computer vision tasks such as segmentation ( Chen et al. , 2016 ; 2017 ) , detection ( Lin et al. , 2017 ) , and video classification ( Wu et al. , 2016 ) . The HRNet architecture maintains multi-resolution streams throughout the forward pass ( Wang et al. , 2020 ) ; these streams are fused together at regular intervals to exchange information . We also use streams with different resolutions , but our network is much shallower ( 12 vs. 38 for the smallest HRNet for classification ) and the streams are fused only once , at the very end , making parallelization easier . 3 METHOD . In this section , we develop and analyze ParNet , a network architecture that is much less deep but still achieves high performance on competitive benchmarks . ParNet consists of parallel substructures that process features at different resolutions . We refer to these parallel substructures as streams . Features from different streams are fused at a later stage in the network , and these fused features are used for the downstream task . Figure 2a provides a schematic representation of ParNet . 3.1 PARNET BLOCK . In ParNet , we utilize VGG-style blocks ( Simonyan & Zisserman , 2015 ) . To see whether non-deep networks can achieve high performance , we empirically find that VGG-style blocks are more suitable than ResNet-style blocks ( Table 8 ) . In general , training VGG-style networks is more difficult than their ResNet counterparts ( He et al. , 2016a ) . But recent work shows that it is easier to train net- works with such blocks if one uses a “ structural reparameterization ” technique ( Ding et al. , 2021 ) . During training , one uses multiple branches over the 3×3 convolution blocks . Once trained , the multiple branches can be fused into one 3×3 convolution . Hence , one ends up with a plain network consisting of only 3×3 block and non-linearity . This reparameterization or fusion of blocks helps reduce latency during inference . We borrow our initial block design from Rep-VGG ( Ding et al. , 2021 ) and modify it to make it more suitable for our non-deep architecture . One challenge with a non-deep network with only 3×3 convolutions is that the receptive field is rather limited . To address this , we build a SkipSqueeze-Excitation ( SSE ) layer which is based on the Squeeze-and-Excitation ( SE ) design ( Hu et al. , 2018 ) . Vanilla Squeeze-and-Excitation is not suitable for our purpose as it increases the depth of the network . Hence we use a Skip-Squeeze-Excitation design which is applied alongside the skip connection and uses a single fully-connected layer . We find that this design helps increase performance ( Table 7 ) . Figure 2b provides a schematic representation of our modified Rep-VGG block with the Skip-Squeeze-Excitation module . We refer to this block as the RepVGG-SSE . One concern , especially with large-scale datasets such as ImageNet , is that a non-deep network may not have sufficient non-linearity , limiting its representational power . Thus we replace the ReLU activation with SiLU ( Ramachandran et al. , 2017 ) . 3.2 DOWNSAMPLING AND FUSION BLOCK . Apart from the RepVGG-SSE block , whose input and output have the same size , ParNet also contains Downsampling and Fusion blocks . The Downsampling block reduces resolution and increases width to enable multi-scale processing , while the Fusion block combines information from multiple resolutions . In the Downsampling block , there is no skip connection ; instead , we add a single-layered SE module parallel to the convolution layer . Additionally , we add 2D average pooling in the 1×1 convolution branch . The Fusion block is similar to the Downsampling block but contains an extra concatenation layer . Because of concatenation , the input to the Fusion block has twice as many channels as a Downsampling block . Hence , to reduce the parameter count , we use convolution with group 2 . Please refer to Figure A1 in the appendix for a schematic representation of the Downsampling and Fusion blocks . | The paper proposes a new architecture of a convolutional neural network for image classification. The authors are motivated by inference efficiency and showing that networks with about a dozen of layers can be competitive in classification accuracy with 50 layers and more. So instead of growing depth, they propose to grow width and have multiple subnetworks of the same depth within one model. The proposed architecture is evaluated on CIFAR, ImageNet and COCO classification and detection tasks, and shows that networks with 12 layers can be competitive with deeper counterparts. | SP:22acf52a7e17f34145c127491d0ed9219916a81f |
Huber Additive Models for Non-stationary Time Series Analysis | Sparse additive models have shown promising flexibility and interpretability in processing time series data . However , existing methods usually assume the time series data to be stationary and the innovation is sampled from a Gaussian distribution . Both assumptions are too stringent for heavy-tailed and non-stationary time series data that frequently arise in practice , such as finance and medical fields . To address these problems , we propose an adaptive sparse Huber additive model for robust forecasting in both non-Gaussian data and ( non ) stationary data . In theory , the generalization bounds of our estimator are established for both stationary and non-stationary time series data , which are independent of the widely used mixing conditions in learning theory of dependent observations . Moreover , the error bound for non-stationary time series contains a discrepancy measure for the shifts of the data distributions over time . Such a discrepancy measure can be estimated empirically and used as a penalty in our method . Experimental results on both synthetic and real-world benchmark datasets validate the effectiveness of the proposed method . 1 INTRODUCTION . Additive model has become one of the most powerful tools for time series analysis due to the exemplary monograph ( Stone , 1985 ; Hastie & Tibshirani , 1990 ) and companion software ( Chambers & Hastie , 1992 ) . For the past two decades , the growing importance of algorithmic flexibility and interpretability motivates the development of various additive models along with theoretical explorations ( Huang & Yang , 2004 ; Wang & Yang , 2007 ; Chu & Glymour , 2008 ; Song & Yang , 2010 ; Yang et al. , 2018 ) and practical applications ( Dominici et al. , 2002 ; Wang & Brown , 2011 ; Ravindra et al. , 2019 ; Bussmann et al. , 2020 ) . Although these aforementioned works have shown promising behaviours , the methods proposed in these works require some stringent assumptions on the stochastic process , e.g. , various mixing conditions ( Doukhan , 1994 ) , stationary distribution and Gaussian innovation . A number of attempts have been made to relax such stringent assumptions . For the purpose of dealing with non-Gaussian innovation , Qiu et al . ( 2015 ) develop an elliptical vector autoregressive model for estimating heavy-tailed stationary processes with parametric convergence analysis that reduces the influence of non-Gaussian innovation . Moreover , under stationarity and decaying β-mixing condition , Wong et al . ( 2020 ) derive nonasymptotic estimation error of lasso without assuming special parametric form of the data generating process . Stationarity and various mixing conditions are commonly adopted in many previous studies , see , e.g. , ( Mohri & Rostamizadeh , 2009 ; 2010 ; Kock & Callot , 2015 ; Wong et al. , 2020 ) . However , the mixing and stationary conditions are too stringent and not always valid in practice ( Baillie , 1996 ; Kuznetsov & Mohri , 2020a ) . To relax the mixing and stationary conditions , Adams & Nobel ( 2010 ) prove asymptotic guarantees for stationary ergodic sequences . Agarwal & Duchi ( 2013 ) establish generalization bounds for asymptotically stationary ( mixing ) processes in the case of stable on-line learning algorithms . Kuznetsov & Mohri ( 2014 ) establish learning guarantees for fully non-stationary and mixing processes . Recently , Kuznetsov & Mohri ( 2020a ) provide data-dependent generalization risk bounds for non-stationary and non-mixing stochastic processes . However , both theoretically and practically , the exploration on robust additive models for nonstationary time series analysis is still limited . In this paper , we propose a class of sparse Huber additive models with theoretical guarantees . Our main contributions are summarized as follows : • Algorithm design and theoretical guarantees : In Section 3.1 , we first propose a novel sparse Huber additive model ( SpHAM ) by integrating Huber loss and sparsity-inducing ` 2,1-norm regularizer into an additive data-dependent hypothesis space . This proposed method can achieve robust forecasting and satisfactory inference ( e.g. , Granger causal discovery ) simultaneously . In theory , Section 3.2 establishes the upper bound of the function approximation error of SpHAM by developing error decomposition technique ( Wu et al. , 2006 ; Chen et al. , 2020 ) and employing sequential Rademacher complexity ( Rakhlin et al. , 2010 ; 2015 ; Kuznetsov & Mohri , 2020a ) . With properly selected scale parameters , the theoretical findings indicate that : a ) For stationary time series , the function approximation consistency with convergence rate O ( n− 1 2 ) can be pursued , even if the innovation is non- Gaussian distribution ( see Theorem 1 and Corollary 1 for more details ) . Moreover , this consistency analysis appears to be novel because no explicit data dependence assumptions are not imposed here , e.g. , various mixing conditions used in ( Doukhan , 1994 ; Mohri & Rostamizadeh , 2010 ; Zou et al. , 2009 ; Wong et al. , 2020 ) ; b ) For non-stationary time series , the function approximation error is bounded by a discrepancy measure , which characterizes the drifts of the data distributions along with time ( see Theorem 2 for more details ) . By penalizing such a discrepancy measure , Section 3.3 further proposes an adaptive SpHAM for dealing with non-stationary time series and provides its theoretical upper bound correspondingly ( see Theorem 3 for more details ) . • Optimization and empirical evaluations : The proposed SpHAM and adptive SpHAM can be implemented efficiently by Difference of Convex programming ( DC programming ) ( Tao & An , 1998 ) and Fast Iterative Shrinkage-Thresholding Algorithm ( FISTA ) ( Beck & Teboulle , 2009 ) . Experimental results on both synthetic and real-world benchmark CauseMe ( Runge et al. , 2019 ) validate the effectiveness of the proposed method . Related works : There exist some interesting studies towards sparse additive model for time series analysis from both theoretical and practical viewpoints ; see , e.g. , ( Chu & Glymour , 2008 ; Song & Yang , 2010 ; Yang et al. , 2018 ) . Although they show promising interpretability and modeling capacity , all of them require Gaussian innovation , stationarity and various mixing conditions . Moreover , these assumptions are not always valid in heavy-tailed and non-stationary time series data . In contrast to these previous additive models , we are seeking to formulate our method and investigate its asymptotic properties without resorting to such strict assumptions . Robust forecasting is a vibrant area of research in time series analysis ( Qiu et al. , 2015 ; Wong et al. , 2020 ) . As one of the triumphs and milestones of robust statistics , the success stories of Huber algorithms are mainly on robust prediction tasks with i.i.d datasets ( Huber , 1964 ; Huber & Ronchetti , 2009 ; Loh , 2017 ; Feng & Wu , 2020 ) , and their extensions to time series prediction are fairly sparse . To our best knowledge , this is the first work that considers Huber additive models for non-stationary and dependent time series data . Our theoretical analyses are inspired from the successful usage of sequential Rademacher complexity in Kuznetsov & Mohri ( 2020b ; a ) . The generalization risk bounds are established in their works for a general scenario of non-stationary and non-mixing stochastic processes . However , it should be mentioned that we are chiefly concerned about the function approximation analysis , which is essentially different from theirs and is very crucial for Huber algorithms , since the convergence of generalization risk can not imply the convergence of function approximation ( Sun et al. , 2019 ; Feng & Wu , 2020 ) . Moreover , the development of analysis techniques ( e.g. , error decomposition and sequential Rademacher complexity ) for assessing our method may shed light on other robust models for nonstationary time series analysis . To better highlight the novelty of our method , Table 1 summarizes the algorithmic properties of our method and other related works , e.g. , Sparse additive models for time series ( TS-SpAM ) ( Yang et al. , 2018 ) , Discrepancy-based Forecasting ( DBF ) ( Kuznetsov & Mohri , 2020a ) and Robust Dantzigselector-type estimator ( R-Dantzig ) ( Qiu et al. , 2015 ) . The remainder of this paper is organized as follows . Section 2 recalls the background of additive models . Section 3 mainly provides our methods and theoretical guarantees . We provide empirical evaluations in Section 4 . Finally , Section 5 concludes this paper . 2 PRELIMINARY . Let { Zt } ∞t=−∞ be a stochastic time series with time index t , where variable Zt = ( Xt , Y t ) takes values in the compact input space X ⊂ Rp and the output space Y ⊂ R. We consider a common nonparametric model Y t = f∗ ( Xt ) + εt , E ( εt ) = 0 , ( 1 ) where f∗ ( · ) is the ground truth function , and the innovation εt is i.i.d . across time t ∈ Z . For the sake of simplicity , we denote ρt and ρtX as the jointed distribution of ( X t , Y t ) and the corresponding marginal distribution with respect to Xt , respectively . This setup actually covers a large number of scenarios commonly used in practice . For instance , the case Xt that contains p lagged values of Y t ( e.g. , Xt = Y ( t−p ) ×· · ·×Y ( t−1 ) ) corresponds to the p-order autoregressive models . Moreover , this case can be viewed as a vector autoregressive model in the sense that input Xt includes the historical information of multiple variables . Although such a nonparametric model ( 1 ) makes very few assumptions on data generation , the related nonparametric algorithms suffer so-called “ curse of dimensionality ” , see Fan & Gijbels ( 1996 ) for further discussion . An effective strategy for solving this problem is additive model . Usually , the additive structure is obtained by decomposing the input space X ∈ Rp into X = X1 × ... × Xp . Under the assumption that the ground truth admits an additive structure f∗ = ∑p j=1 f ∗ j , the additive model can be defined as Y t = f∗1 ( X 1 1 ) + · · ·+ f∗p ( Xtp ) + εt , ( 2 ) where each component f∗j : Xj → R is a smooth function . In linear time series analysis , a weak stationarity condition ( i.e. , the first two moments of time series are time invariant ) is preferred ( Han et al. , 2015 ; Qiu et al. , 2015 ) . In contrast , strict stationarity is primarily used if our focus is on nonlinear relationships ( Fan & Yao , 2005 ) . Definition 1 . A stochastic process { Zt } ∞t=−∞ is strictly stationary if ( Z1 , ... , Zt ) and ( Z1+k , ... , Zt+k ) have the same joint distributions for any t ∈ Z and k ∈ Z . Note that , if not otherwise stated , the stationarity in this paper refers to strict stationarity . Suppose that we are given T size time series data { ( xt , yt ) } Tt=1 ∈ ZT which are drawn from an additive data-generating model ( 2 ) . Under stationarity condition and zero-mean Gaussian innovation with finite variance , the most existing methods that learn the ground truth f∗ usually integrate squared loss and a smoothness- or sparsity-inducing regularizer Ω ( · ) into a structural risk minimization scheme : min f∈H T∑ t=1 ( yt − p∑ j=1 fj ( x t j ) ) 2 + Ω ( f ) , whereH : = { f1 + ... + fp : fj ∈ Hj , j = 1 , ... , p } is an additive hypothesis space . Commonly , each subspaceHj can be reproducing kernel Hilbert space ( Chen et al. , 2017 ; Kandasamy & Yu , 2016 ; Raskutti et al. , 2012 ) , the orthogonal basis inducing space ( Ravikumar et al. , 2009 ; Meier et al. , 2009 ; Yang et al. , 2018 ) , or the composite function space with the neural network as a typical ( Agarwal et al. , 2020 ; Bussmann et al. , 2020 ) . However , when facing heavy-tailed innovation , these methods may have degraded performance due to the amplification of the squared loss to large residuals . In statistic learning community , as one commonly used robust statistic , Huber loss is defined as ` σ ( f ( x t ) − yt ) = { ( f ( xt ) − yt ) 2 , if |f ( xt ) − yt| < σ 2σ|f ( xt ) − yt| − σ2 , if |f ( xt ) − yt| ≥ σ , ( 3 ) where σ is a positive hyper-parameter . Note that in the previous studies ( Huber & Ronchetti , 2009 ; Loh , 2017 ) , the hyper-parameter σ is set to be fixed according to the 95 % asymptotic efficiency rule . However , Huber regression with a fixed scale parameter may not be able to learn the ground truth when the noise is asymmetric , as argued recently in Feng & Wu ( 2020 ) ; Sun et al . ( 2019 ) . In this paper , we choose the scale parameter σ by relating it to the moment condition of the noise distribution and the sample size so that the resulting regression estimator can asymptotically converge to the ground truth function . | This ms tackles a timer series problem where each observation is the sum of p hidden functions and a noise (termed as innovation in ms). Traditionally the noise is Gaussian, but this ms makes the noise into heavy tailed distribution such as t distribution. The L2 loss function of the original problem is then replaced by so called Huber loss, which introduces a cutoff to the deviations and is less affected by outliers than L2 loss. Based on this new loss function, this ms sets up the sparse Huber additive model and derive the bounds of the learned hidden functions, under stationary processes. In case of non-stationary processes, the ms introduces different weights to each time points, which can be used to calculate a discrepancy that reflects the non-stationarity. With different weights to different time points, the ms come up with new error bounds. Inference algorithms are provided in the end. | SP:171ce7bd037e584c5437d09dc43dd90f834d9dd4 |
Huber Additive Models for Non-stationary Time Series Analysis | Sparse additive models have shown promising flexibility and interpretability in processing time series data . However , existing methods usually assume the time series data to be stationary and the innovation is sampled from a Gaussian distribution . Both assumptions are too stringent for heavy-tailed and non-stationary time series data that frequently arise in practice , such as finance and medical fields . To address these problems , we propose an adaptive sparse Huber additive model for robust forecasting in both non-Gaussian data and ( non ) stationary data . In theory , the generalization bounds of our estimator are established for both stationary and non-stationary time series data , which are independent of the widely used mixing conditions in learning theory of dependent observations . Moreover , the error bound for non-stationary time series contains a discrepancy measure for the shifts of the data distributions over time . Such a discrepancy measure can be estimated empirically and used as a penalty in our method . Experimental results on both synthetic and real-world benchmark datasets validate the effectiveness of the proposed method . 1 INTRODUCTION . Additive model has become one of the most powerful tools for time series analysis due to the exemplary monograph ( Stone , 1985 ; Hastie & Tibshirani , 1990 ) and companion software ( Chambers & Hastie , 1992 ) . For the past two decades , the growing importance of algorithmic flexibility and interpretability motivates the development of various additive models along with theoretical explorations ( Huang & Yang , 2004 ; Wang & Yang , 2007 ; Chu & Glymour , 2008 ; Song & Yang , 2010 ; Yang et al. , 2018 ) and practical applications ( Dominici et al. , 2002 ; Wang & Brown , 2011 ; Ravindra et al. , 2019 ; Bussmann et al. , 2020 ) . Although these aforementioned works have shown promising behaviours , the methods proposed in these works require some stringent assumptions on the stochastic process , e.g. , various mixing conditions ( Doukhan , 1994 ) , stationary distribution and Gaussian innovation . A number of attempts have been made to relax such stringent assumptions . For the purpose of dealing with non-Gaussian innovation , Qiu et al . ( 2015 ) develop an elliptical vector autoregressive model for estimating heavy-tailed stationary processes with parametric convergence analysis that reduces the influence of non-Gaussian innovation . Moreover , under stationarity and decaying β-mixing condition , Wong et al . ( 2020 ) derive nonasymptotic estimation error of lasso without assuming special parametric form of the data generating process . Stationarity and various mixing conditions are commonly adopted in many previous studies , see , e.g. , ( Mohri & Rostamizadeh , 2009 ; 2010 ; Kock & Callot , 2015 ; Wong et al. , 2020 ) . However , the mixing and stationary conditions are too stringent and not always valid in practice ( Baillie , 1996 ; Kuznetsov & Mohri , 2020a ) . To relax the mixing and stationary conditions , Adams & Nobel ( 2010 ) prove asymptotic guarantees for stationary ergodic sequences . Agarwal & Duchi ( 2013 ) establish generalization bounds for asymptotically stationary ( mixing ) processes in the case of stable on-line learning algorithms . Kuznetsov & Mohri ( 2014 ) establish learning guarantees for fully non-stationary and mixing processes . Recently , Kuznetsov & Mohri ( 2020a ) provide data-dependent generalization risk bounds for non-stationary and non-mixing stochastic processes . However , both theoretically and practically , the exploration on robust additive models for nonstationary time series analysis is still limited . In this paper , we propose a class of sparse Huber additive models with theoretical guarantees . Our main contributions are summarized as follows : • Algorithm design and theoretical guarantees : In Section 3.1 , we first propose a novel sparse Huber additive model ( SpHAM ) by integrating Huber loss and sparsity-inducing ` 2,1-norm regularizer into an additive data-dependent hypothesis space . This proposed method can achieve robust forecasting and satisfactory inference ( e.g. , Granger causal discovery ) simultaneously . In theory , Section 3.2 establishes the upper bound of the function approximation error of SpHAM by developing error decomposition technique ( Wu et al. , 2006 ; Chen et al. , 2020 ) and employing sequential Rademacher complexity ( Rakhlin et al. , 2010 ; 2015 ; Kuznetsov & Mohri , 2020a ) . With properly selected scale parameters , the theoretical findings indicate that : a ) For stationary time series , the function approximation consistency with convergence rate O ( n− 1 2 ) can be pursued , even if the innovation is non- Gaussian distribution ( see Theorem 1 and Corollary 1 for more details ) . Moreover , this consistency analysis appears to be novel because no explicit data dependence assumptions are not imposed here , e.g. , various mixing conditions used in ( Doukhan , 1994 ; Mohri & Rostamizadeh , 2010 ; Zou et al. , 2009 ; Wong et al. , 2020 ) ; b ) For non-stationary time series , the function approximation error is bounded by a discrepancy measure , which characterizes the drifts of the data distributions along with time ( see Theorem 2 for more details ) . By penalizing such a discrepancy measure , Section 3.3 further proposes an adaptive SpHAM for dealing with non-stationary time series and provides its theoretical upper bound correspondingly ( see Theorem 3 for more details ) . • Optimization and empirical evaluations : The proposed SpHAM and adptive SpHAM can be implemented efficiently by Difference of Convex programming ( DC programming ) ( Tao & An , 1998 ) and Fast Iterative Shrinkage-Thresholding Algorithm ( FISTA ) ( Beck & Teboulle , 2009 ) . Experimental results on both synthetic and real-world benchmark CauseMe ( Runge et al. , 2019 ) validate the effectiveness of the proposed method . Related works : There exist some interesting studies towards sparse additive model for time series analysis from both theoretical and practical viewpoints ; see , e.g. , ( Chu & Glymour , 2008 ; Song & Yang , 2010 ; Yang et al. , 2018 ) . Although they show promising interpretability and modeling capacity , all of them require Gaussian innovation , stationarity and various mixing conditions . Moreover , these assumptions are not always valid in heavy-tailed and non-stationary time series data . In contrast to these previous additive models , we are seeking to formulate our method and investigate its asymptotic properties without resorting to such strict assumptions . Robust forecasting is a vibrant area of research in time series analysis ( Qiu et al. , 2015 ; Wong et al. , 2020 ) . As one of the triumphs and milestones of robust statistics , the success stories of Huber algorithms are mainly on robust prediction tasks with i.i.d datasets ( Huber , 1964 ; Huber & Ronchetti , 2009 ; Loh , 2017 ; Feng & Wu , 2020 ) , and their extensions to time series prediction are fairly sparse . To our best knowledge , this is the first work that considers Huber additive models for non-stationary and dependent time series data . Our theoretical analyses are inspired from the successful usage of sequential Rademacher complexity in Kuznetsov & Mohri ( 2020b ; a ) . The generalization risk bounds are established in their works for a general scenario of non-stationary and non-mixing stochastic processes . However , it should be mentioned that we are chiefly concerned about the function approximation analysis , which is essentially different from theirs and is very crucial for Huber algorithms , since the convergence of generalization risk can not imply the convergence of function approximation ( Sun et al. , 2019 ; Feng & Wu , 2020 ) . Moreover , the development of analysis techniques ( e.g. , error decomposition and sequential Rademacher complexity ) for assessing our method may shed light on other robust models for nonstationary time series analysis . To better highlight the novelty of our method , Table 1 summarizes the algorithmic properties of our method and other related works , e.g. , Sparse additive models for time series ( TS-SpAM ) ( Yang et al. , 2018 ) , Discrepancy-based Forecasting ( DBF ) ( Kuznetsov & Mohri , 2020a ) and Robust Dantzigselector-type estimator ( R-Dantzig ) ( Qiu et al. , 2015 ) . The remainder of this paper is organized as follows . Section 2 recalls the background of additive models . Section 3 mainly provides our methods and theoretical guarantees . We provide empirical evaluations in Section 4 . Finally , Section 5 concludes this paper . 2 PRELIMINARY . Let { Zt } ∞t=−∞ be a stochastic time series with time index t , where variable Zt = ( Xt , Y t ) takes values in the compact input space X ⊂ Rp and the output space Y ⊂ R. We consider a common nonparametric model Y t = f∗ ( Xt ) + εt , E ( εt ) = 0 , ( 1 ) where f∗ ( · ) is the ground truth function , and the innovation εt is i.i.d . across time t ∈ Z . For the sake of simplicity , we denote ρt and ρtX as the jointed distribution of ( X t , Y t ) and the corresponding marginal distribution with respect to Xt , respectively . This setup actually covers a large number of scenarios commonly used in practice . For instance , the case Xt that contains p lagged values of Y t ( e.g. , Xt = Y ( t−p ) ×· · ·×Y ( t−1 ) ) corresponds to the p-order autoregressive models . Moreover , this case can be viewed as a vector autoregressive model in the sense that input Xt includes the historical information of multiple variables . Although such a nonparametric model ( 1 ) makes very few assumptions on data generation , the related nonparametric algorithms suffer so-called “ curse of dimensionality ” , see Fan & Gijbels ( 1996 ) for further discussion . An effective strategy for solving this problem is additive model . Usually , the additive structure is obtained by decomposing the input space X ∈ Rp into X = X1 × ... × Xp . Under the assumption that the ground truth admits an additive structure f∗ = ∑p j=1 f ∗ j , the additive model can be defined as Y t = f∗1 ( X 1 1 ) + · · ·+ f∗p ( Xtp ) + εt , ( 2 ) where each component f∗j : Xj → R is a smooth function . In linear time series analysis , a weak stationarity condition ( i.e. , the first two moments of time series are time invariant ) is preferred ( Han et al. , 2015 ; Qiu et al. , 2015 ) . In contrast , strict stationarity is primarily used if our focus is on nonlinear relationships ( Fan & Yao , 2005 ) . Definition 1 . A stochastic process { Zt } ∞t=−∞ is strictly stationary if ( Z1 , ... , Zt ) and ( Z1+k , ... , Zt+k ) have the same joint distributions for any t ∈ Z and k ∈ Z . Note that , if not otherwise stated , the stationarity in this paper refers to strict stationarity . Suppose that we are given T size time series data { ( xt , yt ) } Tt=1 ∈ ZT which are drawn from an additive data-generating model ( 2 ) . Under stationarity condition and zero-mean Gaussian innovation with finite variance , the most existing methods that learn the ground truth f∗ usually integrate squared loss and a smoothness- or sparsity-inducing regularizer Ω ( · ) into a structural risk minimization scheme : min f∈H T∑ t=1 ( yt − p∑ j=1 fj ( x t j ) ) 2 + Ω ( f ) , whereH : = { f1 + ... + fp : fj ∈ Hj , j = 1 , ... , p } is an additive hypothesis space . Commonly , each subspaceHj can be reproducing kernel Hilbert space ( Chen et al. , 2017 ; Kandasamy & Yu , 2016 ; Raskutti et al. , 2012 ) , the orthogonal basis inducing space ( Ravikumar et al. , 2009 ; Meier et al. , 2009 ; Yang et al. , 2018 ) , or the composite function space with the neural network as a typical ( Agarwal et al. , 2020 ; Bussmann et al. , 2020 ) . However , when facing heavy-tailed innovation , these methods may have degraded performance due to the amplification of the squared loss to large residuals . In statistic learning community , as one commonly used robust statistic , Huber loss is defined as ` σ ( f ( x t ) − yt ) = { ( f ( xt ) − yt ) 2 , if |f ( xt ) − yt| < σ 2σ|f ( xt ) − yt| − σ2 , if |f ( xt ) − yt| ≥ σ , ( 3 ) where σ is a positive hyper-parameter . Note that in the previous studies ( Huber & Ronchetti , 2009 ; Loh , 2017 ) , the hyper-parameter σ is set to be fixed according to the 95 % asymptotic efficiency rule . However , Huber regression with a fixed scale parameter may not be able to learn the ground truth when the noise is asymmetric , as argued recently in Feng & Wu ( 2020 ) ; Sun et al . ( 2019 ) . In this paper , we choose the scale parameter σ by relating it to the moment condition of the noise distribution and the sample size so that the resulting regression estimator can asymptotically converge to the ground truth function . | The authors proposed a robust Huber additive model for non-stationary time series prediction. They combine the idea of robust Huber regression (against non-Gaussian innovations) with a linear additive model formulated with the aid of the representer theorem in RKHS; sparsity is imposed on the weights, and the overall weights optimization problem can be solved efficiently through the classic FISTA algorithm due to the special problem structure. The major contributions lie in a robust (due to the Huber loss function) and interpretable (due to the use of linear additive model) time series prediction model as well as some theoretical supports on the performance. | SP:171ce7bd037e584c5437d09dc43dd90f834d9dd4 |
Huber Additive Models for Non-stationary Time Series Analysis | Sparse additive models have shown promising flexibility and interpretability in processing time series data . However , existing methods usually assume the time series data to be stationary and the innovation is sampled from a Gaussian distribution . Both assumptions are too stringent for heavy-tailed and non-stationary time series data that frequently arise in practice , such as finance and medical fields . To address these problems , we propose an adaptive sparse Huber additive model for robust forecasting in both non-Gaussian data and ( non ) stationary data . In theory , the generalization bounds of our estimator are established for both stationary and non-stationary time series data , which are independent of the widely used mixing conditions in learning theory of dependent observations . Moreover , the error bound for non-stationary time series contains a discrepancy measure for the shifts of the data distributions over time . Such a discrepancy measure can be estimated empirically and used as a penalty in our method . Experimental results on both synthetic and real-world benchmark datasets validate the effectiveness of the proposed method . 1 INTRODUCTION . Additive model has become one of the most powerful tools for time series analysis due to the exemplary monograph ( Stone , 1985 ; Hastie & Tibshirani , 1990 ) and companion software ( Chambers & Hastie , 1992 ) . For the past two decades , the growing importance of algorithmic flexibility and interpretability motivates the development of various additive models along with theoretical explorations ( Huang & Yang , 2004 ; Wang & Yang , 2007 ; Chu & Glymour , 2008 ; Song & Yang , 2010 ; Yang et al. , 2018 ) and practical applications ( Dominici et al. , 2002 ; Wang & Brown , 2011 ; Ravindra et al. , 2019 ; Bussmann et al. , 2020 ) . Although these aforementioned works have shown promising behaviours , the methods proposed in these works require some stringent assumptions on the stochastic process , e.g. , various mixing conditions ( Doukhan , 1994 ) , stationary distribution and Gaussian innovation . A number of attempts have been made to relax such stringent assumptions . For the purpose of dealing with non-Gaussian innovation , Qiu et al . ( 2015 ) develop an elliptical vector autoregressive model for estimating heavy-tailed stationary processes with parametric convergence analysis that reduces the influence of non-Gaussian innovation . Moreover , under stationarity and decaying β-mixing condition , Wong et al . ( 2020 ) derive nonasymptotic estimation error of lasso without assuming special parametric form of the data generating process . Stationarity and various mixing conditions are commonly adopted in many previous studies , see , e.g. , ( Mohri & Rostamizadeh , 2009 ; 2010 ; Kock & Callot , 2015 ; Wong et al. , 2020 ) . However , the mixing and stationary conditions are too stringent and not always valid in practice ( Baillie , 1996 ; Kuznetsov & Mohri , 2020a ) . To relax the mixing and stationary conditions , Adams & Nobel ( 2010 ) prove asymptotic guarantees for stationary ergodic sequences . Agarwal & Duchi ( 2013 ) establish generalization bounds for asymptotically stationary ( mixing ) processes in the case of stable on-line learning algorithms . Kuznetsov & Mohri ( 2014 ) establish learning guarantees for fully non-stationary and mixing processes . Recently , Kuznetsov & Mohri ( 2020a ) provide data-dependent generalization risk bounds for non-stationary and non-mixing stochastic processes . However , both theoretically and practically , the exploration on robust additive models for nonstationary time series analysis is still limited . In this paper , we propose a class of sparse Huber additive models with theoretical guarantees . Our main contributions are summarized as follows : • Algorithm design and theoretical guarantees : In Section 3.1 , we first propose a novel sparse Huber additive model ( SpHAM ) by integrating Huber loss and sparsity-inducing ` 2,1-norm regularizer into an additive data-dependent hypothesis space . This proposed method can achieve robust forecasting and satisfactory inference ( e.g. , Granger causal discovery ) simultaneously . In theory , Section 3.2 establishes the upper bound of the function approximation error of SpHAM by developing error decomposition technique ( Wu et al. , 2006 ; Chen et al. , 2020 ) and employing sequential Rademacher complexity ( Rakhlin et al. , 2010 ; 2015 ; Kuznetsov & Mohri , 2020a ) . With properly selected scale parameters , the theoretical findings indicate that : a ) For stationary time series , the function approximation consistency with convergence rate O ( n− 1 2 ) can be pursued , even if the innovation is non- Gaussian distribution ( see Theorem 1 and Corollary 1 for more details ) . Moreover , this consistency analysis appears to be novel because no explicit data dependence assumptions are not imposed here , e.g. , various mixing conditions used in ( Doukhan , 1994 ; Mohri & Rostamizadeh , 2010 ; Zou et al. , 2009 ; Wong et al. , 2020 ) ; b ) For non-stationary time series , the function approximation error is bounded by a discrepancy measure , which characterizes the drifts of the data distributions along with time ( see Theorem 2 for more details ) . By penalizing such a discrepancy measure , Section 3.3 further proposes an adaptive SpHAM for dealing with non-stationary time series and provides its theoretical upper bound correspondingly ( see Theorem 3 for more details ) . • Optimization and empirical evaluations : The proposed SpHAM and adptive SpHAM can be implemented efficiently by Difference of Convex programming ( DC programming ) ( Tao & An , 1998 ) and Fast Iterative Shrinkage-Thresholding Algorithm ( FISTA ) ( Beck & Teboulle , 2009 ) . Experimental results on both synthetic and real-world benchmark CauseMe ( Runge et al. , 2019 ) validate the effectiveness of the proposed method . Related works : There exist some interesting studies towards sparse additive model for time series analysis from both theoretical and practical viewpoints ; see , e.g. , ( Chu & Glymour , 2008 ; Song & Yang , 2010 ; Yang et al. , 2018 ) . Although they show promising interpretability and modeling capacity , all of them require Gaussian innovation , stationarity and various mixing conditions . Moreover , these assumptions are not always valid in heavy-tailed and non-stationary time series data . In contrast to these previous additive models , we are seeking to formulate our method and investigate its asymptotic properties without resorting to such strict assumptions . Robust forecasting is a vibrant area of research in time series analysis ( Qiu et al. , 2015 ; Wong et al. , 2020 ) . As one of the triumphs and milestones of robust statistics , the success stories of Huber algorithms are mainly on robust prediction tasks with i.i.d datasets ( Huber , 1964 ; Huber & Ronchetti , 2009 ; Loh , 2017 ; Feng & Wu , 2020 ) , and their extensions to time series prediction are fairly sparse . To our best knowledge , this is the first work that considers Huber additive models for non-stationary and dependent time series data . Our theoretical analyses are inspired from the successful usage of sequential Rademacher complexity in Kuznetsov & Mohri ( 2020b ; a ) . The generalization risk bounds are established in their works for a general scenario of non-stationary and non-mixing stochastic processes . However , it should be mentioned that we are chiefly concerned about the function approximation analysis , which is essentially different from theirs and is very crucial for Huber algorithms , since the convergence of generalization risk can not imply the convergence of function approximation ( Sun et al. , 2019 ; Feng & Wu , 2020 ) . Moreover , the development of analysis techniques ( e.g. , error decomposition and sequential Rademacher complexity ) for assessing our method may shed light on other robust models for nonstationary time series analysis . To better highlight the novelty of our method , Table 1 summarizes the algorithmic properties of our method and other related works , e.g. , Sparse additive models for time series ( TS-SpAM ) ( Yang et al. , 2018 ) , Discrepancy-based Forecasting ( DBF ) ( Kuznetsov & Mohri , 2020a ) and Robust Dantzigselector-type estimator ( R-Dantzig ) ( Qiu et al. , 2015 ) . The remainder of this paper is organized as follows . Section 2 recalls the background of additive models . Section 3 mainly provides our methods and theoretical guarantees . We provide empirical evaluations in Section 4 . Finally , Section 5 concludes this paper . 2 PRELIMINARY . Let { Zt } ∞t=−∞ be a stochastic time series with time index t , where variable Zt = ( Xt , Y t ) takes values in the compact input space X ⊂ Rp and the output space Y ⊂ R. We consider a common nonparametric model Y t = f∗ ( Xt ) + εt , E ( εt ) = 0 , ( 1 ) where f∗ ( · ) is the ground truth function , and the innovation εt is i.i.d . across time t ∈ Z . For the sake of simplicity , we denote ρt and ρtX as the jointed distribution of ( X t , Y t ) and the corresponding marginal distribution with respect to Xt , respectively . This setup actually covers a large number of scenarios commonly used in practice . For instance , the case Xt that contains p lagged values of Y t ( e.g. , Xt = Y ( t−p ) ×· · ·×Y ( t−1 ) ) corresponds to the p-order autoregressive models . Moreover , this case can be viewed as a vector autoregressive model in the sense that input Xt includes the historical information of multiple variables . Although such a nonparametric model ( 1 ) makes very few assumptions on data generation , the related nonparametric algorithms suffer so-called “ curse of dimensionality ” , see Fan & Gijbels ( 1996 ) for further discussion . An effective strategy for solving this problem is additive model . Usually , the additive structure is obtained by decomposing the input space X ∈ Rp into X = X1 × ... × Xp . Under the assumption that the ground truth admits an additive structure f∗ = ∑p j=1 f ∗ j , the additive model can be defined as Y t = f∗1 ( X 1 1 ) + · · ·+ f∗p ( Xtp ) + εt , ( 2 ) where each component f∗j : Xj → R is a smooth function . In linear time series analysis , a weak stationarity condition ( i.e. , the first two moments of time series are time invariant ) is preferred ( Han et al. , 2015 ; Qiu et al. , 2015 ) . In contrast , strict stationarity is primarily used if our focus is on nonlinear relationships ( Fan & Yao , 2005 ) . Definition 1 . A stochastic process { Zt } ∞t=−∞ is strictly stationary if ( Z1 , ... , Zt ) and ( Z1+k , ... , Zt+k ) have the same joint distributions for any t ∈ Z and k ∈ Z . Note that , if not otherwise stated , the stationarity in this paper refers to strict stationarity . Suppose that we are given T size time series data { ( xt , yt ) } Tt=1 ∈ ZT which are drawn from an additive data-generating model ( 2 ) . Under stationarity condition and zero-mean Gaussian innovation with finite variance , the most existing methods that learn the ground truth f∗ usually integrate squared loss and a smoothness- or sparsity-inducing regularizer Ω ( · ) into a structural risk minimization scheme : min f∈H T∑ t=1 ( yt − p∑ j=1 fj ( x t j ) ) 2 + Ω ( f ) , whereH : = { f1 + ... + fp : fj ∈ Hj , j = 1 , ... , p } is an additive hypothesis space . Commonly , each subspaceHj can be reproducing kernel Hilbert space ( Chen et al. , 2017 ; Kandasamy & Yu , 2016 ; Raskutti et al. , 2012 ) , the orthogonal basis inducing space ( Ravikumar et al. , 2009 ; Meier et al. , 2009 ; Yang et al. , 2018 ) , or the composite function space with the neural network as a typical ( Agarwal et al. , 2020 ; Bussmann et al. , 2020 ) . However , when facing heavy-tailed innovation , these methods may have degraded performance due to the amplification of the squared loss to large residuals . In statistic learning community , as one commonly used robust statistic , Huber loss is defined as ` σ ( f ( x t ) − yt ) = { ( f ( xt ) − yt ) 2 , if |f ( xt ) − yt| < σ 2σ|f ( xt ) − yt| − σ2 , if |f ( xt ) − yt| ≥ σ , ( 3 ) where σ is a positive hyper-parameter . Note that in the previous studies ( Huber & Ronchetti , 2009 ; Loh , 2017 ) , the hyper-parameter σ is set to be fixed according to the 95 % asymptotic efficiency rule . However , Huber regression with a fixed scale parameter may not be able to learn the ground truth when the noise is asymmetric , as argued recently in Feng & Wu ( 2020 ) ; Sun et al . ( 2019 ) . In this paper , we choose the scale parameter σ by relating it to the moment condition of the noise distribution and the sample size so that the resulting regression estimator can asymptotically converge to the ground truth function . | The authors propose, theoretically analyze and empirically evaluate a sparse additive huber additive model (SpHAM), which is an additive model where each component function in the model is a kernel function that is fitted by minimizing a huber huber loss function with a functional sparsity inducing penalty term. Statistical properties when estimating this model on stationary data with non gaussian noise and also on non-stationary data are developed. Finally, the model and fitting routines are demonstrated empirically on 2 synthetic and 1 real world time series. | SP:171ce7bd037e584c5437d09dc43dd90f834d9dd4 |
A Closer Look at Loss Weighting in Multi-Task Learning | 1 INTRODUCTION . Multi-Task Learning ( MTL ) ( Zhang & Yang , 2021 ; Vandenhende et al. , 2021 ) aims to jointly train several related tasks to improve their generalization performance by leveraging common knowledge among them . Since this learning paradigm can not only significantly reduce the model size and increase the inference speed but also improve the performance , it has been successfully applied in various fields of deep learning , such as Computer Vision ( CV ) ( Vandenhende et al. , 2021 ) , Natural Language Processing ( NLP ) ( Chen et al. , 2021 ) , reinforcement learning ( Zhang & Yang , 2021 ) and so on . However , when all the tasks are not related enough , which may be reflected via conflicting gradients or dominating gradients ( Yu et al. , 2020 ) , it is more difficult to train a multi-task model than training them separately because some tasks dominantly influence model parameters , leading to unsatisfactory performance for other tasks . This phenomenon is related to the task balancing problem ( Vandenhende et al. , 2021 ) in MTL . Recently , several works focus on tackling this issue from an optimization perspective via balancing task losses or gradients . In this paper , we investigate eight State-Of-The-Art ( SOTA ) task balancing approaches and unify them as loss weighting strategies . According to the way of generating loss weights , those methods can be divided into three types , including the solving approach such as directly solving a quadratic optimization problem in a multi-objective formulation as weights ( Sener & Koltun , 2018 ) , the calculating approach such as projecting conflict gradients ( Yu et al. , 2020 ) , and the learning approach such as learning weights in a gradient descent manner ( Chen et al. , 2018b ) . On the other hand , since there are some discrepancies of the implementation details such as using different backbone networks for training or different metrics for the evaluation among those SOTA weighting methods , leading to inconsistent comparisons , we provide a unified testbed on six CV datasets and four multilingual problems from the XTREME benchmark ( Hu et al. , 2020 ) for those SOTA weighting strategies to show a fair comparison . In addition , inspired by dynamic weighting processes in those SOTA strategies where loss weights vary over training iterations or epochs , we have a sudden whim : what will happen if a MTL model is trained with random loss weights ? Specifically , in each training iteration , we first sample the loss weights from a distribution with some normalization and then minimize the aggregated loss weighted by the normalized random weights . Surprisingly , this seemingly unreliable method can not only converge but also achieve comparable performance with the SOTA weighting strategies . Based on this observations , we proposed a simple yet effective weighting strategy for MTL , called Random Loss Weighting ( RLW ) . It is very easy to implement RLW by adding only one line of code and this strategy does not incur any additionally computational cost . An implementation example of RLW in PyTorch ( Paszke et al. , 2019 ) is shown below . 1 outputs = model ( inputs ) 2 loss = criterion ( outputs , labels ) # [ 1 , task_num ] vector 3 weight = F.softmax ( torch.randn ( task_num ) , dim=-1 ) # RLW is only this ! 4 loss = torch.sum ( loss * weight ) 5 optimizer.zero_grad ( ) 6 loss.backward ( ) 7 optimizer.step ( ) To show the effectiveness of RLW , we provide both theoretical analyses and empirical evaluations . Firstly , the objective function of RLW can be considered as a doubly stochastic optimization problem when optimizing by stochastic gradient descent or its variants , where the randomness is from both the mini-batch sampling of the data for each task and the random sampling of loss weights . From this perspective , we give a convergence analysis for RLW . Besides , we can show that RLW has a higher probability to escape local minima when compared with fixing loss weights , resulting in a better generalization performance . Empirically , as described before , we compare RLW with SOTA weighting approaches on six CV datasets and four multilingual problems to show its competitive performance . In summary , the main contributions of this paper are four-fold . • We provide a unified testbed on six multi-task computer vision datasets and four multilingual problems from the XTREME benchmark for a fair comparison among eight SOTA weighting methods and the proposed RLW method . • We propose a simple yet effective RLW strategy , which we think is an ignored baseline in MTL . • We provide the convergence guarantee and effectiveness analysis for RLW . • Experiments show that RLW can achieve comparable performance with SOTA weighting methods without bringing any additionally computational cost . 2 PRELIMINARY . Suppose there are T tasks and task t has its corresponding dataset Dt . An MTL model usually contains two parts of parameters : task-sharing parameters θ and task-specific parameters { ψt } Tt=1 . For example , in CV , θ usually denotes parameters in the feature extractor shared by all tasks and ψt represents the task-specific output module for task t. Let ` t ( · ; θ , ψt ) denotes a task-specific loss function for task t. Then the objective function of a MTL model can be formulated as LMTL = T∑ t=1 λt ` t ( Dt ; θ , ψt ) , ( 1 ) where ` t ( Dt ; θ , ψt ) denotes the average loss on Dt for task t and { λt } Tt=1 are task-specific loss weights with a constraint that λt ≥ 0 for all t. When minimizing Eq . ( 1 ) by Stochastic Gradient Descent ( SGD ) or its variants , the task-specific parameters { ψt } Tt=1 are simply updated based on the corresponding task gradient ∇ψt ` t ( Dt ; θ , ψt ) , while the task-sharing parameters θ should be updated by all the task losses jointly as θ = θ − η T∑ t=1 λt∇θ ` t ( Dt ; θ , ψt ) , ( 2 ) where η is a learning rate . Obviously , for the update of task-sharing parameters θ , the loss weighting ( i.e. , { λt } Tt=1 in Eq . ( 1 ) ) influences θ via the aggregated gradient essentially and the gradient weighting in Eq . ( 2 ) during the backward process has the same effect as the loss weighting when they are using the same weights . Therefore , we can ignore the level on which the weights act and focus on the generation of weights . For simplicity , these two types of weighting are all referred to as loss weighting in the following sections . Apparently , the most simple method for loss weighting is to set a same weight for every tasks , i.e. , without loss of generality , λt = 1T for all t. This approach is a common baseline in MTL and it is called Equally Weighting ( EW ) in this paper . To tackle the task balancing problem and improve the performance of MTL model , there are several works to study how to generate appropriate weights . In this paper , we investigate eight SOTA weighting strategies , i.e . Gradient Normalization ( GradNorm ) ( Chen et al. , 2018b ) , Uncertainty Weights ( UW ) ( Kendall et al. , 2018 ) , MGDA ( Sener & Koltun , 2018 ) , Dynamic Weight Average ( DWA ) ( Liu et al. , 2019a ) , Projecting Conflicting Gradient ( PCGrad ) ( Yu et al. , 2020 ) , Gradient sign Dropout ( GradDrop ) ( Chen et al. , 2020 ) , Impartial Multi-Task Learning ( IMTL ) ( Liu et al. , 2021 ) , and Gradient Vaccine ( GradVac ) ( Wang et al. , 2021 ) . According to different ways of generating loss weights , we categorize those loss weighting strategies into three types : the learning approach , the solving approach , and the calculating approach . Both GradNorm and UW consider the loss weights { λt } Tt=1 in Eq . ( 1 ) as learnable parameters and explicitly optimize them by gradient descent . MGDA casts MTL as a multi-objective optimization problem and directly solves the loss weights { λt } Tt=1 in Eq . ( 1 ) by solving a quadratic programming problem . DWA , PCGrad , GradDrop and GradVac directly compute the weights { λt } Tt=1 by combining gradients and/or losses of all the tasks . IMTL is a hybrid strategy , which combines the learning and the calculating approaches . We summarize those strategies from the perspective of loss weighting in Table 5 in Appendix A . We now unify those eight SOTA methods as loss weighting strategies , i.e. , generating loss weights { λt } Tt=1 in Eq . ( 1 ) . Noticeably , almost all the existing strategies except EW need to incur intensive computation to generate loss weights in every iteration , such as solving a quadratic optimization problem in MGDA , and operating on high-dimensional gradients in PCGrad , GradDrop , IMTL , and GradVac . Different from those strategies , the proposed RLW strategy generates loss weights in a sampling way , thus it is as efficient as EW without bringing additionally computational costs . 3 THE RLW METHOD . In this section , we introduce the proposed RLW method . The RLW method is a simple loss weighting strategy and it considers the loss weights λ = ( λ1 , · · · , λT ) ∈ RT as random variables . Formally , the objective function of the RLW method is formulated as LRLW ( θ ) = Eλ [ λ > ` ( D ; θ ) ] = Eλ [ λ ] > ` ( D ; θ ) , ( 3 ) where E [ · ] denotes the expectation and ` ( D ; θ ) = ( ` 1 ( D1 ; θ ) , · · · , ` T ( DT ; θ ) ) where we omit the task-specific parameters { ψt } Tt=1 in Eq . ( 3 ) for brevity . To guarantee loss weights in λ to be nonnegative , we can first sample λ̃ = ( λ̃1 , · · · , λ̃T ) from any distribution p ( λ̃ ) and then normalize λ̃ into λ via a mapping f , where f : RT → ∆T is a normalization function for example softmax function and ∆T denotes a convex hull in RT , i.e . λ ∈ ∆T means ∑T t=1 λt = 1 and λt ≥ 0 for all t. Note that in most cases p ( λ ) is different from p ( λ̃ ) . In Eq . ( 3 ) , p ( λ ) is usually too complex to compute its expectation Eλ [ λ ] , thus a stochastic approximation scheme is adopted to minimize Eq . ( 3 ) . When the mini-batch SGD ( Bottou , 1991 ) or its variants is used to minimize Eq . ( 3 ) as most deep learning models did , Eq . ( 3 ) can be viewed as a doubly stochastic optimization problem , where the randomness is from both the mini-batch data sampling for each task and the randomly sampling of the loss weights . In the following , we show that the approximated gradient ∇θλ > ` ( D̃ ; θ ) is an unbiased estimation of the true gradient of LRLW ( θ ) , where D̃ denotes a mini-batch data sampled from all the tasks . Specifically , as D̃t is a mini-batch data sampled from Dt to calculate the stochastic gradient ∇θ ` t ( D̃t ; θ ) to approximate the full gradient ∇θ ` t ( Dt ; θ ) for task t , we have ED̃ [ ∇θ ` ( D̃ ; θ ) ] = ∇θ ` ( D ; θ ) . Therefore , when we further randomly sample a weight vector λ , we have Eλ [ ED̃ [ ∇θλ > ` ( D̃ ; θ ) ] ] = Eλ [ λ ] > ∇θ ` ( D ; θ ) = ∇θLRLW ( θ ) , which verifies that∇θλ > ` ( D̃ ; θ ) is an unbiased estimation . In practice , it is very easy to implement the RLW method without modifying network architecture or bringing additionally computational costs . Specifically , in each iteration , we first sample λ̃ from p ( λ̃ ) and normalize it to obtain λ via appropriate normalization function f , and then minimize the aggregated loss weighted by λ . The entire algorithm of RLW ( i.e. , minimizing Eq . ( 3 ) ) via SGD is shown in Algorithm 1 . Apparently , the only difference between the proposed RLW strategy and the widely used EW strategy is Line 7 in Algorithm 1 and it is very easy to implement with only one line of code . Algorithm 1 Optimization Algorithm for RLW by SGD Input : numbers of iterations K , numbers of tasks T , learning rate η , dataset { Dt } Tt=1 , weight distribution p ( λ̃ ) 1 : Randomly initialized θ0 ; 2 : for k = 1 to K do 3 : for t = 1 to T do 4 : Sample a mini-batch data D̃t from Dt ; 5 : Compute loss ` t ( D̃t ; θk ) ; 6 : end for 7 : Sample weights λ̃ from p ( λ̃ ) and normalize it into λ via f ; . RLW is only this 8 : θk+1 = θk − η∇θ ∑T t=1 λt ` t ( D̃t ; θk ) ; 9 : end for In this paper , we use six different distributions for p ( λ̃ ) in the proposed RLW method , including uniform distribution between 0 and 1 ( denoted by Uniform ) , standard normal distribution ( denoted by Normal ) , Dirichlet distribution with α = 1 ( denoted by Dirichlet ) , Bernoulli distribution with probability 1/2 ( denoted by Bernoulli ) , Bernoulli distribution with probability 1/2 and a constraint ∑T t=1 λ̃t = 1 ( denoted by constrained Bernoulli ) , and normal distribution with a random mean and a random variance both sampling from a uniform distribution U ( 0 , 1 ) for each task ( denoted by random Normal ) . We set f as a function of f ( λ̃ ) = λ̃/ ( ∑T t=1 λ̃t ) if p ( λ̃ ) is the Bernoulli distribution or the constrained Bernoulli distribution and a softmax function for the other types of distribution . When sampling from the first five types of distribution , E [ λ ] is simply proportional to ( 1T , · · · , 1 T ) , thus it is fair to compare with the EW strategy . When p ( λ̃ ) is a random Normal distribution , it means each λ̃t is sampled from a normal distribution with random mean and variance , thus it is intractable to compute the expectation for p ( λ ) and combining with such distribution can further show the effectiveness of RLW . When sampling from a Bernoulli distribution , the weights for all tasks are either 0 or 1 , i.e. , λt ∈ { 0 , 1 } for all t. In this way , just a subset of tasks contributes to updating the task-sharing parameters θ . This manner can be viewed as the mini-batch sampling on the task level . If considering an additional constraint that ∑T t=1 λ̃t = 1 , it implies only one task is involved in the update of the tasksharing parameters in each iteration . Although there are some works ( Dong et al. , 2015 ; Liu et al. , 2015a ; Søgaard & Goldberg , 2016 ; Subramanian et al. , 2018 ; Sanh et al. , 2019 ; Liu et al. , 2019b ) adopting this strategy to train a MTL model , it is a special case in the proposed RLW strategy and beyond existing works , we also provide theoretical analyses to show the effectiveness of the proposed RLW method . | This paper conducted an empirical study of existing loss weighting based multi-task learning techniques. By comparing them in both CV and NLP multi-task benchmark datasets, the authors also identified a simple random loss weighting method achieving similar performance. This paper provided both empirical and theoretical analysis of why random loss weighting can achieve similar performance efficiently. | SP:a1cb382f8c5f55bbecc2230e01b13e23f63e3ad1 |
A Closer Look at Loss Weighting in Multi-Task Learning | 1 INTRODUCTION . Multi-Task Learning ( MTL ) ( Zhang & Yang , 2021 ; Vandenhende et al. , 2021 ) aims to jointly train several related tasks to improve their generalization performance by leveraging common knowledge among them . Since this learning paradigm can not only significantly reduce the model size and increase the inference speed but also improve the performance , it has been successfully applied in various fields of deep learning , such as Computer Vision ( CV ) ( Vandenhende et al. , 2021 ) , Natural Language Processing ( NLP ) ( Chen et al. , 2021 ) , reinforcement learning ( Zhang & Yang , 2021 ) and so on . However , when all the tasks are not related enough , which may be reflected via conflicting gradients or dominating gradients ( Yu et al. , 2020 ) , it is more difficult to train a multi-task model than training them separately because some tasks dominantly influence model parameters , leading to unsatisfactory performance for other tasks . This phenomenon is related to the task balancing problem ( Vandenhende et al. , 2021 ) in MTL . Recently , several works focus on tackling this issue from an optimization perspective via balancing task losses or gradients . In this paper , we investigate eight State-Of-The-Art ( SOTA ) task balancing approaches and unify them as loss weighting strategies . According to the way of generating loss weights , those methods can be divided into three types , including the solving approach such as directly solving a quadratic optimization problem in a multi-objective formulation as weights ( Sener & Koltun , 2018 ) , the calculating approach such as projecting conflict gradients ( Yu et al. , 2020 ) , and the learning approach such as learning weights in a gradient descent manner ( Chen et al. , 2018b ) . On the other hand , since there are some discrepancies of the implementation details such as using different backbone networks for training or different metrics for the evaluation among those SOTA weighting methods , leading to inconsistent comparisons , we provide a unified testbed on six CV datasets and four multilingual problems from the XTREME benchmark ( Hu et al. , 2020 ) for those SOTA weighting strategies to show a fair comparison . In addition , inspired by dynamic weighting processes in those SOTA strategies where loss weights vary over training iterations or epochs , we have a sudden whim : what will happen if a MTL model is trained with random loss weights ? Specifically , in each training iteration , we first sample the loss weights from a distribution with some normalization and then minimize the aggregated loss weighted by the normalized random weights . Surprisingly , this seemingly unreliable method can not only converge but also achieve comparable performance with the SOTA weighting strategies . Based on this observations , we proposed a simple yet effective weighting strategy for MTL , called Random Loss Weighting ( RLW ) . It is very easy to implement RLW by adding only one line of code and this strategy does not incur any additionally computational cost . An implementation example of RLW in PyTorch ( Paszke et al. , 2019 ) is shown below . 1 outputs = model ( inputs ) 2 loss = criterion ( outputs , labels ) # [ 1 , task_num ] vector 3 weight = F.softmax ( torch.randn ( task_num ) , dim=-1 ) # RLW is only this ! 4 loss = torch.sum ( loss * weight ) 5 optimizer.zero_grad ( ) 6 loss.backward ( ) 7 optimizer.step ( ) To show the effectiveness of RLW , we provide both theoretical analyses and empirical evaluations . Firstly , the objective function of RLW can be considered as a doubly stochastic optimization problem when optimizing by stochastic gradient descent or its variants , where the randomness is from both the mini-batch sampling of the data for each task and the random sampling of loss weights . From this perspective , we give a convergence analysis for RLW . Besides , we can show that RLW has a higher probability to escape local minima when compared with fixing loss weights , resulting in a better generalization performance . Empirically , as described before , we compare RLW with SOTA weighting approaches on six CV datasets and four multilingual problems to show its competitive performance . In summary , the main contributions of this paper are four-fold . • We provide a unified testbed on six multi-task computer vision datasets and four multilingual problems from the XTREME benchmark for a fair comparison among eight SOTA weighting methods and the proposed RLW method . • We propose a simple yet effective RLW strategy , which we think is an ignored baseline in MTL . • We provide the convergence guarantee and effectiveness analysis for RLW . • Experiments show that RLW can achieve comparable performance with SOTA weighting methods without bringing any additionally computational cost . 2 PRELIMINARY . Suppose there are T tasks and task t has its corresponding dataset Dt . An MTL model usually contains two parts of parameters : task-sharing parameters θ and task-specific parameters { ψt } Tt=1 . For example , in CV , θ usually denotes parameters in the feature extractor shared by all tasks and ψt represents the task-specific output module for task t. Let ` t ( · ; θ , ψt ) denotes a task-specific loss function for task t. Then the objective function of a MTL model can be formulated as LMTL = T∑ t=1 λt ` t ( Dt ; θ , ψt ) , ( 1 ) where ` t ( Dt ; θ , ψt ) denotes the average loss on Dt for task t and { λt } Tt=1 are task-specific loss weights with a constraint that λt ≥ 0 for all t. When minimizing Eq . ( 1 ) by Stochastic Gradient Descent ( SGD ) or its variants , the task-specific parameters { ψt } Tt=1 are simply updated based on the corresponding task gradient ∇ψt ` t ( Dt ; θ , ψt ) , while the task-sharing parameters θ should be updated by all the task losses jointly as θ = θ − η T∑ t=1 λt∇θ ` t ( Dt ; θ , ψt ) , ( 2 ) where η is a learning rate . Obviously , for the update of task-sharing parameters θ , the loss weighting ( i.e. , { λt } Tt=1 in Eq . ( 1 ) ) influences θ via the aggregated gradient essentially and the gradient weighting in Eq . ( 2 ) during the backward process has the same effect as the loss weighting when they are using the same weights . Therefore , we can ignore the level on which the weights act and focus on the generation of weights . For simplicity , these two types of weighting are all referred to as loss weighting in the following sections . Apparently , the most simple method for loss weighting is to set a same weight for every tasks , i.e. , without loss of generality , λt = 1T for all t. This approach is a common baseline in MTL and it is called Equally Weighting ( EW ) in this paper . To tackle the task balancing problem and improve the performance of MTL model , there are several works to study how to generate appropriate weights . In this paper , we investigate eight SOTA weighting strategies , i.e . Gradient Normalization ( GradNorm ) ( Chen et al. , 2018b ) , Uncertainty Weights ( UW ) ( Kendall et al. , 2018 ) , MGDA ( Sener & Koltun , 2018 ) , Dynamic Weight Average ( DWA ) ( Liu et al. , 2019a ) , Projecting Conflicting Gradient ( PCGrad ) ( Yu et al. , 2020 ) , Gradient sign Dropout ( GradDrop ) ( Chen et al. , 2020 ) , Impartial Multi-Task Learning ( IMTL ) ( Liu et al. , 2021 ) , and Gradient Vaccine ( GradVac ) ( Wang et al. , 2021 ) . According to different ways of generating loss weights , we categorize those loss weighting strategies into three types : the learning approach , the solving approach , and the calculating approach . Both GradNorm and UW consider the loss weights { λt } Tt=1 in Eq . ( 1 ) as learnable parameters and explicitly optimize them by gradient descent . MGDA casts MTL as a multi-objective optimization problem and directly solves the loss weights { λt } Tt=1 in Eq . ( 1 ) by solving a quadratic programming problem . DWA , PCGrad , GradDrop and GradVac directly compute the weights { λt } Tt=1 by combining gradients and/or losses of all the tasks . IMTL is a hybrid strategy , which combines the learning and the calculating approaches . We summarize those strategies from the perspective of loss weighting in Table 5 in Appendix A . We now unify those eight SOTA methods as loss weighting strategies , i.e. , generating loss weights { λt } Tt=1 in Eq . ( 1 ) . Noticeably , almost all the existing strategies except EW need to incur intensive computation to generate loss weights in every iteration , such as solving a quadratic optimization problem in MGDA , and operating on high-dimensional gradients in PCGrad , GradDrop , IMTL , and GradVac . Different from those strategies , the proposed RLW strategy generates loss weights in a sampling way , thus it is as efficient as EW without bringing additionally computational costs . 3 THE RLW METHOD . In this section , we introduce the proposed RLW method . The RLW method is a simple loss weighting strategy and it considers the loss weights λ = ( λ1 , · · · , λT ) ∈ RT as random variables . Formally , the objective function of the RLW method is formulated as LRLW ( θ ) = Eλ [ λ > ` ( D ; θ ) ] = Eλ [ λ ] > ` ( D ; θ ) , ( 3 ) where E [ · ] denotes the expectation and ` ( D ; θ ) = ( ` 1 ( D1 ; θ ) , · · · , ` T ( DT ; θ ) ) where we omit the task-specific parameters { ψt } Tt=1 in Eq . ( 3 ) for brevity . To guarantee loss weights in λ to be nonnegative , we can first sample λ̃ = ( λ̃1 , · · · , λ̃T ) from any distribution p ( λ̃ ) and then normalize λ̃ into λ via a mapping f , where f : RT → ∆T is a normalization function for example softmax function and ∆T denotes a convex hull in RT , i.e . λ ∈ ∆T means ∑T t=1 λt = 1 and λt ≥ 0 for all t. Note that in most cases p ( λ ) is different from p ( λ̃ ) . In Eq . ( 3 ) , p ( λ ) is usually too complex to compute its expectation Eλ [ λ ] , thus a stochastic approximation scheme is adopted to minimize Eq . ( 3 ) . When the mini-batch SGD ( Bottou , 1991 ) or its variants is used to minimize Eq . ( 3 ) as most deep learning models did , Eq . ( 3 ) can be viewed as a doubly stochastic optimization problem , where the randomness is from both the mini-batch data sampling for each task and the randomly sampling of the loss weights . In the following , we show that the approximated gradient ∇θλ > ` ( D̃ ; θ ) is an unbiased estimation of the true gradient of LRLW ( θ ) , where D̃ denotes a mini-batch data sampled from all the tasks . Specifically , as D̃t is a mini-batch data sampled from Dt to calculate the stochastic gradient ∇θ ` t ( D̃t ; θ ) to approximate the full gradient ∇θ ` t ( Dt ; θ ) for task t , we have ED̃ [ ∇θ ` ( D̃ ; θ ) ] = ∇θ ` ( D ; θ ) . Therefore , when we further randomly sample a weight vector λ , we have Eλ [ ED̃ [ ∇θλ > ` ( D̃ ; θ ) ] ] = Eλ [ λ ] > ∇θ ` ( D ; θ ) = ∇θLRLW ( θ ) , which verifies that∇θλ > ` ( D̃ ; θ ) is an unbiased estimation . In practice , it is very easy to implement the RLW method without modifying network architecture or bringing additionally computational costs . Specifically , in each iteration , we first sample λ̃ from p ( λ̃ ) and normalize it to obtain λ via appropriate normalization function f , and then minimize the aggregated loss weighted by λ . The entire algorithm of RLW ( i.e. , minimizing Eq . ( 3 ) ) via SGD is shown in Algorithm 1 . Apparently , the only difference between the proposed RLW strategy and the widely used EW strategy is Line 7 in Algorithm 1 and it is very easy to implement with only one line of code . Algorithm 1 Optimization Algorithm for RLW by SGD Input : numbers of iterations K , numbers of tasks T , learning rate η , dataset { Dt } Tt=1 , weight distribution p ( λ̃ ) 1 : Randomly initialized θ0 ; 2 : for k = 1 to K do 3 : for t = 1 to T do 4 : Sample a mini-batch data D̃t from Dt ; 5 : Compute loss ` t ( D̃t ; θk ) ; 6 : end for 7 : Sample weights λ̃ from p ( λ̃ ) and normalize it into λ via f ; . RLW is only this 8 : θk+1 = θk − η∇θ ∑T t=1 λt ` t ( D̃t ; θk ) ; 9 : end for In this paper , we use six different distributions for p ( λ̃ ) in the proposed RLW method , including uniform distribution between 0 and 1 ( denoted by Uniform ) , standard normal distribution ( denoted by Normal ) , Dirichlet distribution with α = 1 ( denoted by Dirichlet ) , Bernoulli distribution with probability 1/2 ( denoted by Bernoulli ) , Bernoulli distribution with probability 1/2 and a constraint ∑T t=1 λ̃t = 1 ( denoted by constrained Bernoulli ) , and normal distribution with a random mean and a random variance both sampling from a uniform distribution U ( 0 , 1 ) for each task ( denoted by random Normal ) . We set f as a function of f ( λ̃ ) = λ̃/ ( ∑T t=1 λ̃t ) if p ( λ̃ ) is the Bernoulli distribution or the constrained Bernoulli distribution and a softmax function for the other types of distribution . When sampling from the first five types of distribution , E [ λ ] is simply proportional to ( 1T , · · · , 1 T ) , thus it is fair to compare with the EW strategy . When p ( λ̃ ) is a random Normal distribution , it means each λ̃t is sampled from a normal distribution with random mean and variance , thus it is intractable to compute the expectation for p ( λ ) and combining with such distribution can further show the effectiveness of RLW . When sampling from a Bernoulli distribution , the weights for all tasks are either 0 or 1 , i.e. , λt ∈ { 0 , 1 } for all t. In this way , just a subset of tasks contributes to updating the task-sharing parameters θ . This manner can be viewed as the mini-batch sampling on the task level . If considering an additional constraint that ∑T t=1 λ̃t = 1 , it implies only one task is involved in the update of the tasksharing parameters in each iteration . Although there are some works ( Dong et al. , 2015 ; Liu et al. , 2015a ; Søgaard & Goldberg , 2016 ; Subramanian et al. , 2018 ; Sanh et al. , 2019 ; Liu et al. , 2019b ) adopting this strategy to train a MTL model , it is a special case in the proposed RLW strategy and beyond existing works , we also provide theoretical analyses to show the effectiveness of the proposed RLW method . | Authors propose a dynamic loss weighting algorithm that chooses random loss weights per step from a chosen distribution in a multitask setting. Model with these dynamic weights is then trained until convergence. Theoretical analysis on convergence is provided and experimental results on NYUv2, PASCAL-Context, and XTREME are given. The method seems to perform relatively on par or a bit worse compared with other SOTA methods but does not require computation of gradients. | SP:a1cb382f8c5f55bbecc2230e01b13e23f63e3ad1 |
A Closer Look at Loss Weighting in Multi-Task Learning | 1 INTRODUCTION . Multi-Task Learning ( MTL ) ( Zhang & Yang , 2021 ; Vandenhende et al. , 2021 ) aims to jointly train several related tasks to improve their generalization performance by leveraging common knowledge among them . Since this learning paradigm can not only significantly reduce the model size and increase the inference speed but also improve the performance , it has been successfully applied in various fields of deep learning , such as Computer Vision ( CV ) ( Vandenhende et al. , 2021 ) , Natural Language Processing ( NLP ) ( Chen et al. , 2021 ) , reinforcement learning ( Zhang & Yang , 2021 ) and so on . However , when all the tasks are not related enough , which may be reflected via conflicting gradients or dominating gradients ( Yu et al. , 2020 ) , it is more difficult to train a multi-task model than training them separately because some tasks dominantly influence model parameters , leading to unsatisfactory performance for other tasks . This phenomenon is related to the task balancing problem ( Vandenhende et al. , 2021 ) in MTL . Recently , several works focus on tackling this issue from an optimization perspective via balancing task losses or gradients . In this paper , we investigate eight State-Of-The-Art ( SOTA ) task balancing approaches and unify them as loss weighting strategies . According to the way of generating loss weights , those methods can be divided into three types , including the solving approach such as directly solving a quadratic optimization problem in a multi-objective formulation as weights ( Sener & Koltun , 2018 ) , the calculating approach such as projecting conflict gradients ( Yu et al. , 2020 ) , and the learning approach such as learning weights in a gradient descent manner ( Chen et al. , 2018b ) . On the other hand , since there are some discrepancies of the implementation details such as using different backbone networks for training or different metrics for the evaluation among those SOTA weighting methods , leading to inconsistent comparisons , we provide a unified testbed on six CV datasets and four multilingual problems from the XTREME benchmark ( Hu et al. , 2020 ) for those SOTA weighting strategies to show a fair comparison . In addition , inspired by dynamic weighting processes in those SOTA strategies where loss weights vary over training iterations or epochs , we have a sudden whim : what will happen if a MTL model is trained with random loss weights ? Specifically , in each training iteration , we first sample the loss weights from a distribution with some normalization and then minimize the aggregated loss weighted by the normalized random weights . Surprisingly , this seemingly unreliable method can not only converge but also achieve comparable performance with the SOTA weighting strategies . Based on this observations , we proposed a simple yet effective weighting strategy for MTL , called Random Loss Weighting ( RLW ) . It is very easy to implement RLW by adding only one line of code and this strategy does not incur any additionally computational cost . An implementation example of RLW in PyTorch ( Paszke et al. , 2019 ) is shown below . 1 outputs = model ( inputs ) 2 loss = criterion ( outputs , labels ) # [ 1 , task_num ] vector 3 weight = F.softmax ( torch.randn ( task_num ) , dim=-1 ) # RLW is only this ! 4 loss = torch.sum ( loss * weight ) 5 optimizer.zero_grad ( ) 6 loss.backward ( ) 7 optimizer.step ( ) To show the effectiveness of RLW , we provide both theoretical analyses and empirical evaluations . Firstly , the objective function of RLW can be considered as a doubly stochastic optimization problem when optimizing by stochastic gradient descent or its variants , where the randomness is from both the mini-batch sampling of the data for each task and the random sampling of loss weights . From this perspective , we give a convergence analysis for RLW . Besides , we can show that RLW has a higher probability to escape local minima when compared with fixing loss weights , resulting in a better generalization performance . Empirically , as described before , we compare RLW with SOTA weighting approaches on six CV datasets and four multilingual problems to show its competitive performance . In summary , the main contributions of this paper are four-fold . • We provide a unified testbed on six multi-task computer vision datasets and four multilingual problems from the XTREME benchmark for a fair comparison among eight SOTA weighting methods and the proposed RLW method . • We propose a simple yet effective RLW strategy , which we think is an ignored baseline in MTL . • We provide the convergence guarantee and effectiveness analysis for RLW . • Experiments show that RLW can achieve comparable performance with SOTA weighting methods without bringing any additionally computational cost . 2 PRELIMINARY . Suppose there are T tasks and task t has its corresponding dataset Dt . An MTL model usually contains two parts of parameters : task-sharing parameters θ and task-specific parameters { ψt } Tt=1 . For example , in CV , θ usually denotes parameters in the feature extractor shared by all tasks and ψt represents the task-specific output module for task t. Let ` t ( · ; θ , ψt ) denotes a task-specific loss function for task t. Then the objective function of a MTL model can be formulated as LMTL = T∑ t=1 λt ` t ( Dt ; θ , ψt ) , ( 1 ) where ` t ( Dt ; θ , ψt ) denotes the average loss on Dt for task t and { λt } Tt=1 are task-specific loss weights with a constraint that λt ≥ 0 for all t. When minimizing Eq . ( 1 ) by Stochastic Gradient Descent ( SGD ) or its variants , the task-specific parameters { ψt } Tt=1 are simply updated based on the corresponding task gradient ∇ψt ` t ( Dt ; θ , ψt ) , while the task-sharing parameters θ should be updated by all the task losses jointly as θ = θ − η T∑ t=1 λt∇θ ` t ( Dt ; θ , ψt ) , ( 2 ) where η is a learning rate . Obviously , for the update of task-sharing parameters θ , the loss weighting ( i.e. , { λt } Tt=1 in Eq . ( 1 ) ) influences θ via the aggregated gradient essentially and the gradient weighting in Eq . ( 2 ) during the backward process has the same effect as the loss weighting when they are using the same weights . Therefore , we can ignore the level on which the weights act and focus on the generation of weights . For simplicity , these two types of weighting are all referred to as loss weighting in the following sections . Apparently , the most simple method for loss weighting is to set a same weight for every tasks , i.e. , without loss of generality , λt = 1T for all t. This approach is a common baseline in MTL and it is called Equally Weighting ( EW ) in this paper . To tackle the task balancing problem and improve the performance of MTL model , there are several works to study how to generate appropriate weights . In this paper , we investigate eight SOTA weighting strategies , i.e . Gradient Normalization ( GradNorm ) ( Chen et al. , 2018b ) , Uncertainty Weights ( UW ) ( Kendall et al. , 2018 ) , MGDA ( Sener & Koltun , 2018 ) , Dynamic Weight Average ( DWA ) ( Liu et al. , 2019a ) , Projecting Conflicting Gradient ( PCGrad ) ( Yu et al. , 2020 ) , Gradient sign Dropout ( GradDrop ) ( Chen et al. , 2020 ) , Impartial Multi-Task Learning ( IMTL ) ( Liu et al. , 2021 ) , and Gradient Vaccine ( GradVac ) ( Wang et al. , 2021 ) . According to different ways of generating loss weights , we categorize those loss weighting strategies into three types : the learning approach , the solving approach , and the calculating approach . Both GradNorm and UW consider the loss weights { λt } Tt=1 in Eq . ( 1 ) as learnable parameters and explicitly optimize them by gradient descent . MGDA casts MTL as a multi-objective optimization problem and directly solves the loss weights { λt } Tt=1 in Eq . ( 1 ) by solving a quadratic programming problem . DWA , PCGrad , GradDrop and GradVac directly compute the weights { λt } Tt=1 by combining gradients and/or losses of all the tasks . IMTL is a hybrid strategy , which combines the learning and the calculating approaches . We summarize those strategies from the perspective of loss weighting in Table 5 in Appendix A . We now unify those eight SOTA methods as loss weighting strategies , i.e. , generating loss weights { λt } Tt=1 in Eq . ( 1 ) . Noticeably , almost all the existing strategies except EW need to incur intensive computation to generate loss weights in every iteration , such as solving a quadratic optimization problem in MGDA , and operating on high-dimensional gradients in PCGrad , GradDrop , IMTL , and GradVac . Different from those strategies , the proposed RLW strategy generates loss weights in a sampling way , thus it is as efficient as EW without bringing additionally computational costs . 3 THE RLW METHOD . In this section , we introduce the proposed RLW method . The RLW method is a simple loss weighting strategy and it considers the loss weights λ = ( λ1 , · · · , λT ) ∈ RT as random variables . Formally , the objective function of the RLW method is formulated as LRLW ( θ ) = Eλ [ λ > ` ( D ; θ ) ] = Eλ [ λ ] > ` ( D ; θ ) , ( 3 ) where E [ · ] denotes the expectation and ` ( D ; θ ) = ( ` 1 ( D1 ; θ ) , · · · , ` T ( DT ; θ ) ) where we omit the task-specific parameters { ψt } Tt=1 in Eq . ( 3 ) for brevity . To guarantee loss weights in λ to be nonnegative , we can first sample λ̃ = ( λ̃1 , · · · , λ̃T ) from any distribution p ( λ̃ ) and then normalize λ̃ into λ via a mapping f , where f : RT → ∆T is a normalization function for example softmax function and ∆T denotes a convex hull in RT , i.e . λ ∈ ∆T means ∑T t=1 λt = 1 and λt ≥ 0 for all t. Note that in most cases p ( λ ) is different from p ( λ̃ ) . In Eq . ( 3 ) , p ( λ ) is usually too complex to compute its expectation Eλ [ λ ] , thus a stochastic approximation scheme is adopted to minimize Eq . ( 3 ) . When the mini-batch SGD ( Bottou , 1991 ) or its variants is used to minimize Eq . ( 3 ) as most deep learning models did , Eq . ( 3 ) can be viewed as a doubly stochastic optimization problem , where the randomness is from both the mini-batch data sampling for each task and the randomly sampling of the loss weights . In the following , we show that the approximated gradient ∇θλ > ` ( D̃ ; θ ) is an unbiased estimation of the true gradient of LRLW ( θ ) , where D̃ denotes a mini-batch data sampled from all the tasks . Specifically , as D̃t is a mini-batch data sampled from Dt to calculate the stochastic gradient ∇θ ` t ( D̃t ; θ ) to approximate the full gradient ∇θ ` t ( Dt ; θ ) for task t , we have ED̃ [ ∇θ ` ( D̃ ; θ ) ] = ∇θ ` ( D ; θ ) . Therefore , when we further randomly sample a weight vector λ , we have Eλ [ ED̃ [ ∇θλ > ` ( D̃ ; θ ) ] ] = Eλ [ λ ] > ∇θ ` ( D ; θ ) = ∇θLRLW ( θ ) , which verifies that∇θλ > ` ( D̃ ; θ ) is an unbiased estimation . In practice , it is very easy to implement the RLW method without modifying network architecture or bringing additionally computational costs . Specifically , in each iteration , we first sample λ̃ from p ( λ̃ ) and normalize it to obtain λ via appropriate normalization function f , and then minimize the aggregated loss weighted by λ . The entire algorithm of RLW ( i.e. , minimizing Eq . ( 3 ) ) via SGD is shown in Algorithm 1 . Apparently , the only difference between the proposed RLW strategy and the widely used EW strategy is Line 7 in Algorithm 1 and it is very easy to implement with only one line of code . Algorithm 1 Optimization Algorithm for RLW by SGD Input : numbers of iterations K , numbers of tasks T , learning rate η , dataset { Dt } Tt=1 , weight distribution p ( λ̃ ) 1 : Randomly initialized θ0 ; 2 : for k = 1 to K do 3 : for t = 1 to T do 4 : Sample a mini-batch data D̃t from Dt ; 5 : Compute loss ` t ( D̃t ; θk ) ; 6 : end for 7 : Sample weights λ̃ from p ( λ̃ ) and normalize it into λ via f ; . RLW is only this 8 : θk+1 = θk − η∇θ ∑T t=1 λt ` t ( D̃t ; θk ) ; 9 : end for In this paper , we use six different distributions for p ( λ̃ ) in the proposed RLW method , including uniform distribution between 0 and 1 ( denoted by Uniform ) , standard normal distribution ( denoted by Normal ) , Dirichlet distribution with α = 1 ( denoted by Dirichlet ) , Bernoulli distribution with probability 1/2 ( denoted by Bernoulli ) , Bernoulli distribution with probability 1/2 and a constraint ∑T t=1 λ̃t = 1 ( denoted by constrained Bernoulli ) , and normal distribution with a random mean and a random variance both sampling from a uniform distribution U ( 0 , 1 ) for each task ( denoted by random Normal ) . We set f as a function of f ( λ̃ ) = λ̃/ ( ∑T t=1 λ̃t ) if p ( λ̃ ) is the Bernoulli distribution or the constrained Bernoulli distribution and a softmax function for the other types of distribution . When sampling from the first five types of distribution , E [ λ ] is simply proportional to ( 1T , · · · , 1 T ) , thus it is fair to compare with the EW strategy . When p ( λ̃ ) is a random Normal distribution , it means each λ̃t is sampled from a normal distribution with random mean and variance , thus it is intractable to compute the expectation for p ( λ ) and combining with such distribution can further show the effectiveness of RLW . When sampling from a Bernoulli distribution , the weights for all tasks are either 0 or 1 , i.e. , λt ∈ { 0 , 1 } for all t. In this way , just a subset of tasks contributes to updating the task-sharing parameters θ . This manner can be viewed as the mini-batch sampling on the task level . If considering an additional constraint that ∑T t=1 λ̃t = 1 , it implies only one task is involved in the update of the tasksharing parameters in each iteration . Although there are some works ( Dong et al. , 2015 ; Liu et al. , 2015a ; Søgaard & Goldberg , 2016 ; Subramanian et al. , 2018 ; Sanh et al. , 2019 ; Liu et al. , 2019b ) adopting this strategy to train a MTL model , it is a special case in the proposed RLW strategy and beyond existing works , we also provide theoretical analyses to show the effectiveness of the proposed RLW method . | Here, the authors present a novel method for multitasking loss weighting called Random Loss Weighting (RLW). The method is straightforward and clearly described; RLW considers the loss weights lambda as random variables. In practice, it works by sampling the loss weights from a distribution (authors evaluated six different distributions) with some normalization and then minimizing the aggregated loss weighted by the normalized random weights. The authors provided an extensive empirical evaluation including eight state-of-the-art loss weighting strategies on six computer vision datasets and the XTREME benchmark (four multilingual problems). RWL results are comparable to previous strategies, but with a lower computational burden. The authors also provided a theoretical analysis on how the extra randomness from the sampling affects the convergence and effectiveness of RLW compared with fixed loss weights optimized via SGD. | SP:a1cb382f8c5f55bbecc2230e01b13e23f63e3ad1 |
SABAL: Sparse Approximation-based Batch Active Learning | 1 INTRODUCTION . Over the last decade , deep neural networks have achieved promising results in various learning tasks . However , obtaining labels for a complex training dataset can be challenging in practice , as the data annotation is usually a time-consuming process that may require professional knowledge in certain applications such as in medicine ( Hoi et al. , 2006 ; Shen et al. , 2021 ) . Active Learning ( AL ) ( Settles , 2009 ) is commonly employed to mitigate the problem of scarce labeled data – enabling efficient model training with limited annotation costs . Given a partially labeled dataset , active learning ideally selects data samples that are the best for learning . Specifically , it aims to iteratively query the most helpful data to ask an oracle ( human annotator ) to annotate . The queried data samples can be added back to the labeled data pool , and the model is updated . This process is repeated until the model has achieved the desired performance . Intelligently identifying the most valuable data for annotation , also known as the query strategy , is the key problem in active learning . A common strategy is to take the prediction uncertainty or data representation as the metric for data query . This uncertainty-based approach ( Settles , 2009 ; Tong & Koller , 2001 ; Gal et al. , 2017 ; Beluch et al. , 2018 ) works by querying samples with high uncertainty , but often results in selecting correlated and redundant data samples in each batch ( Kirsch et al. , 2019 ; Ducoffe & Precioso , 2018 ) . Representation-based approaches ( Sener & Savarese , 2017 ; Yang & Loog , 2019 ) aim to select a subset of data that represents the whole unlabeled dataset , but tend to be computationally expensive and sensitive to batch sizes ( Ash et al. , 2019 ; Shui et al. , 2020 ) . More recently , several hybrid approaches that try to take both uncertainty and representation into consideration have shown advantages ( Ash et al. , 2019 ; Shui et al. , 2020 ; Sinha et al. , 2019 ) . This paper takes this hybrid view towards an active learning framework that balances the trade-off between uncertainty and representation . Besides hybrid approaches , deep Bayesian active learning has also gained attention due to recent advances in Bayesian deep learning . Several Bayesian approaches ( Gal et al. , 2017 ; Kirsch et al. , 2019 ) leverage model uncertainty measurements ( Gal & Ghahramani , 2015 ; 2016 ) determined by Bayesian neural networks , while other works ( Pinsler et al. , 2019 ) leverage progress in Bayesian Coreset problems ( Zhang et al. , 2021 ; Huggins et al. , 2016 ; Campbell & Broderick , 2019 ) . However , as most existing Bayesian approaches are explicitly designed for Bayesian neural networks , another goal of this paper is to propose a general method for both Bayesian and non-Bayesian models . For deep models , it is reasonable to query a large batch of data simultaneously to reduce model update frequency . The batch selection approach is known as batch active learning . Taking an optimization perspective , finding the best batch is NP-hard in general . Two common approaches for such combinatorial problems are the greedy and clustering approaches . Greedy algorithms select one data sample in sequence until the batch budget is exhausted ( Kirsch et al. , 2019 ; Bıyık et al. , 2019 ; Chen & Krause , 2013 ) . Here , specific conditions of the acquisition function such as submodularity ( Nemhauser et al. , 1978 ) are required to guarantee a good optimization result . Clustering algorithms regard cluster centers as their queried batch ( Sener & Savarese , 2017 ; Ash et al. , 2019 ) , but can be computationally expensive . To our knowledge , except for Pinsler et al . ( 2019 ) that focus on the Bayesian models , so far active learning has rarely been studied from a sparse approximation perspective . This is despite the ubiquity of sparse approximation in signal processing for tasks such as dictionary learning ( Aharon et al. , 2006 ) and compressed sensing ( Donoho , 2006 ) due to its performance for discovering a sparse representation while avoiding redundant information . Here we employ sparse approximation methods for batch active learning tasks . Our main contributions are summarized in the following . We propose a novel and flexible Sparse Approximation-based Batch Active Learning framework , i.e. , SABAL . We show how SABAL generalizes batch active learning as a sparse approximation problem and can adapt to different settings and models . The central intuition of SABAL is finding a weighted subset from the unlabeled data pool so that its corresponding training loss approximates the full-set loss function in a function space . We realize the SABAL framework as an efficient finite-dimensional optimization problem : First , we derive an upper bound to balance the trade-off between uncertainty and representation in a principled way . Second , we approximate the loss functions using finite-dimensional approximation . This results in a sparsity-constrained discontinuous optimization problem , for which we propose several efficient optimization algorithms . We demonstrate the advantages of SABAL in experiments for both Bayesian and non-Bayesian batch active learning settings . The structure of this manuscript is as follows . In Section 2 , we formulate the general framework of SABAL , and in Section 3 , we realize the framework into a finite-dimensional discontinuous sparse optimization problem . To solve the resulting optimization problem , we propose two optimization algorithms in Section 4 . Related work are discussed in Section 5 and Appendix Section B . Results of our experiments are presented in section 6 , and all proofs are provided in Appendix Section C . 2 BATCH ACTIVE LEARNING AS SPARSE APPROXIMATION . This section introduces the preliminaries and the general formulation of batch active learning as a sparse approximation problem . Preliminaries Vectors are denoted as bold lower case letters , e.g. , w ∈ Rn . The l0 pseudonorm of a vector w is denoted as ‖w‖0 , i.e. , the number of non-zero elements of w. We denote R+ : = [ 0 , +∞ ) . Distributions are denoted in script , e.g. , P , and a random variable is denoted by tilde , e.g. , ỹ ∼P . We denote sets in calligraphy or in uppercase Greek alphabet ( e.g. , D , Θ ) , and additionally we denote [ n ] : = { 1 , 2 , . . . , n } . In supervised learning , given a labeled training dataset Dl : = { ( xi , yi ) } nli=1 , where we denote their domain to be x ∈ X and y ∈ Y , the empirical goal is to minimize a loss function Ll ( θ ) : = ∑ ( xi , yi ) ∈Dl ` ( xi , yi ; θ ) formed by the training dataset , where θ ∈ Θ ⊂ Rm is the parameter of the model and ` is a loss function evaluated on individual pairs of data . Without loss of generality , we assume Θ ⊂ Rm is compact and ` ( x , y ; · ) : Θ→ R is in a normed space ( L ( Θ , R ) , ‖ · ‖† ) for all x , y . We further assume the constant function f : Θ→ 1 is included in L ( Θ , R ) . The “ † ” in the norm ‖ · ‖† : L ( Θ , R ) → R+ , representing its definition is a placeholder that will be discussed later . Batch Active Learning Besides the labeled dataset Dl , there is an unlabeled dataset Du : = { xj } nuj=1 where the labels are unknown but could be acquired at a high cost through human labeling . Combining two datasets , the ideal loss function to minimize w.r.t . θ is∑ ( xi , yi ) ∈Dl ` ( xi , yi ; θ ) + ∑ xj∈Du ` ( xj , y ? j ; θ ) , ( 1 ) where y ? j is the unknown true label corresponding to the data xj . Since acquiring true labels could be costly , we have to impose a budget b ( b < nu ) on the number of label acquisitions . Therefore , the batch active learning problem is to find a subset S ⊂ Du such that we can obtain a good model by optimizing the following loss function w.r.t . θ , ∑ ( xi , yi ) ∈Dl ` ( xi , yi ; θ ) + ∑ xj∈S ` ( xj , y ? j ; θ ) , where |S| = b . ( 2 ) Generalized Batch Active Learning We start our method by generalizing the classical formulation ( equation 2 ) by considering an importance weight for each unlabeled data . That is , we aim to find a sparse non-negative vector w ∈ Rnu+ such that we can obtain a good model by optimizing the following loss function w.r.t . θ : ∑ ( xi , yi ) ∈Dl ` ( xi , yi ; θ ) + ∑ xj∈Du wj ` ( xj , y ? j ; θ ) , where ‖w‖0 = b . ( 3 ) A key question now is—what is the criterion for a good w ? Comparing the ideal loss function ( equation 1 ) and the sparse importance weighted loss ( equation 3 ) , the only difference is their unlabeled data loss functions . Therefore , a straight-forward informal criterion for a good importance weight w is that the two unlabeled data loss functions are close to each other , i.e. , L ? w ( θ ) : = 1 b ∑ xj∈Du wj ` ( xj , y ? j ; θ ) ≈ L ? ( θ ) : = 1 nu ∑ xj∈Du ` ( xj , y ? j ; θ ) . However , as the true labels are unknown , we can not compute L ? w and L ? . Luckily , we can have an estimator for the true labels , i.e. , estimation based on the labeled data p ( ỹj | xj , Dl ) or an approximation of it . Denote P ( xj ) as an estimated distribution , so ỹj ∼P ( xj ) , then the informal criterion for a good importance weight w then becomes L̃w ( θ ) : = 1 b ∑ xj∈Du wj ` ( xj , ỹj ; θ ) ≈ L̃ ( θ ) : = 1 nu ∑ xj∈Du ` ( xj , ỹj ; θ ) . ( 4 ) Thus , we are one step closer to evaluating the quality of a weighted selection . The next question is how to measure the difference between L̃ and L̃w . Difference Between Two Loss Functions Given the two loss functions L̃ , L̃w ∈ L ( Θ , R ) , where L ( Θ , R ) is equipped with the norm ‖ · ‖† , a straight-forward measurement of the difference between them is ‖L̃− L̃w‖† . However , observing that the optimization of a loss function is shift-invariant , the difference between two loss functions should also be shift-invariant . For example , for ∀L ∈ L ( Θ , R ) we have arg minθ∈Θ ( L ( θ ) + c ) = arg minθ∈Θ L ( θ ) for ∀c ∈ R , implying that L + c should be treated the same as L. Therefore , to account for the shift-invariance , we define q : L ( Θ , R ) → R+ as q ( L ) : = inf c∈R ‖L+ c‖† , ∀L ∈ L ( Θ , R ) . ( 5 ) Note that we abuse the notation a bit , i.e. , the c in L+ c should be the constant function that maps every θ ∈ Θ to c. The above definition has some nice properties that make it a good difference measurement of two loss functions , as proved in proposition C.1 in the appendix . In particular , q ( · ) satisfies the triangle inequality , and q ( L+ c ) = q ( L ) for any constant c. Therefore , we can formulate the generalized batch active learning problem as the following sparse approximation problem . Problem 1 ( Sparse Approximation-based Batch Active Learning ) . Given the shift-invariant seminorm q induced by the norm ‖ · ‖† ( equation 5 ) , and a label estimation distribution P , the generalized batch active learning problem ( equation 4 ) is formally defined as arg min w∈Rnu+ EP [ q ( L̃− L̃w ) ] s.t . ‖w‖0 = b , ( 6 ) where EP stands for the expectation over ỹj ∼P ( xj ) for ∀j ∈ [ nu ] . Problem 1 ( SABAL ) offers a general framework for batch active learning and can be applied with various settings , i.e. , both the norm ‖ · ‖† and the individual loss function ` can be chosen based on specific problems and applications . In the next section , we introduce two practical realizations of equation 6 for Bayesian and non-Bayesian active learning respectively . | The paper proposes SABAL as a framework to formulate batch active learning as a sparse approximation problem. The paper considers the SABAL framework as a finite-dimensional optimization problem, efficiently solvable by the proposed greedy or proximal IHT algorithms. Numerical experiments demonstrate the strong performance of SABAL, comparable to the state-of-the-art with lower time complexity. Since directly optimising the original objective function is intractable, SABAL proposes to optimise (minimise) the upper bound which is obtained by the triangle inequality including the (i) variance and (ii) approximation bias. | SP:b9c6ff37d1ddb4fb9ea58b4b4daf9b58cb35c778 |
SABAL: Sparse Approximation-based Batch Active Learning | 1 INTRODUCTION . Over the last decade , deep neural networks have achieved promising results in various learning tasks . However , obtaining labels for a complex training dataset can be challenging in practice , as the data annotation is usually a time-consuming process that may require professional knowledge in certain applications such as in medicine ( Hoi et al. , 2006 ; Shen et al. , 2021 ) . Active Learning ( AL ) ( Settles , 2009 ) is commonly employed to mitigate the problem of scarce labeled data – enabling efficient model training with limited annotation costs . Given a partially labeled dataset , active learning ideally selects data samples that are the best for learning . Specifically , it aims to iteratively query the most helpful data to ask an oracle ( human annotator ) to annotate . The queried data samples can be added back to the labeled data pool , and the model is updated . This process is repeated until the model has achieved the desired performance . Intelligently identifying the most valuable data for annotation , also known as the query strategy , is the key problem in active learning . A common strategy is to take the prediction uncertainty or data representation as the metric for data query . This uncertainty-based approach ( Settles , 2009 ; Tong & Koller , 2001 ; Gal et al. , 2017 ; Beluch et al. , 2018 ) works by querying samples with high uncertainty , but often results in selecting correlated and redundant data samples in each batch ( Kirsch et al. , 2019 ; Ducoffe & Precioso , 2018 ) . Representation-based approaches ( Sener & Savarese , 2017 ; Yang & Loog , 2019 ) aim to select a subset of data that represents the whole unlabeled dataset , but tend to be computationally expensive and sensitive to batch sizes ( Ash et al. , 2019 ; Shui et al. , 2020 ) . More recently , several hybrid approaches that try to take both uncertainty and representation into consideration have shown advantages ( Ash et al. , 2019 ; Shui et al. , 2020 ; Sinha et al. , 2019 ) . This paper takes this hybrid view towards an active learning framework that balances the trade-off between uncertainty and representation . Besides hybrid approaches , deep Bayesian active learning has also gained attention due to recent advances in Bayesian deep learning . Several Bayesian approaches ( Gal et al. , 2017 ; Kirsch et al. , 2019 ) leverage model uncertainty measurements ( Gal & Ghahramani , 2015 ; 2016 ) determined by Bayesian neural networks , while other works ( Pinsler et al. , 2019 ) leverage progress in Bayesian Coreset problems ( Zhang et al. , 2021 ; Huggins et al. , 2016 ; Campbell & Broderick , 2019 ) . However , as most existing Bayesian approaches are explicitly designed for Bayesian neural networks , another goal of this paper is to propose a general method for both Bayesian and non-Bayesian models . For deep models , it is reasonable to query a large batch of data simultaneously to reduce model update frequency . The batch selection approach is known as batch active learning . Taking an optimization perspective , finding the best batch is NP-hard in general . Two common approaches for such combinatorial problems are the greedy and clustering approaches . Greedy algorithms select one data sample in sequence until the batch budget is exhausted ( Kirsch et al. , 2019 ; Bıyık et al. , 2019 ; Chen & Krause , 2013 ) . Here , specific conditions of the acquisition function such as submodularity ( Nemhauser et al. , 1978 ) are required to guarantee a good optimization result . Clustering algorithms regard cluster centers as their queried batch ( Sener & Savarese , 2017 ; Ash et al. , 2019 ) , but can be computationally expensive . To our knowledge , except for Pinsler et al . ( 2019 ) that focus on the Bayesian models , so far active learning has rarely been studied from a sparse approximation perspective . This is despite the ubiquity of sparse approximation in signal processing for tasks such as dictionary learning ( Aharon et al. , 2006 ) and compressed sensing ( Donoho , 2006 ) due to its performance for discovering a sparse representation while avoiding redundant information . Here we employ sparse approximation methods for batch active learning tasks . Our main contributions are summarized in the following . We propose a novel and flexible Sparse Approximation-based Batch Active Learning framework , i.e. , SABAL . We show how SABAL generalizes batch active learning as a sparse approximation problem and can adapt to different settings and models . The central intuition of SABAL is finding a weighted subset from the unlabeled data pool so that its corresponding training loss approximates the full-set loss function in a function space . We realize the SABAL framework as an efficient finite-dimensional optimization problem : First , we derive an upper bound to balance the trade-off between uncertainty and representation in a principled way . Second , we approximate the loss functions using finite-dimensional approximation . This results in a sparsity-constrained discontinuous optimization problem , for which we propose several efficient optimization algorithms . We demonstrate the advantages of SABAL in experiments for both Bayesian and non-Bayesian batch active learning settings . The structure of this manuscript is as follows . In Section 2 , we formulate the general framework of SABAL , and in Section 3 , we realize the framework into a finite-dimensional discontinuous sparse optimization problem . To solve the resulting optimization problem , we propose two optimization algorithms in Section 4 . Related work are discussed in Section 5 and Appendix Section B . Results of our experiments are presented in section 6 , and all proofs are provided in Appendix Section C . 2 BATCH ACTIVE LEARNING AS SPARSE APPROXIMATION . This section introduces the preliminaries and the general formulation of batch active learning as a sparse approximation problem . Preliminaries Vectors are denoted as bold lower case letters , e.g. , w ∈ Rn . The l0 pseudonorm of a vector w is denoted as ‖w‖0 , i.e. , the number of non-zero elements of w. We denote R+ : = [ 0 , +∞ ) . Distributions are denoted in script , e.g. , P , and a random variable is denoted by tilde , e.g. , ỹ ∼P . We denote sets in calligraphy or in uppercase Greek alphabet ( e.g. , D , Θ ) , and additionally we denote [ n ] : = { 1 , 2 , . . . , n } . In supervised learning , given a labeled training dataset Dl : = { ( xi , yi ) } nli=1 , where we denote their domain to be x ∈ X and y ∈ Y , the empirical goal is to minimize a loss function Ll ( θ ) : = ∑ ( xi , yi ) ∈Dl ` ( xi , yi ; θ ) formed by the training dataset , where θ ∈ Θ ⊂ Rm is the parameter of the model and ` is a loss function evaluated on individual pairs of data . Without loss of generality , we assume Θ ⊂ Rm is compact and ` ( x , y ; · ) : Θ→ R is in a normed space ( L ( Θ , R ) , ‖ · ‖† ) for all x , y . We further assume the constant function f : Θ→ 1 is included in L ( Θ , R ) . The “ † ” in the norm ‖ · ‖† : L ( Θ , R ) → R+ , representing its definition is a placeholder that will be discussed later . Batch Active Learning Besides the labeled dataset Dl , there is an unlabeled dataset Du : = { xj } nuj=1 where the labels are unknown but could be acquired at a high cost through human labeling . Combining two datasets , the ideal loss function to minimize w.r.t . θ is∑ ( xi , yi ) ∈Dl ` ( xi , yi ; θ ) + ∑ xj∈Du ` ( xj , y ? j ; θ ) , ( 1 ) where y ? j is the unknown true label corresponding to the data xj . Since acquiring true labels could be costly , we have to impose a budget b ( b < nu ) on the number of label acquisitions . Therefore , the batch active learning problem is to find a subset S ⊂ Du such that we can obtain a good model by optimizing the following loss function w.r.t . θ , ∑ ( xi , yi ) ∈Dl ` ( xi , yi ; θ ) + ∑ xj∈S ` ( xj , y ? j ; θ ) , where |S| = b . ( 2 ) Generalized Batch Active Learning We start our method by generalizing the classical formulation ( equation 2 ) by considering an importance weight for each unlabeled data . That is , we aim to find a sparse non-negative vector w ∈ Rnu+ such that we can obtain a good model by optimizing the following loss function w.r.t . θ : ∑ ( xi , yi ) ∈Dl ` ( xi , yi ; θ ) + ∑ xj∈Du wj ` ( xj , y ? j ; θ ) , where ‖w‖0 = b . ( 3 ) A key question now is—what is the criterion for a good w ? Comparing the ideal loss function ( equation 1 ) and the sparse importance weighted loss ( equation 3 ) , the only difference is their unlabeled data loss functions . Therefore , a straight-forward informal criterion for a good importance weight w is that the two unlabeled data loss functions are close to each other , i.e. , L ? w ( θ ) : = 1 b ∑ xj∈Du wj ` ( xj , y ? j ; θ ) ≈ L ? ( θ ) : = 1 nu ∑ xj∈Du ` ( xj , y ? j ; θ ) . However , as the true labels are unknown , we can not compute L ? w and L ? . Luckily , we can have an estimator for the true labels , i.e. , estimation based on the labeled data p ( ỹj | xj , Dl ) or an approximation of it . Denote P ( xj ) as an estimated distribution , so ỹj ∼P ( xj ) , then the informal criterion for a good importance weight w then becomes L̃w ( θ ) : = 1 b ∑ xj∈Du wj ` ( xj , ỹj ; θ ) ≈ L̃ ( θ ) : = 1 nu ∑ xj∈Du ` ( xj , ỹj ; θ ) . ( 4 ) Thus , we are one step closer to evaluating the quality of a weighted selection . The next question is how to measure the difference between L̃ and L̃w . Difference Between Two Loss Functions Given the two loss functions L̃ , L̃w ∈ L ( Θ , R ) , where L ( Θ , R ) is equipped with the norm ‖ · ‖† , a straight-forward measurement of the difference between them is ‖L̃− L̃w‖† . However , observing that the optimization of a loss function is shift-invariant , the difference between two loss functions should also be shift-invariant . For example , for ∀L ∈ L ( Θ , R ) we have arg minθ∈Θ ( L ( θ ) + c ) = arg minθ∈Θ L ( θ ) for ∀c ∈ R , implying that L + c should be treated the same as L. Therefore , to account for the shift-invariance , we define q : L ( Θ , R ) → R+ as q ( L ) : = inf c∈R ‖L+ c‖† , ∀L ∈ L ( Θ , R ) . ( 5 ) Note that we abuse the notation a bit , i.e. , the c in L+ c should be the constant function that maps every θ ∈ Θ to c. The above definition has some nice properties that make it a good difference measurement of two loss functions , as proved in proposition C.1 in the appendix . In particular , q ( · ) satisfies the triangle inequality , and q ( L+ c ) = q ( L ) for any constant c. Therefore , we can formulate the generalized batch active learning problem as the following sparse approximation problem . Problem 1 ( Sparse Approximation-based Batch Active Learning ) . Given the shift-invariant seminorm q induced by the norm ‖ · ‖† ( equation 5 ) , and a label estimation distribution P , the generalized batch active learning problem ( equation 4 ) is formally defined as arg min w∈Rnu+ EP [ q ( L̃− L̃w ) ] s.t . ‖w‖0 = b , ( 6 ) where EP stands for the expectation over ỹj ∼P ( xj ) for ∀j ∈ [ nu ] . Problem 1 ( SABAL ) offers a general framework for batch active learning and can be applied with various settings , i.e. , both the norm ‖ · ‖† and the individual loss function ` can be chosen based on specific problems and applications . In the next section , we introduce two practical realizations of equation 6 for Bayesian and non-Bayesian active learning respectively . | This paper provides a framework which attempts to find a weighted subset of the unlabeled pool that matches the loss on all the points. This paper introduces a seminorm on the loss functions and proposes an optimization method to minimize this. Somewhat favorable results are shown for vision datasets. | SP:b9c6ff37d1ddb4fb9ea58b4b4daf9b58cb35c778 |
SABAL: Sparse Approximation-based Batch Active Learning | 1 INTRODUCTION . Over the last decade , deep neural networks have achieved promising results in various learning tasks . However , obtaining labels for a complex training dataset can be challenging in practice , as the data annotation is usually a time-consuming process that may require professional knowledge in certain applications such as in medicine ( Hoi et al. , 2006 ; Shen et al. , 2021 ) . Active Learning ( AL ) ( Settles , 2009 ) is commonly employed to mitigate the problem of scarce labeled data – enabling efficient model training with limited annotation costs . Given a partially labeled dataset , active learning ideally selects data samples that are the best for learning . Specifically , it aims to iteratively query the most helpful data to ask an oracle ( human annotator ) to annotate . The queried data samples can be added back to the labeled data pool , and the model is updated . This process is repeated until the model has achieved the desired performance . Intelligently identifying the most valuable data for annotation , also known as the query strategy , is the key problem in active learning . A common strategy is to take the prediction uncertainty or data representation as the metric for data query . This uncertainty-based approach ( Settles , 2009 ; Tong & Koller , 2001 ; Gal et al. , 2017 ; Beluch et al. , 2018 ) works by querying samples with high uncertainty , but often results in selecting correlated and redundant data samples in each batch ( Kirsch et al. , 2019 ; Ducoffe & Precioso , 2018 ) . Representation-based approaches ( Sener & Savarese , 2017 ; Yang & Loog , 2019 ) aim to select a subset of data that represents the whole unlabeled dataset , but tend to be computationally expensive and sensitive to batch sizes ( Ash et al. , 2019 ; Shui et al. , 2020 ) . More recently , several hybrid approaches that try to take both uncertainty and representation into consideration have shown advantages ( Ash et al. , 2019 ; Shui et al. , 2020 ; Sinha et al. , 2019 ) . This paper takes this hybrid view towards an active learning framework that balances the trade-off between uncertainty and representation . Besides hybrid approaches , deep Bayesian active learning has also gained attention due to recent advances in Bayesian deep learning . Several Bayesian approaches ( Gal et al. , 2017 ; Kirsch et al. , 2019 ) leverage model uncertainty measurements ( Gal & Ghahramani , 2015 ; 2016 ) determined by Bayesian neural networks , while other works ( Pinsler et al. , 2019 ) leverage progress in Bayesian Coreset problems ( Zhang et al. , 2021 ; Huggins et al. , 2016 ; Campbell & Broderick , 2019 ) . However , as most existing Bayesian approaches are explicitly designed for Bayesian neural networks , another goal of this paper is to propose a general method for both Bayesian and non-Bayesian models . For deep models , it is reasonable to query a large batch of data simultaneously to reduce model update frequency . The batch selection approach is known as batch active learning . Taking an optimization perspective , finding the best batch is NP-hard in general . Two common approaches for such combinatorial problems are the greedy and clustering approaches . Greedy algorithms select one data sample in sequence until the batch budget is exhausted ( Kirsch et al. , 2019 ; Bıyık et al. , 2019 ; Chen & Krause , 2013 ) . Here , specific conditions of the acquisition function such as submodularity ( Nemhauser et al. , 1978 ) are required to guarantee a good optimization result . Clustering algorithms regard cluster centers as their queried batch ( Sener & Savarese , 2017 ; Ash et al. , 2019 ) , but can be computationally expensive . To our knowledge , except for Pinsler et al . ( 2019 ) that focus on the Bayesian models , so far active learning has rarely been studied from a sparse approximation perspective . This is despite the ubiquity of sparse approximation in signal processing for tasks such as dictionary learning ( Aharon et al. , 2006 ) and compressed sensing ( Donoho , 2006 ) due to its performance for discovering a sparse representation while avoiding redundant information . Here we employ sparse approximation methods for batch active learning tasks . Our main contributions are summarized in the following . We propose a novel and flexible Sparse Approximation-based Batch Active Learning framework , i.e. , SABAL . We show how SABAL generalizes batch active learning as a sparse approximation problem and can adapt to different settings and models . The central intuition of SABAL is finding a weighted subset from the unlabeled data pool so that its corresponding training loss approximates the full-set loss function in a function space . We realize the SABAL framework as an efficient finite-dimensional optimization problem : First , we derive an upper bound to balance the trade-off between uncertainty and representation in a principled way . Second , we approximate the loss functions using finite-dimensional approximation . This results in a sparsity-constrained discontinuous optimization problem , for which we propose several efficient optimization algorithms . We demonstrate the advantages of SABAL in experiments for both Bayesian and non-Bayesian batch active learning settings . The structure of this manuscript is as follows . In Section 2 , we formulate the general framework of SABAL , and in Section 3 , we realize the framework into a finite-dimensional discontinuous sparse optimization problem . To solve the resulting optimization problem , we propose two optimization algorithms in Section 4 . Related work are discussed in Section 5 and Appendix Section B . Results of our experiments are presented in section 6 , and all proofs are provided in Appendix Section C . 2 BATCH ACTIVE LEARNING AS SPARSE APPROXIMATION . This section introduces the preliminaries and the general formulation of batch active learning as a sparse approximation problem . Preliminaries Vectors are denoted as bold lower case letters , e.g. , w ∈ Rn . The l0 pseudonorm of a vector w is denoted as ‖w‖0 , i.e. , the number of non-zero elements of w. We denote R+ : = [ 0 , +∞ ) . Distributions are denoted in script , e.g. , P , and a random variable is denoted by tilde , e.g. , ỹ ∼P . We denote sets in calligraphy or in uppercase Greek alphabet ( e.g. , D , Θ ) , and additionally we denote [ n ] : = { 1 , 2 , . . . , n } . In supervised learning , given a labeled training dataset Dl : = { ( xi , yi ) } nli=1 , where we denote their domain to be x ∈ X and y ∈ Y , the empirical goal is to minimize a loss function Ll ( θ ) : = ∑ ( xi , yi ) ∈Dl ` ( xi , yi ; θ ) formed by the training dataset , where θ ∈ Θ ⊂ Rm is the parameter of the model and ` is a loss function evaluated on individual pairs of data . Without loss of generality , we assume Θ ⊂ Rm is compact and ` ( x , y ; · ) : Θ→ R is in a normed space ( L ( Θ , R ) , ‖ · ‖† ) for all x , y . We further assume the constant function f : Θ→ 1 is included in L ( Θ , R ) . The “ † ” in the norm ‖ · ‖† : L ( Θ , R ) → R+ , representing its definition is a placeholder that will be discussed later . Batch Active Learning Besides the labeled dataset Dl , there is an unlabeled dataset Du : = { xj } nuj=1 where the labels are unknown but could be acquired at a high cost through human labeling . Combining two datasets , the ideal loss function to minimize w.r.t . θ is∑ ( xi , yi ) ∈Dl ` ( xi , yi ; θ ) + ∑ xj∈Du ` ( xj , y ? j ; θ ) , ( 1 ) where y ? j is the unknown true label corresponding to the data xj . Since acquiring true labels could be costly , we have to impose a budget b ( b < nu ) on the number of label acquisitions . Therefore , the batch active learning problem is to find a subset S ⊂ Du such that we can obtain a good model by optimizing the following loss function w.r.t . θ , ∑ ( xi , yi ) ∈Dl ` ( xi , yi ; θ ) + ∑ xj∈S ` ( xj , y ? j ; θ ) , where |S| = b . ( 2 ) Generalized Batch Active Learning We start our method by generalizing the classical formulation ( equation 2 ) by considering an importance weight for each unlabeled data . That is , we aim to find a sparse non-negative vector w ∈ Rnu+ such that we can obtain a good model by optimizing the following loss function w.r.t . θ : ∑ ( xi , yi ) ∈Dl ` ( xi , yi ; θ ) + ∑ xj∈Du wj ` ( xj , y ? j ; θ ) , where ‖w‖0 = b . ( 3 ) A key question now is—what is the criterion for a good w ? Comparing the ideal loss function ( equation 1 ) and the sparse importance weighted loss ( equation 3 ) , the only difference is their unlabeled data loss functions . Therefore , a straight-forward informal criterion for a good importance weight w is that the two unlabeled data loss functions are close to each other , i.e. , L ? w ( θ ) : = 1 b ∑ xj∈Du wj ` ( xj , y ? j ; θ ) ≈ L ? ( θ ) : = 1 nu ∑ xj∈Du ` ( xj , y ? j ; θ ) . However , as the true labels are unknown , we can not compute L ? w and L ? . Luckily , we can have an estimator for the true labels , i.e. , estimation based on the labeled data p ( ỹj | xj , Dl ) or an approximation of it . Denote P ( xj ) as an estimated distribution , so ỹj ∼P ( xj ) , then the informal criterion for a good importance weight w then becomes L̃w ( θ ) : = 1 b ∑ xj∈Du wj ` ( xj , ỹj ; θ ) ≈ L̃ ( θ ) : = 1 nu ∑ xj∈Du ` ( xj , ỹj ; θ ) . ( 4 ) Thus , we are one step closer to evaluating the quality of a weighted selection . The next question is how to measure the difference between L̃ and L̃w . Difference Between Two Loss Functions Given the two loss functions L̃ , L̃w ∈ L ( Θ , R ) , where L ( Θ , R ) is equipped with the norm ‖ · ‖† , a straight-forward measurement of the difference between them is ‖L̃− L̃w‖† . However , observing that the optimization of a loss function is shift-invariant , the difference between two loss functions should also be shift-invariant . For example , for ∀L ∈ L ( Θ , R ) we have arg minθ∈Θ ( L ( θ ) + c ) = arg minθ∈Θ L ( θ ) for ∀c ∈ R , implying that L + c should be treated the same as L. Therefore , to account for the shift-invariance , we define q : L ( Θ , R ) → R+ as q ( L ) : = inf c∈R ‖L+ c‖† , ∀L ∈ L ( Θ , R ) . ( 5 ) Note that we abuse the notation a bit , i.e. , the c in L+ c should be the constant function that maps every θ ∈ Θ to c. The above definition has some nice properties that make it a good difference measurement of two loss functions , as proved in proposition C.1 in the appendix . In particular , q ( · ) satisfies the triangle inequality , and q ( L+ c ) = q ( L ) for any constant c. Therefore , we can formulate the generalized batch active learning problem as the following sparse approximation problem . Problem 1 ( Sparse Approximation-based Batch Active Learning ) . Given the shift-invariant seminorm q induced by the norm ‖ · ‖† ( equation 5 ) , and a label estimation distribution P , the generalized batch active learning problem ( equation 4 ) is formally defined as arg min w∈Rnu+ EP [ q ( L̃− L̃w ) ] s.t . ‖w‖0 = b , ( 6 ) where EP stands for the expectation over ỹj ∼P ( xj ) for ∀j ∈ [ nu ] . Problem 1 ( SABAL ) offers a general framework for batch active learning and can be applied with various settings , i.e. , both the norm ‖ · ‖† and the individual loss function ` can be chosen based on specific problems and applications . In the next section , we introduce two practical realizations of equation 6 for Bayesian and non-Bayesian active learning respectively . | This paper formulate the batched active learning problem as a sparse approximation problem. The authors also provide algorithms to solve the sparse approximation problem. Empirical evaluations show the advantages of the proposed methods. | SP:b9c6ff37d1ddb4fb9ea58b4b4daf9b58cb35c778 |
Sample Selection with Uncertainty of Losses for Learning with Noisy Labels | 1 INTRODUCTION . Learning with noisy labels is one of the most challenging problems in weakly-supervised learning , since noisy labels are ubiquitous in the real world ( Mirzasoleiman et al. , 2020 ; Yu et al. , 2019 ; Nishi et al. , 2021 ; Arazo et al. , 2019 ; Yang et al. , 2021a ; Bai & Liu , 2021 ) . For instance , both crowdsourcing and web crawling yield large numbers of noisy labels everyday ( Han et al. , 2018 ) . Noisy labels can severely impair the performance of deep neural networks with strong memorization capacities ( Zhang et al. , 2017 ; Zhang & Sabuncu , 2018 ; Pleiss et al. , 2020 ; Lukasik et al. , 2020 ; Chen et al. , 2022 ) . To reduce the influence of noisy labels , a lot of approaches have been recently proposed ( Natarajan et al. , 2013 ; Liu & Tao , 2016 ; Ma et al. , 2018 ; Yang et al. , 2021b ; Zheng et al. , 2020 ; Xia et al. , 2019 ; 2020 ; Tanaka et al. , 2018 ; Malach & Shalev-Shwartz , 2017 ; Li et al. , 2020b ; Menon et al. , 2018 ; Thekumparampil et al. , 2018 ; Xu et al. , 2019 ; Kim et al. , 2019 ; Jiang et al. , 2020 ; Harutyunyan et al. , 2020 ) . They can be generally divided into two main categories . The first one is to estimate the noise transition matrix ( Patrini et al. , 2017 ; Shu et al. , 2020 ; Hendrycks et al. , 2018 ; Yang et al. , 2021c ; Wu et al. , 2022 ) , which denotes the probabilities that clean labels flip into noisy labels . However , the noise transition matrix is hard to be estimated accurately , especially when the number of classes is large ( Yu et al. , 2019 ) . The second approach is sample selection , which is our focus in this paper . This approach is based on selecting possibly clean examples from a mini-batch for training ( Han et al. , 2018 ; Wang et al. , 2018 ; Yao et al. , 2020a ; Wang et al. , 2019 ; Yu et al. , 2019 ; Lee et al. , 2019 ; Wang et al. , 2019 ; Yao et al. , 2022 ) . Intuitively , if we can exploit less noisy data for network parameter updates , the network will be more robust . A major question in sample selection is what criteria can be used to select possibly clean examples . At the present stage , the selection based on the small-loss criteria is the most common method , and has been verified to be effective in many circumstances ( Han et al. , 2018 ; Jiang et al. , 2018 ; Yu et al. , †Corresponding author 2019 ; Wei et al. , 2020 ; Yao et al. , 2020a ) . Specifically , since deep networks learn patterns first ( Arpit et al. , 2017 ) , they would first memorize training data of clean labels and then those of noisy labels with the assumption that clean labels are of the majority in a noisy class . Small-loss examples can thus be regarded as clean examples with high probability . Therefore , in each iteration , prior methods ( Han et al. , 2018 ; Wei et al. , 2020 ) select the small-loss examples based on the predictions of the current network for robust training . However , such a selection procedure is debatable , since it arguably does not consider uncertainty in selection . The uncertainty comes from two aspects . First , this procedure has uncertainty about small-loss examples . Specifically , the procedure uses limited time intervals and only exploits the losses provided by the current predictions . For this reason , the estimation for the noisy class posterior is unstable ( Yao et al. , 2020b ) , which causes the network predictions to be equally unstable . It thus takes huge risks to only use losses provided by the current predictions ( Figure 1 , left ) . Once wrong selection is made , the inferiority of accumulated errors will arise ( Yu et al. , 2019 ) . Second , this procedure has uncertainty about large-loss examples . To be specific , deep networks learn easy examples at the beginning of training , but ignore some clean examples with large losses . Nevertheless , such examples are always critical for generalization . For instance , when learning with imbalanced data , distinguishing the examples with non-dominant labels are more pivotal during training ( Menon et al. , 2020 ) . Deep networks often give large losses to such examples ( Figure 1 , right ) . Therefore , when learning under the realistic scenes , e.g. , learning with noisy imbalanced data , prior sample selection methods can not address such an issue well . To relieve the above issues , we study the uncertainty of losses in the sample selection procedure to combat noisy labels . To reduce the uncertainty of small-loss examples , we extend time intervals and utilize the mean of training losses at different training iterations . In consideration of the bad influence of mislabeled data on training losses , we build two robust mean estimators from the perspectives of soft truncation and hard truncation w.r.t . the truncation level , respectively . Soft truncation makes the mean estimation more robust by holistically changing the behavior of losses . Hard truncation makes the mean estimation more robust by locally removing outliers from losses . To reduce the uncertainty of large-loss examples , we encourage networks to pick the sample that has not been selected in a conservative way . Furthermore , to address the two issues simultaneously , we derive concentration inequalities ( Boucheron et al. , 2013 ) for robust mean estimation and further employ statistical confidence bounds ( Auer , 2002 ) to consider the number of times an example was selected during training . The study of uncertainty of losses in learning with noisy labels can be justified as follows . In statistical learning , it is known that uncertainty is related to the quality of data ( Vapnik , 2013 ) . Philosophically , we need variety decrease for selected data and variety search for unselected data , which share a common objective , i.e. , reduce the uncertainty of data to improve generalization ( Moore , 1990 ) . This is our original intention , since noisy labels could bring more uncertainty because of the low quality of noisy data . Nevertheless , due to the harm of noisy labels for generalization , we need to strike a good balance between variety decrease and search . Technically , our method is specially designed for handling noisy labels , which robustly uses network predictions and conservatively seeks less selected examples meanwhile to reduce the uncertainty of losses and then generalize well . Before delving into details , we clearly emphasize our contributions in two folds . First , we reveal prior sample selection criteria in learning with noisy labels have some potential weaknesses and discuss them in detail . The new selection criteria are then proposed with detailed theoretical analyses . Second , we experimentally validate the proposed method on both synthetic noisy balanced/imbalanced datasets and real-world noisy datasets , on which it achieves superior robustness compared with the stateof-the-art methods in learning with noisy labels . The rest of the paper is organized as follows . In Section 2 , we propose our robust learning paradigm step by step . Experimental results are discussed in Section 3 . The conclusion is given in Section 4 . 2 METHOD . In this section , we first introduce the problem setting and some background ( Section 2.1 ) . Then we discuss how to exploit training losses at different iterations ( Section 2.2 ) . Finally , we introduce the proposed method , which exploits training losses at different iterations more robustly and encourages networks to pick the sample that is less selected but could be correctly labeled ( Section 2.3 ) . 2.1 PRELIMINARIES . Let X and Y be the input and output spaces . Consider a k-class classification problem , i.e. , Y = [ k ] , where [ k ] = { 1 , . . . , k } . In learning with noisy labels , the training data are all sampled from a corrupted distribution on X × Y . We are given a sample with noisy labels , i.e. , S̃ = { ( x , ỹ ) } , where ỹ is the noisy label . The aim is to learn a robust classifier that could assign clean labels to test data by only exploiting a training sample with noisy labels . Let f : X → Rk be the classifier with learnable parameters w. At the i-th iteration during training , the parameters of the classifier f can be denoted as wi . Let ` : Rk × Y → R be a surrogate loss function for k-class classification . We exploit the softmax cross entropy loss in this paper . Given an arbitrary training example ( x , ỹ ) , at the i-th iteration , we can obtain a loss ` i , i.e. , ` i = ` ( f ( wi ; x ) , ỹ ) . Hence , until the t-th iteration , we can obtain a training loss set Lt about the example ( x , ỹ ) , i.e. , Lt = { ` 1 , . . . , ` t } . In this paper , we assume that the training losses in Lt conform to a Markov process , which is to represent a changing system under the assumption that future states only depend on the current state ( the Markov property ) . More specifically , at the i-th iteration , if we exploit an optimization algorithm for parameter updates ( e.g. , the stochastic gradient descent algorithm ( Bottou , 2012 ) ) and omit other dependencies ( e.g. , S̃ ) , we will have P ( wi|wi−1 , . . . , w0 ) = P ( wi|wi−1 ) , which means that the future state of the classifier f only depends on the current state . Furthermore , given a training example and the parameters of the classifier f , we can determine the loss of the training example as discussed . Therefore , the training losses in Lt will also conform to a Markov process . 2.2 EXTENDED TIME INTERVALS . As limited time interval can not address the instability issue of the estimation for the noisy class posterior well ( Pleiss et al. , 2020 ) , we extend time intervals and exploit the training losses at different training iterations for sample selection . One straightforward idea is to use the mean of training losses at different training iterations . Hence , the selection criterion could be µ̃ = 1 t t∑ i=1 ` i . ( 1 ) It is intuitive and reasonable to use such a selection criterion for sample selection , since the operation of averaging can mitigate the risks caused by the unstable estimation for the noisy class posterior , following better generalization . Nevertheless , such a method could arguably achieve suboptimal classification performance for learning with noisy labels . The main reason is that , due to the great harm of mislabeled data , part of training losses are with too large uncertainty and could be seen as outliers . Therefore , it could be biased to use the mean of training losses consisting of such outliers ( Diakonikolas et al. , 2020 ) , which further influences sample selection . More evaluations for our claims are provided in Section 3 . | This paper discusses the potential weaknesses in previous sample selection criteria in learning with noisy labels. And then propose a new selection criterion by incorporating the uncertainty of losses, together with theoretical justification. Experiments on both synthetic noisy balanced/imbalanced datasets and real-world noisy datasets validate the effectiveness of the proposed approach. | SP:8bcc40cf0cbc16b7c6d403becfe2b1325b2d00d4 |
Sample Selection with Uncertainty of Losses for Learning with Noisy Labels | 1 INTRODUCTION . Learning with noisy labels is one of the most challenging problems in weakly-supervised learning , since noisy labels are ubiquitous in the real world ( Mirzasoleiman et al. , 2020 ; Yu et al. , 2019 ; Nishi et al. , 2021 ; Arazo et al. , 2019 ; Yang et al. , 2021a ; Bai & Liu , 2021 ) . For instance , both crowdsourcing and web crawling yield large numbers of noisy labels everyday ( Han et al. , 2018 ) . Noisy labels can severely impair the performance of deep neural networks with strong memorization capacities ( Zhang et al. , 2017 ; Zhang & Sabuncu , 2018 ; Pleiss et al. , 2020 ; Lukasik et al. , 2020 ; Chen et al. , 2022 ) . To reduce the influence of noisy labels , a lot of approaches have been recently proposed ( Natarajan et al. , 2013 ; Liu & Tao , 2016 ; Ma et al. , 2018 ; Yang et al. , 2021b ; Zheng et al. , 2020 ; Xia et al. , 2019 ; 2020 ; Tanaka et al. , 2018 ; Malach & Shalev-Shwartz , 2017 ; Li et al. , 2020b ; Menon et al. , 2018 ; Thekumparampil et al. , 2018 ; Xu et al. , 2019 ; Kim et al. , 2019 ; Jiang et al. , 2020 ; Harutyunyan et al. , 2020 ) . They can be generally divided into two main categories . The first one is to estimate the noise transition matrix ( Patrini et al. , 2017 ; Shu et al. , 2020 ; Hendrycks et al. , 2018 ; Yang et al. , 2021c ; Wu et al. , 2022 ) , which denotes the probabilities that clean labels flip into noisy labels . However , the noise transition matrix is hard to be estimated accurately , especially when the number of classes is large ( Yu et al. , 2019 ) . The second approach is sample selection , which is our focus in this paper . This approach is based on selecting possibly clean examples from a mini-batch for training ( Han et al. , 2018 ; Wang et al. , 2018 ; Yao et al. , 2020a ; Wang et al. , 2019 ; Yu et al. , 2019 ; Lee et al. , 2019 ; Wang et al. , 2019 ; Yao et al. , 2022 ) . Intuitively , if we can exploit less noisy data for network parameter updates , the network will be more robust . A major question in sample selection is what criteria can be used to select possibly clean examples . At the present stage , the selection based on the small-loss criteria is the most common method , and has been verified to be effective in many circumstances ( Han et al. , 2018 ; Jiang et al. , 2018 ; Yu et al. , †Corresponding author 2019 ; Wei et al. , 2020 ; Yao et al. , 2020a ) . Specifically , since deep networks learn patterns first ( Arpit et al. , 2017 ) , they would first memorize training data of clean labels and then those of noisy labels with the assumption that clean labels are of the majority in a noisy class . Small-loss examples can thus be regarded as clean examples with high probability . Therefore , in each iteration , prior methods ( Han et al. , 2018 ; Wei et al. , 2020 ) select the small-loss examples based on the predictions of the current network for robust training . However , such a selection procedure is debatable , since it arguably does not consider uncertainty in selection . The uncertainty comes from two aspects . First , this procedure has uncertainty about small-loss examples . Specifically , the procedure uses limited time intervals and only exploits the losses provided by the current predictions . For this reason , the estimation for the noisy class posterior is unstable ( Yao et al. , 2020b ) , which causes the network predictions to be equally unstable . It thus takes huge risks to only use losses provided by the current predictions ( Figure 1 , left ) . Once wrong selection is made , the inferiority of accumulated errors will arise ( Yu et al. , 2019 ) . Second , this procedure has uncertainty about large-loss examples . To be specific , deep networks learn easy examples at the beginning of training , but ignore some clean examples with large losses . Nevertheless , such examples are always critical for generalization . For instance , when learning with imbalanced data , distinguishing the examples with non-dominant labels are more pivotal during training ( Menon et al. , 2020 ) . Deep networks often give large losses to such examples ( Figure 1 , right ) . Therefore , when learning under the realistic scenes , e.g. , learning with noisy imbalanced data , prior sample selection methods can not address such an issue well . To relieve the above issues , we study the uncertainty of losses in the sample selection procedure to combat noisy labels . To reduce the uncertainty of small-loss examples , we extend time intervals and utilize the mean of training losses at different training iterations . In consideration of the bad influence of mislabeled data on training losses , we build two robust mean estimators from the perspectives of soft truncation and hard truncation w.r.t . the truncation level , respectively . Soft truncation makes the mean estimation more robust by holistically changing the behavior of losses . Hard truncation makes the mean estimation more robust by locally removing outliers from losses . To reduce the uncertainty of large-loss examples , we encourage networks to pick the sample that has not been selected in a conservative way . Furthermore , to address the two issues simultaneously , we derive concentration inequalities ( Boucheron et al. , 2013 ) for robust mean estimation and further employ statistical confidence bounds ( Auer , 2002 ) to consider the number of times an example was selected during training . The study of uncertainty of losses in learning with noisy labels can be justified as follows . In statistical learning , it is known that uncertainty is related to the quality of data ( Vapnik , 2013 ) . Philosophically , we need variety decrease for selected data and variety search for unselected data , which share a common objective , i.e. , reduce the uncertainty of data to improve generalization ( Moore , 1990 ) . This is our original intention , since noisy labels could bring more uncertainty because of the low quality of noisy data . Nevertheless , due to the harm of noisy labels for generalization , we need to strike a good balance between variety decrease and search . Technically , our method is specially designed for handling noisy labels , which robustly uses network predictions and conservatively seeks less selected examples meanwhile to reduce the uncertainty of losses and then generalize well . Before delving into details , we clearly emphasize our contributions in two folds . First , we reveal prior sample selection criteria in learning with noisy labels have some potential weaknesses and discuss them in detail . The new selection criteria are then proposed with detailed theoretical analyses . Second , we experimentally validate the proposed method on both synthetic noisy balanced/imbalanced datasets and real-world noisy datasets , on which it achieves superior robustness compared with the stateof-the-art methods in learning with noisy labels . The rest of the paper is organized as follows . In Section 2 , we propose our robust learning paradigm step by step . Experimental results are discussed in Section 3 . The conclusion is given in Section 4 . 2 METHOD . In this section , we first introduce the problem setting and some background ( Section 2.1 ) . Then we discuss how to exploit training losses at different iterations ( Section 2.2 ) . Finally , we introduce the proposed method , which exploits training losses at different iterations more robustly and encourages networks to pick the sample that is less selected but could be correctly labeled ( Section 2.3 ) . 2.1 PRELIMINARIES . Let X and Y be the input and output spaces . Consider a k-class classification problem , i.e. , Y = [ k ] , where [ k ] = { 1 , . . . , k } . In learning with noisy labels , the training data are all sampled from a corrupted distribution on X × Y . We are given a sample with noisy labels , i.e. , S̃ = { ( x , ỹ ) } , where ỹ is the noisy label . The aim is to learn a robust classifier that could assign clean labels to test data by only exploiting a training sample with noisy labels . Let f : X → Rk be the classifier with learnable parameters w. At the i-th iteration during training , the parameters of the classifier f can be denoted as wi . Let ` : Rk × Y → R be a surrogate loss function for k-class classification . We exploit the softmax cross entropy loss in this paper . Given an arbitrary training example ( x , ỹ ) , at the i-th iteration , we can obtain a loss ` i , i.e. , ` i = ` ( f ( wi ; x ) , ỹ ) . Hence , until the t-th iteration , we can obtain a training loss set Lt about the example ( x , ỹ ) , i.e. , Lt = { ` 1 , . . . , ` t } . In this paper , we assume that the training losses in Lt conform to a Markov process , which is to represent a changing system under the assumption that future states only depend on the current state ( the Markov property ) . More specifically , at the i-th iteration , if we exploit an optimization algorithm for parameter updates ( e.g. , the stochastic gradient descent algorithm ( Bottou , 2012 ) ) and omit other dependencies ( e.g. , S̃ ) , we will have P ( wi|wi−1 , . . . , w0 ) = P ( wi|wi−1 ) , which means that the future state of the classifier f only depends on the current state . Furthermore , given a training example and the parameters of the classifier f , we can determine the loss of the training example as discussed . Therefore , the training losses in Lt will also conform to a Markov process . 2.2 EXTENDED TIME INTERVALS . As limited time interval can not address the instability issue of the estimation for the noisy class posterior well ( Pleiss et al. , 2020 ) , we extend time intervals and exploit the training losses at different training iterations for sample selection . One straightforward idea is to use the mean of training losses at different training iterations . Hence , the selection criterion could be µ̃ = 1 t t∑ i=1 ` i . ( 1 ) It is intuitive and reasonable to use such a selection criterion for sample selection , since the operation of averaging can mitigate the risks caused by the unstable estimation for the noisy class posterior , following better generalization . Nevertheless , such a method could arguably achieve suboptimal classification performance for learning with noisy labels . The main reason is that , due to the great harm of mislabeled data , part of training losses are with too large uncertainty and could be seen as outliers . Therefore , it could be biased to use the mean of training losses consisting of such outliers ( Diakonikolas et al. , 2020 ) , which further influences sample selection . More evaluations for our claims are provided in Section 3 . | This paper proposes a novel algorithm to improve the sample selection in the case of noisy labels training by incorporating the uncertainty of losses. To select samples, the authors propose to use the lower bounds of the confidence intervals derived from concentration inequalities instead of using point estimation of losses. The authors introduce the Soft truncation estimator and the Hard truncation estimator and propose lower bounds for both estimators. The authors introduce an algorithm, the CNLCU Algorithm based on using either the lower bounds calculated for the Soft truncation estimator or the Hard truncation estimator. The authors validate empirically their results on four benchmark datasets (MNIST, F-MNIST, CIFAR-10, CIFAR-100) and use a diverse set of possible noise functions. The method proposed almost always outperforms all other comparable approaches. | SP:8bcc40cf0cbc16b7c6d403becfe2b1325b2d00d4 |
Sample Selection with Uncertainty of Losses for Learning with Noisy Labels | 1 INTRODUCTION . Learning with noisy labels is one of the most challenging problems in weakly-supervised learning , since noisy labels are ubiquitous in the real world ( Mirzasoleiman et al. , 2020 ; Yu et al. , 2019 ; Nishi et al. , 2021 ; Arazo et al. , 2019 ; Yang et al. , 2021a ; Bai & Liu , 2021 ) . For instance , both crowdsourcing and web crawling yield large numbers of noisy labels everyday ( Han et al. , 2018 ) . Noisy labels can severely impair the performance of deep neural networks with strong memorization capacities ( Zhang et al. , 2017 ; Zhang & Sabuncu , 2018 ; Pleiss et al. , 2020 ; Lukasik et al. , 2020 ; Chen et al. , 2022 ) . To reduce the influence of noisy labels , a lot of approaches have been recently proposed ( Natarajan et al. , 2013 ; Liu & Tao , 2016 ; Ma et al. , 2018 ; Yang et al. , 2021b ; Zheng et al. , 2020 ; Xia et al. , 2019 ; 2020 ; Tanaka et al. , 2018 ; Malach & Shalev-Shwartz , 2017 ; Li et al. , 2020b ; Menon et al. , 2018 ; Thekumparampil et al. , 2018 ; Xu et al. , 2019 ; Kim et al. , 2019 ; Jiang et al. , 2020 ; Harutyunyan et al. , 2020 ) . They can be generally divided into two main categories . The first one is to estimate the noise transition matrix ( Patrini et al. , 2017 ; Shu et al. , 2020 ; Hendrycks et al. , 2018 ; Yang et al. , 2021c ; Wu et al. , 2022 ) , which denotes the probabilities that clean labels flip into noisy labels . However , the noise transition matrix is hard to be estimated accurately , especially when the number of classes is large ( Yu et al. , 2019 ) . The second approach is sample selection , which is our focus in this paper . This approach is based on selecting possibly clean examples from a mini-batch for training ( Han et al. , 2018 ; Wang et al. , 2018 ; Yao et al. , 2020a ; Wang et al. , 2019 ; Yu et al. , 2019 ; Lee et al. , 2019 ; Wang et al. , 2019 ; Yao et al. , 2022 ) . Intuitively , if we can exploit less noisy data for network parameter updates , the network will be more robust . A major question in sample selection is what criteria can be used to select possibly clean examples . At the present stage , the selection based on the small-loss criteria is the most common method , and has been verified to be effective in many circumstances ( Han et al. , 2018 ; Jiang et al. , 2018 ; Yu et al. , †Corresponding author 2019 ; Wei et al. , 2020 ; Yao et al. , 2020a ) . Specifically , since deep networks learn patterns first ( Arpit et al. , 2017 ) , they would first memorize training data of clean labels and then those of noisy labels with the assumption that clean labels are of the majority in a noisy class . Small-loss examples can thus be regarded as clean examples with high probability . Therefore , in each iteration , prior methods ( Han et al. , 2018 ; Wei et al. , 2020 ) select the small-loss examples based on the predictions of the current network for robust training . However , such a selection procedure is debatable , since it arguably does not consider uncertainty in selection . The uncertainty comes from two aspects . First , this procedure has uncertainty about small-loss examples . Specifically , the procedure uses limited time intervals and only exploits the losses provided by the current predictions . For this reason , the estimation for the noisy class posterior is unstable ( Yao et al. , 2020b ) , which causes the network predictions to be equally unstable . It thus takes huge risks to only use losses provided by the current predictions ( Figure 1 , left ) . Once wrong selection is made , the inferiority of accumulated errors will arise ( Yu et al. , 2019 ) . Second , this procedure has uncertainty about large-loss examples . To be specific , deep networks learn easy examples at the beginning of training , but ignore some clean examples with large losses . Nevertheless , such examples are always critical for generalization . For instance , when learning with imbalanced data , distinguishing the examples with non-dominant labels are more pivotal during training ( Menon et al. , 2020 ) . Deep networks often give large losses to such examples ( Figure 1 , right ) . Therefore , when learning under the realistic scenes , e.g. , learning with noisy imbalanced data , prior sample selection methods can not address such an issue well . To relieve the above issues , we study the uncertainty of losses in the sample selection procedure to combat noisy labels . To reduce the uncertainty of small-loss examples , we extend time intervals and utilize the mean of training losses at different training iterations . In consideration of the bad influence of mislabeled data on training losses , we build two robust mean estimators from the perspectives of soft truncation and hard truncation w.r.t . the truncation level , respectively . Soft truncation makes the mean estimation more robust by holistically changing the behavior of losses . Hard truncation makes the mean estimation more robust by locally removing outliers from losses . To reduce the uncertainty of large-loss examples , we encourage networks to pick the sample that has not been selected in a conservative way . Furthermore , to address the two issues simultaneously , we derive concentration inequalities ( Boucheron et al. , 2013 ) for robust mean estimation and further employ statistical confidence bounds ( Auer , 2002 ) to consider the number of times an example was selected during training . The study of uncertainty of losses in learning with noisy labels can be justified as follows . In statistical learning , it is known that uncertainty is related to the quality of data ( Vapnik , 2013 ) . Philosophically , we need variety decrease for selected data and variety search for unselected data , which share a common objective , i.e. , reduce the uncertainty of data to improve generalization ( Moore , 1990 ) . This is our original intention , since noisy labels could bring more uncertainty because of the low quality of noisy data . Nevertheless , due to the harm of noisy labels for generalization , we need to strike a good balance between variety decrease and search . Technically , our method is specially designed for handling noisy labels , which robustly uses network predictions and conservatively seeks less selected examples meanwhile to reduce the uncertainty of losses and then generalize well . Before delving into details , we clearly emphasize our contributions in two folds . First , we reveal prior sample selection criteria in learning with noisy labels have some potential weaknesses and discuss them in detail . The new selection criteria are then proposed with detailed theoretical analyses . Second , we experimentally validate the proposed method on both synthetic noisy balanced/imbalanced datasets and real-world noisy datasets , on which it achieves superior robustness compared with the stateof-the-art methods in learning with noisy labels . The rest of the paper is organized as follows . In Section 2 , we propose our robust learning paradigm step by step . Experimental results are discussed in Section 3 . The conclusion is given in Section 4 . 2 METHOD . In this section , we first introduce the problem setting and some background ( Section 2.1 ) . Then we discuss how to exploit training losses at different iterations ( Section 2.2 ) . Finally , we introduce the proposed method , which exploits training losses at different iterations more robustly and encourages networks to pick the sample that is less selected but could be correctly labeled ( Section 2.3 ) . 2.1 PRELIMINARIES . Let X and Y be the input and output spaces . Consider a k-class classification problem , i.e. , Y = [ k ] , where [ k ] = { 1 , . . . , k } . In learning with noisy labels , the training data are all sampled from a corrupted distribution on X × Y . We are given a sample with noisy labels , i.e. , S̃ = { ( x , ỹ ) } , where ỹ is the noisy label . The aim is to learn a robust classifier that could assign clean labels to test data by only exploiting a training sample with noisy labels . Let f : X → Rk be the classifier with learnable parameters w. At the i-th iteration during training , the parameters of the classifier f can be denoted as wi . Let ` : Rk × Y → R be a surrogate loss function for k-class classification . We exploit the softmax cross entropy loss in this paper . Given an arbitrary training example ( x , ỹ ) , at the i-th iteration , we can obtain a loss ` i , i.e. , ` i = ` ( f ( wi ; x ) , ỹ ) . Hence , until the t-th iteration , we can obtain a training loss set Lt about the example ( x , ỹ ) , i.e. , Lt = { ` 1 , . . . , ` t } . In this paper , we assume that the training losses in Lt conform to a Markov process , which is to represent a changing system under the assumption that future states only depend on the current state ( the Markov property ) . More specifically , at the i-th iteration , if we exploit an optimization algorithm for parameter updates ( e.g. , the stochastic gradient descent algorithm ( Bottou , 2012 ) ) and omit other dependencies ( e.g. , S̃ ) , we will have P ( wi|wi−1 , . . . , w0 ) = P ( wi|wi−1 ) , which means that the future state of the classifier f only depends on the current state . Furthermore , given a training example and the parameters of the classifier f , we can determine the loss of the training example as discussed . Therefore , the training losses in Lt will also conform to a Markov process . 2.2 EXTENDED TIME INTERVALS . As limited time interval can not address the instability issue of the estimation for the noisy class posterior well ( Pleiss et al. , 2020 ) , we extend time intervals and exploit the training losses at different training iterations for sample selection . One straightforward idea is to use the mean of training losses at different training iterations . Hence , the selection criterion could be µ̃ = 1 t t∑ i=1 ` i . ( 1 ) It is intuitive and reasonable to use such a selection criterion for sample selection , since the operation of averaging can mitigate the risks caused by the unstable estimation for the noisy class posterior , following better generalization . Nevertheless , such a method could arguably achieve suboptimal classification performance for learning with noisy labels . The main reason is that , due to the great harm of mislabeled data , part of training losses are with too large uncertainty and could be seen as outliers . Therefore , it could be biased to use the mean of training losses consisting of such outliers ( Diakonikolas et al. , 2020 ) , which further influences sample selection . More evaluations for our claims are provided in Section 3 . | The paper proposes a novel sample selection method for learning with noisy labels (LNL). Based on the typical "small-loss" assumption, the motivation is to consider uncertainty about large-loss samples in order to distinguish the two confounding cases: truly mislabeled samples, or clean yet underrepresented samples that are less frequently selected or learned by the model so far. The proposed method explores robust mean estimation to summarize the per-sample loss trajectory, through soft truncation and hard truncation. Concentration inequalities are used to obtain the final selection criteria to perform conservative search. Results are overall promising, in particular showing very good results dealing with label noise + extreme class imbalance (Figure 2). | SP:8bcc40cf0cbc16b7c6d403becfe2b1325b2d00d4 |
How BPE Affects Memorization in Transformers | Training data memorization in NLP can both be beneficial ( e.g. , closed-book QA ) and undesirable ( personal data extraction ) . In any case , successful model training requires a non-trivial amount of memorization to store word spellings , various linguistic idiosyncrasies and common knowledge . However , little is known about what affects the memorization behavior of NLP models , as the field tends to focus on the equally important question of generalization . In this work , we demonstrate that the size of the subword vocabulary learned by Byte-Pair Encoding ( BPE ) greatly affects both ability and tendency of standard Transformer models to memorize training data , even when we control for the number of learned parameters . We find that with a large subword vocabulary size , Transformer models fit random mappings more easily and are more vulnerable to membership inference attacks . Similarly , given a prompt , Transformer-based language models with large subword vocabularies reproduce the training data more often . We conjecture this effect is caused by reduction in the sequences ’ length that happens as the BPE vocabulary grows . Our findings can allow a more informed choice of hyper-parameters , that is better tailored for a particular use-case . 1 INTRODUCTION . The Transformer architecture ( Vaswani et al. , 2017 ) became the backbone of the state-of-the-art models in a variety of tasks ( Liu et al. , 2019 ; Raffel et al. , 2019 ; Adiwardana et al. , 2020 ; Brown et al. , 2020 ) . This spurred a significant interest in better understanding inner workings of these models ( Vig and Belinkov , 2019 ; Clark et al. , 2019 ; Kharitonov and Chaabouni , 2020 ; Hahn , 2020 ; Movva and Zhao , 2020 ; Chaabouni et al. , 2021 ; Merrill et al. , 2021 ; Sinha et al. , 2021 ) . Most of these works have focussed specifically on how models generalize and capture structure across samples that are similar . For instance , Vig and Belinkov ( 2019 ) focussed on how attention align with specific syntactic dependency relations , Hupkes et al . ( 2020 ) considered if Transformers generalize compositionally and Kharitonov and Chaabouni ( 2020 ) studied how different models generalize from very few data . In contrast to these studies , we focus on factors that control the training data memorization behavior of Transformers , which we believe to be important for several reasons . First , large Transformer models are increasingly often used as a storage , for instance , as a generalpurpose knowledge base or as a closed-book question-answering system ( Petroni et al. , 2019 ; Roberts et al. , 2020 ; Lewis et al. , 2020 ) . Clearly , the ability to memorize factual knowledge from the training data is crucial for such applications . There are even Transformers models that are explicitly endowed with an external training data memorization mechanism ( Khandelwal et al. , 2020 ; 2021 ; He et al. , 2021 ) , demonstrating that further boosting their memorization abilities is beneficial . Second , in contrast , the same ability to memorize can become undesirable and lead to a leakage of personal data from trained models ( Carlini et al. , 2020 ; Thakkar et al. , 2021 ) . A better understanding of the phenomenon is thus instrumental both to enable better memorization when it is needed and to avoid it when not . Third , while generalization and memorization are often thought of as competing modes of fitting data , training effective models in real tasks requires a non-trivial combination of the two . For instance , successful language models need to generalize to be able to deal with never-seen-before sentences , but they also need to memorize the spelling of words , the non-compositional meaning of idioms , idiosyncrasies of languages , common knowledge , etc ( see , e.g . Dankers et al. , 2021 ) .1 Despite this apparent importance , there is very little research into memorization in Transformers and in NLP models in general , and we have only superficial understanding of what factors affect this behavior . Intuitively , the number of parameters , data augmentation , and regularization are likely to affect how successful models are in memorization ( Zhang et al. , 2016 ; Sablayrolles et al. , 2018 ) . In this work , we primarily focus on the influence of a less obvious yet important factor : we study how the selection of modelling units affects memorization . Typically , the same data can be represented on various levels : raw bytes and their groups , individual characters , subword units , and entire words . A very common approach is to learn subword-level vocabulary with Byte-Pair Encoding ( BPE ) ( Sennrich et al. , 2015 ) or similar methods ( e.g. , Devlin et al. , 2018 ; Kudo and Richardson , 2018 ; Provilkov et al. , 2019 ) . In spite of ubiquitous use of these methods , to the best of our knowledge , there is no clear understanding of how the number of subwords or BPE operations should be chosen and how this affect behavior of a model . We expect that BPE-like segmentation might play a crucial role in memorization , as it controls the trade-off between the number of primitives a model will have to operate with and the lengths of sequences it must represent . In this work , to characterize a model ’ s behavior , we measure three “ facets ” of training data memorization . First , as a proxy for the memorization capacity of a model , we use its ability to fit random , non-systematic mappings . Next , we study the preference for memorization when generalization is possible . For that , we study how easy it is to accurately tell if a particular example was used in the model ’ s training data via a membership inference attack ( Shokri et al. , 2017 ) . Finally , we examine how easy it is to recover training data from a trained language model . We experiment with three Transformer architectures : causal & masked language models , and encoder-based classifiers . Our main experimental finding is that , across all architectures and tasks , the choice of modeling units strongly affects the memorization behavior of the models , with large-cardinality BPE vocabularies greatly facilitating memorization . This observation holds even when we control for the number of trainable parameters . After establishing this fact , we look deeper into the causes of the phenomenon we observe . We examine three candidate causes which are principal ( side- ) effects of applying BPE : ( i ) removing redundancy in the data ( due to compression ) , ( ii ) increase in the number of the unique units used to represent the data , or ( iii ) reducing the length of the training sequences . By finding a similar effect with incompressible randomly generated data we can rule out the first possibility . Next , we artificially double the vocabulary size by introducing “ synonym ” tokens and observe that the vocabulary growth , in isolation , leads to a different memorization pattern . Thus , by exclusion , we conjecture that reducing utterance length is , at least , a very important factor of memorization.2 . 2 STUDYING MEMORIZATION – THE TASKS . To quantify the memorization capabilities and preferences of NLP models , we use three different setups , with which we aim to cover different facets of what one can call training data memorization . 2.1 LEARNING MAPPINGS WITH RANDOM LABELS . Firstly , we consider a task of learning non-systematic mappings , where labels are independent from inputs ( Zhang et al. , 2016 ) . To achieve accuracy above chance , the model has to “ store ” the training example in some way , thus we assume that a higher training accuracy implies increased training data memorization ability . To experiment with realistic natural input data , we consider the Stanford Natural Language Inference dataset ( SNLI , Bowman et al. , 2015 ) . In this dataset , each example is a pair of two sentences , one representing a premise ( “ A boy is jumping on skateboard in the middle of a red bridge. ” ) and the other representing a hypothesis ( “ The boy does a skateboarding trick. ” ) . Each example is assigned a 1An interesting example is the language model of Lakhotia et al . ( 2021 ) , which is trained on sub-phonemic acoustic units without word boundaries , but confidently processes a large vocabulary of English words . 2Another potential cause that we consider is the changes in the relative frequencies of tokens that BPE brings along . In Appendix D we investigate and rule out this hypothesis . label that denotes if the hypothesis entails the premise , contradicts it , or neither contradict nor entails ( neutral ) . We represent examples in a concatenated form with a separator token ( : : ) between a premise and a hypothesis ( “ A boy is jumping on skateboard in the middle of a red bridge . : : The boy does a skateboarding trick. ” ) . For uniformity with other experiments , we transform the dataset into a binary classification task by filtering out all examples with neutral labels.3 After this filtering , 367,388 examples remain . We replace original labels with randomly sampled ones ( -1 / +1 , equiprobably ) , and we measure memorization by measuring the ( training ) accuracy of the models on this data . 2.2 MEMBERSHIP INFERENCE . While the task of memorizing random labels can tell us how much a model can remember , it doesn ’ t allow us to test how much or what a model memorizes when it is trained on tasks which also admit ( or require ) generalization . As this is typically the case with natural data , we thus need a different strategy to assess memorization in more realistic scenarios . To evaluate memorization in such cases , we resort to measuring models ’ vulnerability to membership inference attacks ( Shokri et al. , 2017 ) . Indeed , if it is “ easy ” to accurately tell if a particular example was used for training , we assume it is actually “ stored ” in the weights of the model in some form , rather than being inferred from a more general rule or pattern ( which would lead to high scores also for examples that were not in the training data , but that are likely given that data ) . More formally , suppose we have a model fθ that was trained on a subset D′ of a large set of examples D , ( D′ ⊂ D ) withD′ obtained by sampling examples independently fromD with some probability λ . The goal of membership inference is to figure out , given fθ , whether a particular example ( xi , yi ) ∈ D was included in the training data D′ . We implement a simple membership inference attack protocol by Yeom et al . ( 2018 ) . Given a model fθ parameterized by θ , we calculate its loss on a data point l ( fθ ( xi ) , yi ) and compare to a threshold τ : if it is below the threshold , the data point belongs to the training data . By controlling τ we can control the trade-off between precision and recall of the attack . To avoid the dependency on this parameter and to represent the entire space of possible trade-offs , we use the AUC metric . After training a model , we measure the AUC of the above rule that separates training and hold-out examples . In this set of experiments , we again use the SNLI dataset . However , in this experiment we use the true labels of the dataset , rather than using the random labels of the previous setup , allowing us to consider both generalization and memorization . To make the prior probability of an example belonging to the training dataset equal to 12 , at training time we use only a half of the original ’ s dataset training data ( 367,388 examples remaining after filtering ) , with the second half playing the role of the hold-out . | This paper studies the memorization properties of an NLP models conditioned on how large is the vocabulary size. They concentrate on widely used BPE algorithm in order to split original data into subword units. Further they construct a test-bed consisting on several tasks where each task is related with a specific memorization aspect connected to the model such as capacity or preference which authors introduced themself. Experiments empirically validate the change of memorization properties as the vocabulary size is changing where it exhibits better memorization with larger vocab size. Further authors make multiple hypotheses of what might be the underlying explanation hidden behind the improved memorization. After checking these out they conjecture that the reduced sequence length is likely the major contributor explaining the underlying observation. | SP:842ff110a244839688e360ec6f67f2e56d609d4a |
How BPE Affects Memorization in Transformers | Training data memorization in NLP can both be beneficial ( e.g. , closed-book QA ) and undesirable ( personal data extraction ) . In any case , successful model training requires a non-trivial amount of memorization to store word spellings , various linguistic idiosyncrasies and common knowledge . However , little is known about what affects the memorization behavior of NLP models , as the field tends to focus on the equally important question of generalization . In this work , we demonstrate that the size of the subword vocabulary learned by Byte-Pair Encoding ( BPE ) greatly affects both ability and tendency of standard Transformer models to memorize training data , even when we control for the number of learned parameters . We find that with a large subword vocabulary size , Transformer models fit random mappings more easily and are more vulnerable to membership inference attacks . Similarly , given a prompt , Transformer-based language models with large subword vocabularies reproduce the training data more often . We conjecture this effect is caused by reduction in the sequences ’ length that happens as the BPE vocabulary grows . Our findings can allow a more informed choice of hyper-parameters , that is better tailored for a particular use-case . 1 INTRODUCTION . The Transformer architecture ( Vaswani et al. , 2017 ) became the backbone of the state-of-the-art models in a variety of tasks ( Liu et al. , 2019 ; Raffel et al. , 2019 ; Adiwardana et al. , 2020 ; Brown et al. , 2020 ) . This spurred a significant interest in better understanding inner workings of these models ( Vig and Belinkov , 2019 ; Clark et al. , 2019 ; Kharitonov and Chaabouni , 2020 ; Hahn , 2020 ; Movva and Zhao , 2020 ; Chaabouni et al. , 2021 ; Merrill et al. , 2021 ; Sinha et al. , 2021 ) . Most of these works have focussed specifically on how models generalize and capture structure across samples that are similar . For instance , Vig and Belinkov ( 2019 ) focussed on how attention align with specific syntactic dependency relations , Hupkes et al . ( 2020 ) considered if Transformers generalize compositionally and Kharitonov and Chaabouni ( 2020 ) studied how different models generalize from very few data . In contrast to these studies , we focus on factors that control the training data memorization behavior of Transformers , which we believe to be important for several reasons . First , large Transformer models are increasingly often used as a storage , for instance , as a generalpurpose knowledge base or as a closed-book question-answering system ( Petroni et al. , 2019 ; Roberts et al. , 2020 ; Lewis et al. , 2020 ) . Clearly , the ability to memorize factual knowledge from the training data is crucial for such applications . There are even Transformers models that are explicitly endowed with an external training data memorization mechanism ( Khandelwal et al. , 2020 ; 2021 ; He et al. , 2021 ) , demonstrating that further boosting their memorization abilities is beneficial . Second , in contrast , the same ability to memorize can become undesirable and lead to a leakage of personal data from trained models ( Carlini et al. , 2020 ; Thakkar et al. , 2021 ) . A better understanding of the phenomenon is thus instrumental both to enable better memorization when it is needed and to avoid it when not . Third , while generalization and memorization are often thought of as competing modes of fitting data , training effective models in real tasks requires a non-trivial combination of the two . For instance , successful language models need to generalize to be able to deal with never-seen-before sentences , but they also need to memorize the spelling of words , the non-compositional meaning of idioms , idiosyncrasies of languages , common knowledge , etc ( see , e.g . Dankers et al. , 2021 ) .1 Despite this apparent importance , there is very little research into memorization in Transformers and in NLP models in general , and we have only superficial understanding of what factors affect this behavior . Intuitively , the number of parameters , data augmentation , and regularization are likely to affect how successful models are in memorization ( Zhang et al. , 2016 ; Sablayrolles et al. , 2018 ) . In this work , we primarily focus on the influence of a less obvious yet important factor : we study how the selection of modelling units affects memorization . Typically , the same data can be represented on various levels : raw bytes and their groups , individual characters , subword units , and entire words . A very common approach is to learn subword-level vocabulary with Byte-Pair Encoding ( BPE ) ( Sennrich et al. , 2015 ) or similar methods ( e.g. , Devlin et al. , 2018 ; Kudo and Richardson , 2018 ; Provilkov et al. , 2019 ) . In spite of ubiquitous use of these methods , to the best of our knowledge , there is no clear understanding of how the number of subwords or BPE operations should be chosen and how this affect behavior of a model . We expect that BPE-like segmentation might play a crucial role in memorization , as it controls the trade-off between the number of primitives a model will have to operate with and the lengths of sequences it must represent . In this work , to characterize a model ’ s behavior , we measure three “ facets ” of training data memorization . First , as a proxy for the memorization capacity of a model , we use its ability to fit random , non-systematic mappings . Next , we study the preference for memorization when generalization is possible . For that , we study how easy it is to accurately tell if a particular example was used in the model ’ s training data via a membership inference attack ( Shokri et al. , 2017 ) . Finally , we examine how easy it is to recover training data from a trained language model . We experiment with three Transformer architectures : causal & masked language models , and encoder-based classifiers . Our main experimental finding is that , across all architectures and tasks , the choice of modeling units strongly affects the memorization behavior of the models , with large-cardinality BPE vocabularies greatly facilitating memorization . This observation holds even when we control for the number of trainable parameters . After establishing this fact , we look deeper into the causes of the phenomenon we observe . We examine three candidate causes which are principal ( side- ) effects of applying BPE : ( i ) removing redundancy in the data ( due to compression ) , ( ii ) increase in the number of the unique units used to represent the data , or ( iii ) reducing the length of the training sequences . By finding a similar effect with incompressible randomly generated data we can rule out the first possibility . Next , we artificially double the vocabulary size by introducing “ synonym ” tokens and observe that the vocabulary growth , in isolation , leads to a different memorization pattern . Thus , by exclusion , we conjecture that reducing utterance length is , at least , a very important factor of memorization.2 . 2 STUDYING MEMORIZATION – THE TASKS . To quantify the memorization capabilities and preferences of NLP models , we use three different setups , with which we aim to cover different facets of what one can call training data memorization . 2.1 LEARNING MAPPINGS WITH RANDOM LABELS . Firstly , we consider a task of learning non-systematic mappings , where labels are independent from inputs ( Zhang et al. , 2016 ) . To achieve accuracy above chance , the model has to “ store ” the training example in some way , thus we assume that a higher training accuracy implies increased training data memorization ability . To experiment with realistic natural input data , we consider the Stanford Natural Language Inference dataset ( SNLI , Bowman et al. , 2015 ) . In this dataset , each example is a pair of two sentences , one representing a premise ( “ A boy is jumping on skateboard in the middle of a red bridge. ” ) and the other representing a hypothesis ( “ The boy does a skateboarding trick. ” ) . Each example is assigned a 1An interesting example is the language model of Lakhotia et al . ( 2021 ) , which is trained on sub-phonemic acoustic units without word boundaries , but confidently processes a large vocabulary of English words . 2Another potential cause that we consider is the changes in the relative frequencies of tokens that BPE brings along . In Appendix D we investigate and rule out this hypothesis . label that denotes if the hypothesis entails the premise , contradicts it , or neither contradict nor entails ( neutral ) . We represent examples in a concatenated form with a separator token ( : : ) between a premise and a hypothesis ( “ A boy is jumping on skateboard in the middle of a red bridge . : : The boy does a skateboarding trick. ” ) . For uniformity with other experiments , we transform the dataset into a binary classification task by filtering out all examples with neutral labels.3 After this filtering , 367,388 examples remain . We replace original labels with randomly sampled ones ( -1 / +1 , equiprobably ) , and we measure memorization by measuring the ( training ) accuracy of the models on this data . 2.2 MEMBERSHIP INFERENCE . While the task of memorizing random labels can tell us how much a model can remember , it doesn ’ t allow us to test how much or what a model memorizes when it is trained on tasks which also admit ( or require ) generalization . As this is typically the case with natural data , we thus need a different strategy to assess memorization in more realistic scenarios . To evaluate memorization in such cases , we resort to measuring models ’ vulnerability to membership inference attacks ( Shokri et al. , 2017 ) . Indeed , if it is “ easy ” to accurately tell if a particular example was used for training , we assume it is actually “ stored ” in the weights of the model in some form , rather than being inferred from a more general rule or pattern ( which would lead to high scores also for examples that were not in the training data , but that are likely given that data ) . More formally , suppose we have a model fθ that was trained on a subset D′ of a large set of examples D , ( D′ ⊂ D ) withD′ obtained by sampling examples independently fromD with some probability λ . The goal of membership inference is to figure out , given fθ , whether a particular example ( xi , yi ) ∈ D was included in the training data D′ . We implement a simple membership inference attack protocol by Yeom et al . ( 2018 ) . Given a model fθ parameterized by θ , we calculate its loss on a data point l ( fθ ( xi ) , yi ) and compare to a threshold τ : if it is below the threshold , the data point belongs to the training data . By controlling τ we can control the trade-off between precision and recall of the attack . To avoid the dependency on this parameter and to represent the entire space of possible trade-offs , we use the AUC metric . After training a model , we measure the AUC of the above rule that separates training and hold-out examples . In this set of experiments , we again use the SNLI dataset . However , in this experiment we use the true labels of the dataset , rather than using the random labels of the previous setup , allowing us to consider both generalization and memorization . To make the prior probability of an example belonging to the training dataset equal to 12 , at training time we use only a half of the original ’ s dataset training data ( 367,388 examples remaining after filtering ) , with the second half playing the role of the hold-out . | This paper investigates the impact of subword vocabulary size on the memorization ability of Transformer models. The authors designed three types of tasks to evaluate the changes of model memorization, namely learning mappings with random labels, membership inference and training data recovery. Experimental results show that the memorization ability of Transformer model is stronger with the increase of subword vocabulary size, which the authors attribute to the reduction in the sequences' length. | SP:842ff110a244839688e360ec6f67f2e56d609d4a |
How BPE Affects Memorization in Transformers | Training data memorization in NLP can both be beneficial ( e.g. , closed-book QA ) and undesirable ( personal data extraction ) . In any case , successful model training requires a non-trivial amount of memorization to store word spellings , various linguistic idiosyncrasies and common knowledge . However , little is known about what affects the memorization behavior of NLP models , as the field tends to focus on the equally important question of generalization . In this work , we demonstrate that the size of the subword vocabulary learned by Byte-Pair Encoding ( BPE ) greatly affects both ability and tendency of standard Transformer models to memorize training data , even when we control for the number of learned parameters . We find that with a large subword vocabulary size , Transformer models fit random mappings more easily and are more vulnerable to membership inference attacks . Similarly , given a prompt , Transformer-based language models with large subword vocabularies reproduce the training data more often . We conjecture this effect is caused by reduction in the sequences ’ length that happens as the BPE vocabulary grows . Our findings can allow a more informed choice of hyper-parameters , that is better tailored for a particular use-case . 1 INTRODUCTION . The Transformer architecture ( Vaswani et al. , 2017 ) became the backbone of the state-of-the-art models in a variety of tasks ( Liu et al. , 2019 ; Raffel et al. , 2019 ; Adiwardana et al. , 2020 ; Brown et al. , 2020 ) . This spurred a significant interest in better understanding inner workings of these models ( Vig and Belinkov , 2019 ; Clark et al. , 2019 ; Kharitonov and Chaabouni , 2020 ; Hahn , 2020 ; Movva and Zhao , 2020 ; Chaabouni et al. , 2021 ; Merrill et al. , 2021 ; Sinha et al. , 2021 ) . Most of these works have focussed specifically on how models generalize and capture structure across samples that are similar . For instance , Vig and Belinkov ( 2019 ) focussed on how attention align with specific syntactic dependency relations , Hupkes et al . ( 2020 ) considered if Transformers generalize compositionally and Kharitonov and Chaabouni ( 2020 ) studied how different models generalize from very few data . In contrast to these studies , we focus on factors that control the training data memorization behavior of Transformers , which we believe to be important for several reasons . First , large Transformer models are increasingly often used as a storage , for instance , as a generalpurpose knowledge base or as a closed-book question-answering system ( Petroni et al. , 2019 ; Roberts et al. , 2020 ; Lewis et al. , 2020 ) . Clearly , the ability to memorize factual knowledge from the training data is crucial for such applications . There are even Transformers models that are explicitly endowed with an external training data memorization mechanism ( Khandelwal et al. , 2020 ; 2021 ; He et al. , 2021 ) , demonstrating that further boosting their memorization abilities is beneficial . Second , in contrast , the same ability to memorize can become undesirable and lead to a leakage of personal data from trained models ( Carlini et al. , 2020 ; Thakkar et al. , 2021 ) . A better understanding of the phenomenon is thus instrumental both to enable better memorization when it is needed and to avoid it when not . Third , while generalization and memorization are often thought of as competing modes of fitting data , training effective models in real tasks requires a non-trivial combination of the two . For instance , successful language models need to generalize to be able to deal with never-seen-before sentences , but they also need to memorize the spelling of words , the non-compositional meaning of idioms , idiosyncrasies of languages , common knowledge , etc ( see , e.g . Dankers et al. , 2021 ) .1 Despite this apparent importance , there is very little research into memorization in Transformers and in NLP models in general , and we have only superficial understanding of what factors affect this behavior . Intuitively , the number of parameters , data augmentation , and regularization are likely to affect how successful models are in memorization ( Zhang et al. , 2016 ; Sablayrolles et al. , 2018 ) . In this work , we primarily focus on the influence of a less obvious yet important factor : we study how the selection of modelling units affects memorization . Typically , the same data can be represented on various levels : raw bytes and their groups , individual characters , subword units , and entire words . A very common approach is to learn subword-level vocabulary with Byte-Pair Encoding ( BPE ) ( Sennrich et al. , 2015 ) or similar methods ( e.g. , Devlin et al. , 2018 ; Kudo and Richardson , 2018 ; Provilkov et al. , 2019 ) . In spite of ubiquitous use of these methods , to the best of our knowledge , there is no clear understanding of how the number of subwords or BPE operations should be chosen and how this affect behavior of a model . We expect that BPE-like segmentation might play a crucial role in memorization , as it controls the trade-off between the number of primitives a model will have to operate with and the lengths of sequences it must represent . In this work , to characterize a model ’ s behavior , we measure three “ facets ” of training data memorization . First , as a proxy for the memorization capacity of a model , we use its ability to fit random , non-systematic mappings . Next , we study the preference for memorization when generalization is possible . For that , we study how easy it is to accurately tell if a particular example was used in the model ’ s training data via a membership inference attack ( Shokri et al. , 2017 ) . Finally , we examine how easy it is to recover training data from a trained language model . We experiment with three Transformer architectures : causal & masked language models , and encoder-based classifiers . Our main experimental finding is that , across all architectures and tasks , the choice of modeling units strongly affects the memorization behavior of the models , with large-cardinality BPE vocabularies greatly facilitating memorization . This observation holds even when we control for the number of trainable parameters . After establishing this fact , we look deeper into the causes of the phenomenon we observe . We examine three candidate causes which are principal ( side- ) effects of applying BPE : ( i ) removing redundancy in the data ( due to compression ) , ( ii ) increase in the number of the unique units used to represent the data , or ( iii ) reducing the length of the training sequences . By finding a similar effect with incompressible randomly generated data we can rule out the first possibility . Next , we artificially double the vocabulary size by introducing “ synonym ” tokens and observe that the vocabulary growth , in isolation , leads to a different memorization pattern . Thus , by exclusion , we conjecture that reducing utterance length is , at least , a very important factor of memorization.2 . 2 STUDYING MEMORIZATION – THE TASKS . To quantify the memorization capabilities and preferences of NLP models , we use three different setups , with which we aim to cover different facets of what one can call training data memorization . 2.1 LEARNING MAPPINGS WITH RANDOM LABELS . Firstly , we consider a task of learning non-systematic mappings , where labels are independent from inputs ( Zhang et al. , 2016 ) . To achieve accuracy above chance , the model has to “ store ” the training example in some way , thus we assume that a higher training accuracy implies increased training data memorization ability . To experiment with realistic natural input data , we consider the Stanford Natural Language Inference dataset ( SNLI , Bowman et al. , 2015 ) . In this dataset , each example is a pair of two sentences , one representing a premise ( “ A boy is jumping on skateboard in the middle of a red bridge. ” ) and the other representing a hypothesis ( “ The boy does a skateboarding trick. ” ) . Each example is assigned a 1An interesting example is the language model of Lakhotia et al . ( 2021 ) , which is trained on sub-phonemic acoustic units without word boundaries , but confidently processes a large vocabulary of English words . 2Another potential cause that we consider is the changes in the relative frequencies of tokens that BPE brings along . In Appendix D we investigate and rule out this hypothesis . label that denotes if the hypothesis entails the premise , contradicts it , or neither contradict nor entails ( neutral ) . We represent examples in a concatenated form with a separator token ( : : ) between a premise and a hypothesis ( “ A boy is jumping on skateboard in the middle of a red bridge . : : The boy does a skateboarding trick. ” ) . For uniformity with other experiments , we transform the dataset into a binary classification task by filtering out all examples with neutral labels.3 After this filtering , 367,388 examples remain . We replace original labels with randomly sampled ones ( -1 / +1 , equiprobably ) , and we measure memorization by measuring the ( training ) accuracy of the models on this data . 2.2 MEMBERSHIP INFERENCE . While the task of memorizing random labels can tell us how much a model can remember , it doesn ’ t allow us to test how much or what a model memorizes when it is trained on tasks which also admit ( or require ) generalization . As this is typically the case with natural data , we thus need a different strategy to assess memorization in more realistic scenarios . To evaluate memorization in such cases , we resort to measuring models ’ vulnerability to membership inference attacks ( Shokri et al. , 2017 ) . Indeed , if it is “ easy ” to accurately tell if a particular example was used for training , we assume it is actually “ stored ” in the weights of the model in some form , rather than being inferred from a more general rule or pattern ( which would lead to high scores also for examples that were not in the training data , but that are likely given that data ) . More formally , suppose we have a model fθ that was trained on a subset D′ of a large set of examples D , ( D′ ⊂ D ) withD′ obtained by sampling examples independently fromD with some probability λ . The goal of membership inference is to figure out , given fθ , whether a particular example ( xi , yi ) ∈ D was included in the training data D′ . We implement a simple membership inference attack protocol by Yeom et al . ( 2018 ) . Given a model fθ parameterized by θ , we calculate its loss on a data point l ( fθ ( xi ) , yi ) and compare to a threshold τ : if it is below the threshold , the data point belongs to the training data . By controlling τ we can control the trade-off between precision and recall of the attack . To avoid the dependency on this parameter and to represent the entire space of possible trade-offs , we use the AUC metric . After training a model , we measure the AUC of the above rule that separates training and hold-out examples . In this set of experiments , we again use the SNLI dataset . However , in this experiment we use the true labels of the dataset , rather than using the random labels of the previous setup , allowing us to consider both generalization and memorization . To make the prior probability of an example belonging to the training dataset equal to 12 , at training time we use only a half of the original ’ s dataset training data ( 367,388 examples remaining after filtering ) , with the second half playing the role of the hold-out . | This paper as the name suggests, tries to figure out whether and through which ways bpe can affect Transformer’s memorization capacity. It evaluates Transformer’s memorization under these 4 settings: memorizing random synthetic data, memorizing random labeled natural language data, recognizing training data with lower output entropy, and training data recovery QA. Experiments show that if we have more merge times for bpe (larger vocabulary size), the model’s performance on all the four settings would improve on 3 architectures, which shows that bpe indeed can affect the model’s memorization capacity. Larger the vocabulary size is, the better the model would perform on memorizing. Then, the paper tries to figure out why more merges in bpe would lead to better memorization. By excluding two other hypotheses, the paper concludes that more merges in bpe results in shorter input sequence and that makes memorizing easier for transformers. | SP:842ff110a244839688e360ec6f67f2e56d609d4a |
Equalized Robustness: Towards Sustainable Fairness Under Distributional Shifts | 1 INTRODUCTION . With the wide deployment of deep learning in modern business applications concerning individual lives and privacy , there naturally emerge concerns on machine learning fairness ( Podesta et al. , 2014 ; Muñoz et al. , 2016 ; Smuha , 2019 ) . Research efforts on various fairness evaluation metrics and corresponding enforcing methods have been carried out ( Edwards & Storkey , 2016 ; Hardt et al. , 2016 ; Du et al. , 2020 ) . Specifically , many such metrics require some form of “ equalized model performance ” across different groups on in-distribution data . Examples include Demographic parity ( DP ) ( Edwards & Storkey , 2016 ) , Equalized Opportunity ( EOpp ) , and Equalized Odds ( EO ) ( Hardt et al. , 2016 ) . Unfortunately , when deployed for real-world applications , deep models commonly encounter data with unforeseeable distribution shifts ( Hendrycks & Dietterich , 2019 ; Hendrycks et al. , 2020 ; 2021 ) . It has been shown that deep learning models can have drastically degraded performance ( Hendrycks & Dietterich , 2019 ; Hendrycks et al. , 2020 ; 2021 ; Taori et al. , 2020 ) and show unreliable behaviors ( Qiu et al. , 2019 ; Yan et al. , 2021 ) under unseen distribution shifts . Intuitively speaking , previous fairness learning algorithms aim to optimize the model to a local minimum where data from majority and minority groups have similar average loss values ( and thus similar in-distribution performance ) . However , those algorithms do not take into consideration the the stability or “ robustness ” of their found fairness-aware minima . Taking object detection in a self-driving car for example , it might have been calibrated over high-quality clear images to be “ fair ” with different skin colors ; however such fairness may severely break down when applied to data collected in adverse visual conditions , such as inclement weather , poor lighting , or other digital artifacts . Our experiments also find that previous state-of-the-art fairness algorithms would be jeopardized if distributional shifts are present in test data , as illustrated in Figure 1 ( b ) . The above findings beg the following question : How to achieve practically sustainable fairness , e.g. , even under unseen distribution shifts ? To answer that , we first propose a new fairness objective , termed Equalized Robustness ( ER ) , which aims to impose “ equalized robustness ” against unseen distribution shifts across the majority and minority groups , so that the learned fairness can sustain even with test data perturbed . ER explicitly considers a new dimension of fairness that is practically significant yet so far largely overlooked . In other words , ER assesses fairness on “ out-of-distribution ” . Therefore it works as a complement instead of a replacement for previous fairness metrics , which focus on assessing the “ in-distribution ” fairness . Previous research has shown that model robustness against input perturbation is highly correlated with loss curvature smoothness ( Bartlett et al. , 2017 ; Moosavi-Dezfooli et al. , 2019 ; Weng et al. , 2018 ) . Our experiments also observed that , the local loss curvature of minority group is often larger than that of majority group , leading to the two group ’ s robustness discrepancy against distribution shifts . To this end , we propose to empirically quantify the robustness discrepancy as the maximum mean discrepancy ( MMD ) ( Gretton et al. , 2012 ) distance between the local model smoothness distributions , for data samples from the majority and minority groups . We experimentally demonstrate that our new metric aligns well with model performance under real-world distribution shifts . On top of that , we further propose a new fair learning algorithm , termed Curvature Matching ( CUMA ) , to simultaneously achieve both traditional in-distribution fairness and ER . CUMA matches the local curvature distribution between data points from the two different groups , as illustrated in Figure 1 ( c ) , by adding a curvature-matching regularizer that can be efficiently computed via a one-shot power iteration method . Our codes will be released upon acceptance . Our contributions can be summarized as bellow : • We propose Equalized Robustness ( ER ) , a new fairness objective for machine learning models , to impose equalized model robustness against unforeseeable distributions shifts across majority and minority groups . • We further propose a new fairness learning algorithm dubbed Curvature Matching ( CUMA ) , which enforces ER during training by utilizing a one-shot power iteration method . • Experiments show that CUMA achieves much more robust fairness against distribution shifts , without more sacrifice on either overall accuracies or the in-distribution fairness , compared with traditional in-distribution fair learning methods . 2 PRELIMINARIES . 2.1 MACHINE LEARNING FAIRNESS . Problem Setting and Metrics Machine learning fairness can be generally categorized into individual fairness and group fairness ( Du et al. , 2020 ) . Individual fairness requires similar inputs to have similar predictions ( Dwork et al. , 2012 ) . Compared with individual fairness , group fairness is a more popular setting and thus the focus of our paper . Given input data X ∈ Rn with sensitive attributes A ∈ { 0 , 1 } and their corresponding ground truth labels Y ∈ { 0 , 1 } , group fairness requires a learned binary classifier f ( · ; θ ) : Rn → { 0 , 1 } parameterized by θ to give equally accurate predictions ( denoted as Ŷ : = f ( X ) ) on the two groups with A = 0 and A = 1 . Multiple fairness criteria have been defined in this context . Demographic parity ( DP ) ( Edwards & Storkey , 2016 ) requires identical ratio of positive predictions between two groups : P ( Ŷ = 1|A = 0 ) = P ( Ŷ = 1|A = 1 ) . Equalized Odds ( EO ) ( Hardt et al. , 2016 ) requires identical false positive rates ( FPRs ) and false negative rates ( FNRs ) between the two groups : P ( Ŷ 6= Y |A = 0 , Y = y ) = P ( Ŷ 6= Y |A = 1 , Y = y ) , ∀y ∈ { 0 , 1 } . Equalized Opportunity ( EOpp ) ( Hardt et al. , 2016 ) requires only equal FNRs between the groups : P ( Ŷ 6= Y |A = 0 , Y = 0 ) = P ( Ŷ 6= Y |A = 1 , Y = 0 ) . Based on these fairness criteria , quantified metrics are defined to measure fairness . Specifically , DP , EO and EOpp distances ( Madras et al. , 2018 ) are defined as follows : ∆DP : = |P ( Ŷ = 1|A = 0 ) − P ( Ŷ = 1|A = 1 ) | ( 1 ) ∆EO : = ∑ y∈ { 0,1 } |P ( Ŷ 6= Y |A = 0 , Y = y ) − P ( Ŷ 6= Y |A = 1 , Y = y ) | ( 2 ) ∆EOpp : = |P ( Ŷ 6= Y |A = 0 , Y = 0 ) − P ( Ŷ 6= Y |A = 1 , Y = 0 ) | ( 3 ) MMD has been previously used to define fairness metric in ( Quadrianto & Sharmanska , 2017 ) defines a more general fairness metric using MMD distance , and shows ∆DP , ∆EO and ∆EOpp to be spatial cases of their unified metric . All these metrics consider the in-distribution fairness , while our Equalized Generalizibility is the first fairness metric explicitly aware of robust generalization ability on unseen distributions . Bias Mitigation Methods Many methods have been proposed to mitigate model bias . Data preprocessing methods such as re-weighting ( Kamiran & Calders , 2012 ) and data-transformation ( Calmon et al. , 2017 ) have been used to reduce discrimination before model training . In contrast , Hardt et al . ( 2016 ) and Zhao et al . ( 2017 ) propose post-processing methods to calibrate model predictions towards a desired fair distribution after model training . Instead of pre- or post-processing , researchers have explored to enhance fairness during training . For example , Madras et al . ( 2018 ) uses a adversarial training technique and shows the learned fair representations can transfer to unseen target tasks . The key technique , adversarial training ( Edwards & Storkey , 2016 ) , was designed for feature disentanglement on hidden representations such that sensitive ( Edwards & Storkey , 2016 ) or domain-specific information ( Ganin et al. , 2016 ) will be removed while keeping other useful information for the target task . The hidden representations are typically the output of intermediate layers of neural networks ( Ganin et al. , 2016 ; Edwards & Storkey , 2016 ; Madras et al. , 2018 ) . Instead , methods , like adversarial debiasing ( Zhang et al. , 2018 ) and its simplified version ( Wadsworth et al. , 2018 ) , directly apply the adversary on the output layer of the classifier , which also promotes the model fairness . Observing the unfairness due to ignoring the worst learning risk of specific samples , Hashimoto et al . ( 2018 ) proposes to use distributionally robust optimization which provably bounds the worst-case risk over groups . Creager et al . ( 2019 ) proposes a flexible fair representation learning framework based on VAE ( Kingma & Welling , 2013 ) , that can be easily adapted for different sensitive attribute settings during run-time . Sarhan et al . ( 2020 ) uses orthogonality constraints as a proxy for independence to disentangles the utility and sensitive representations . Martinez et al . ( 2020 ) formulates group fairness with multiple sensitive attributes as a multi-objective learning problem and proposes a simple optimization algorithm to find the Pareto optimality . Another line of research focuses on learning unbiased representations from biased ones ( Bahng et al. , 2020 ; Nam et al. , 2020 ) . Bahng et al . ( 2020 ) proposes a novel framework to learn unbiased representations by explicitly enforcing them to be different from a set of pre-defined biased representations . Nam et al . ( 2020 ) observes that data bias can be either benign or malicious , and removing malicious bias along can achieve fairness . Li & Vasconcelos ( 2019 ) jointly learns a data re-sampling weight distribution that penalizes easy samples and network parameters . Applications in Computer Vision When many fairness metrics and debiasing algorithms are designed for general learning problems as aforementioned , there are a line of research and applications focusing on fairness-encouraged computer vision tasks . For instance , Buolamwini et al . ( Buolamwini & Gebru , 2018 ) shows current commercial gender-recognition systems have substantial accuracy disparities among groups with different genders and skin colors . Wilson et al . ( 2019 ) observe that state-of-the-art segmentation models achieve better performance on pedestrians with lighter skin colors . In ( Shankar et al. , 2017 ; de Vries et al. , 2019 ) , it is found that the common geographical bias in public image databases can lead to strong performance disparities among images from locales with different income levels . Nagpal et al . ( 2019 ) reveal that the focus region of face-classification models depends on people ’ s ages or races , which may explain the source of age- and race-biases of classifiers . On the awareness of the unfairness , many efforts have been devoted to mitigate such biases in computer vision tasks . Wang et al . ( 2019 ) shows the effectiveness of adversarial debiasing technique ( Zhang et al. , 2018 ) in fair image classification and activity recognition tasks . Beyond the supervised learning , FairFaceGAN ( Hwang et al. , 2020 ) is proposed to prevent undesired sensitive feature translation during image editing . Similar ideas have also been successfully applied to visual question answering ( Park et al. , 2020 ) . | The paper is motivated by a common problem in real world applications of deep models, distributional shifts, which can cause unreliable behavior in the deployed models. In particular, state-of-the-art fairness algorithms would be affected by such distributional shifts in the test data. This poses the following question studied by the paper: how can one achieve fairness when there exist unseen distributional shifts? Towards this end, the paper proposes a new objective: Equalized Robustness (ER), that imposes equalized model robustness against distributions shifts across majority and minority. Fruthermore, the paper develops a new algorithm called Curvature Matching (CUMA) that imposes ER during training, and tests it through experiments. | SP:9c57d3125e4ccdb69c7ce9cbaf907520e1957af3 |
Equalized Robustness: Towards Sustainable Fairness Under Distributional Shifts | 1 INTRODUCTION . With the wide deployment of deep learning in modern business applications concerning individual lives and privacy , there naturally emerge concerns on machine learning fairness ( Podesta et al. , 2014 ; Muñoz et al. , 2016 ; Smuha , 2019 ) . Research efforts on various fairness evaluation metrics and corresponding enforcing methods have been carried out ( Edwards & Storkey , 2016 ; Hardt et al. , 2016 ; Du et al. , 2020 ) . Specifically , many such metrics require some form of “ equalized model performance ” across different groups on in-distribution data . Examples include Demographic parity ( DP ) ( Edwards & Storkey , 2016 ) , Equalized Opportunity ( EOpp ) , and Equalized Odds ( EO ) ( Hardt et al. , 2016 ) . Unfortunately , when deployed for real-world applications , deep models commonly encounter data with unforeseeable distribution shifts ( Hendrycks & Dietterich , 2019 ; Hendrycks et al. , 2020 ; 2021 ) . It has been shown that deep learning models can have drastically degraded performance ( Hendrycks & Dietterich , 2019 ; Hendrycks et al. , 2020 ; 2021 ; Taori et al. , 2020 ) and show unreliable behaviors ( Qiu et al. , 2019 ; Yan et al. , 2021 ) under unseen distribution shifts . Intuitively speaking , previous fairness learning algorithms aim to optimize the model to a local minimum where data from majority and minority groups have similar average loss values ( and thus similar in-distribution performance ) . However , those algorithms do not take into consideration the the stability or “ robustness ” of their found fairness-aware minima . Taking object detection in a self-driving car for example , it might have been calibrated over high-quality clear images to be “ fair ” with different skin colors ; however such fairness may severely break down when applied to data collected in adverse visual conditions , such as inclement weather , poor lighting , or other digital artifacts . Our experiments also find that previous state-of-the-art fairness algorithms would be jeopardized if distributional shifts are present in test data , as illustrated in Figure 1 ( b ) . The above findings beg the following question : How to achieve practically sustainable fairness , e.g. , even under unseen distribution shifts ? To answer that , we first propose a new fairness objective , termed Equalized Robustness ( ER ) , which aims to impose “ equalized robustness ” against unseen distribution shifts across the majority and minority groups , so that the learned fairness can sustain even with test data perturbed . ER explicitly considers a new dimension of fairness that is practically significant yet so far largely overlooked . In other words , ER assesses fairness on “ out-of-distribution ” . Therefore it works as a complement instead of a replacement for previous fairness metrics , which focus on assessing the “ in-distribution ” fairness . Previous research has shown that model robustness against input perturbation is highly correlated with loss curvature smoothness ( Bartlett et al. , 2017 ; Moosavi-Dezfooli et al. , 2019 ; Weng et al. , 2018 ) . Our experiments also observed that , the local loss curvature of minority group is often larger than that of majority group , leading to the two group ’ s robustness discrepancy against distribution shifts . To this end , we propose to empirically quantify the robustness discrepancy as the maximum mean discrepancy ( MMD ) ( Gretton et al. , 2012 ) distance between the local model smoothness distributions , for data samples from the majority and minority groups . We experimentally demonstrate that our new metric aligns well with model performance under real-world distribution shifts . On top of that , we further propose a new fair learning algorithm , termed Curvature Matching ( CUMA ) , to simultaneously achieve both traditional in-distribution fairness and ER . CUMA matches the local curvature distribution between data points from the two different groups , as illustrated in Figure 1 ( c ) , by adding a curvature-matching regularizer that can be efficiently computed via a one-shot power iteration method . Our codes will be released upon acceptance . Our contributions can be summarized as bellow : • We propose Equalized Robustness ( ER ) , a new fairness objective for machine learning models , to impose equalized model robustness against unforeseeable distributions shifts across majority and minority groups . • We further propose a new fairness learning algorithm dubbed Curvature Matching ( CUMA ) , which enforces ER during training by utilizing a one-shot power iteration method . • Experiments show that CUMA achieves much more robust fairness against distribution shifts , without more sacrifice on either overall accuracies or the in-distribution fairness , compared with traditional in-distribution fair learning methods . 2 PRELIMINARIES . 2.1 MACHINE LEARNING FAIRNESS . Problem Setting and Metrics Machine learning fairness can be generally categorized into individual fairness and group fairness ( Du et al. , 2020 ) . Individual fairness requires similar inputs to have similar predictions ( Dwork et al. , 2012 ) . Compared with individual fairness , group fairness is a more popular setting and thus the focus of our paper . Given input data X ∈ Rn with sensitive attributes A ∈ { 0 , 1 } and their corresponding ground truth labels Y ∈ { 0 , 1 } , group fairness requires a learned binary classifier f ( · ; θ ) : Rn → { 0 , 1 } parameterized by θ to give equally accurate predictions ( denoted as Ŷ : = f ( X ) ) on the two groups with A = 0 and A = 1 . Multiple fairness criteria have been defined in this context . Demographic parity ( DP ) ( Edwards & Storkey , 2016 ) requires identical ratio of positive predictions between two groups : P ( Ŷ = 1|A = 0 ) = P ( Ŷ = 1|A = 1 ) . Equalized Odds ( EO ) ( Hardt et al. , 2016 ) requires identical false positive rates ( FPRs ) and false negative rates ( FNRs ) between the two groups : P ( Ŷ 6= Y |A = 0 , Y = y ) = P ( Ŷ 6= Y |A = 1 , Y = y ) , ∀y ∈ { 0 , 1 } . Equalized Opportunity ( EOpp ) ( Hardt et al. , 2016 ) requires only equal FNRs between the groups : P ( Ŷ 6= Y |A = 0 , Y = 0 ) = P ( Ŷ 6= Y |A = 1 , Y = 0 ) . Based on these fairness criteria , quantified metrics are defined to measure fairness . Specifically , DP , EO and EOpp distances ( Madras et al. , 2018 ) are defined as follows : ∆DP : = |P ( Ŷ = 1|A = 0 ) − P ( Ŷ = 1|A = 1 ) | ( 1 ) ∆EO : = ∑ y∈ { 0,1 } |P ( Ŷ 6= Y |A = 0 , Y = y ) − P ( Ŷ 6= Y |A = 1 , Y = y ) | ( 2 ) ∆EOpp : = |P ( Ŷ 6= Y |A = 0 , Y = 0 ) − P ( Ŷ 6= Y |A = 1 , Y = 0 ) | ( 3 ) MMD has been previously used to define fairness metric in ( Quadrianto & Sharmanska , 2017 ) defines a more general fairness metric using MMD distance , and shows ∆DP , ∆EO and ∆EOpp to be spatial cases of their unified metric . All these metrics consider the in-distribution fairness , while our Equalized Generalizibility is the first fairness metric explicitly aware of robust generalization ability on unseen distributions . Bias Mitigation Methods Many methods have been proposed to mitigate model bias . Data preprocessing methods such as re-weighting ( Kamiran & Calders , 2012 ) and data-transformation ( Calmon et al. , 2017 ) have been used to reduce discrimination before model training . In contrast , Hardt et al . ( 2016 ) and Zhao et al . ( 2017 ) propose post-processing methods to calibrate model predictions towards a desired fair distribution after model training . Instead of pre- or post-processing , researchers have explored to enhance fairness during training . For example , Madras et al . ( 2018 ) uses a adversarial training technique and shows the learned fair representations can transfer to unseen target tasks . The key technique , adversarial training ( Edwards & Storkey , 2016 ) , was designed for feature disentanglement on hidden representations such that sensitive ( Edwards & Storkey , 2016 ) or domain-specific information ( Ganin et al. , 2016 ) will be removed while keeping other useful information for the target task . The hidden representations are typically the output of intermediate layers of neural networks ( Ganin et al. , 2016 ; Edwards & Storkey , 2016 ; Madras et al. , 2018 ) . Instead , methods , like adversarial debiasing ( Zhang et al. , 2018 ) and its simplified version ( Wadsworth et al. , 2018 ) , directly apply the adversary on the output layer of the classifier , which also promotes the model fairness . Observing the unfairness due to ignoring the worst learning risk of specific samples , Hashimoto et al . ( 2018 ) proposes to use distributionally robust optimization which provably bounds the worst-case risk over groups . Creager et al . ( 2019 ) proposes a flexible fair representation learning framework based on VAE ( Kingma & Welling , 2013 ) , that can be easily adapted for different sensitive attribute settings during run-time . Sarhan et al . ( 2020 ) uses orthogonality constraints as a proxy for independence to disentangles the utility and sensitive representations . Martinez et al . ( 2020 ) formulates group fairness with multiple sensitive attributes as a multi-objective learning problem and proposes a simple optimization algorithm to find the Pareto optimality . Another line of research focuses on learning unbiased representations from biased ones ( Bahng et al. , 2020 ; Nam et al. , 2020 ) . Bahng et al . ( 2020 ) proposes a novel framework to learn unbiased representations by explicitly enforcing them to be different from a set of pre-defined biased representations . Nam et al . ( 2020 ) observes that data bias can be either benign or malicious , and removing malicious bias along can achieve fairness . Li & Vasconcelos ( 2019 ) jointly learns a data re-sampling weight distribution that penalizes easy samples and network parameters . Applications in Computer Vision When many fairness metrics and debiasing algorithms are designed for general learning problems as aforementioned , there are a line of research and applications focusing on fairness-encouraged computer vision tasks . For instance , Buolamwini et al . ( Buolamwini & Gebru , 2018 ) shows current commercial gender-recognition systems have substantial accuracy disparities among groups with different genders and skin colors . Wilson et al . ( 2019 ) observe that state-of-the-art segmentation models achieve better performance on pedestrians with lighter skin colors . In ( Shankar et al. , 2017 ; de Vries et al. , 2019 ) , it is found that the common geographical bias in public image databases can lead to strong performance disparities among images from locales with different income levels . Nagpal et al . ( 2019 ) reveal that the focus region of face-classification models depends on people ’ s ages or races , which may explain the source of age- and race-biases of classifiers . On the awareness of the unfairness , many efforts have been devoted to mitigate such biases in computer vision tasks . Wang et al . ( 2019 ) shows the effectiveness of adversarial debiasing technique ( Zhang et al. , 2018 ) in fair image classification and activity recognition tasks . Beyond the supervised learning , FairFaceGAN ( Hwang et al. , 2020 ) is proposed to prevent undesired sensitive feature translation during image editing . Similar ideas have also been successfully applied to visual question answering ( Park et al. , 2020 ) . | The paper proposed a new penalty term which is expected to make the final prediction model robust to distribution shift of test data. The proposed penalty is based on the distributions of local curvatures of two sensitive groups and enforces these two distributions to be similar. The proposed idea is motivated by robust learning methods where the prediction model is robust to distributional shift. | SP:9c57d3125e4ccdb69c7ce9cbaf907520e1957af3 |
Equalized Robustness: Towards Sustainable Fairness Under Distributional Shifts | 1 INTRODUCTION . With the wide deployment of deep learning in modern business applications concerning individual lives and privacy , there naturally emerge concerns on machine learning fairness ( Podesta et al. , 2014 ; Muñoz et al. , 2016 ; Smuha , 2019 ) . Research efforts on various fairness evaluation metrics and corresponding enforcing methods have been carried out ( Edwards & Storkey , 2016 ; Hardt et al. , 2016 ; Du et al. , 2020 ) . Specifically , many such metrics require some form of “ equalized model performance ” across different groups on in-distribution data . Examples include Demographic parity ( DP ) ( Edwards & Storkey , 2016 ) , Equalized Opportunity ( EOpp ) , and Equalized Odds ( EO ) ( Hardt et al. , 2016 ) . Unfortunately , when deployed for real-world applications , deep models commonly encounter data with unforeseeable distribution shifts ( Hendrycks & Dietterich , 2019 ; Hendrycks et al. , 2020 ; 2021 ) . It has been shown that deep learning models can have drastically degraded performance ( Hendrycks & Dietterich , 2019 ; Hendrycks et al. , 2020 ; 2021 ; Taori et al. , 2020 ) and show unreliable behaviors ( Qiu et al. , 2019 ; Yan et al. , 2021 ) under unseen distribution shifts . Intuitively speaking , previous fairness learning algorithms aim to optimize the model to a local minimum where data from majority and minority groups have similar average loss values ( and thus similar in-distribution performance ) . However , those algorithms do not take into consideration the the stability or “ robustness ” of their found fairness-aware minima . Taking object detection in a self-driving car for example , it might have been calibrated over high-quality clear images to be “ fair ” with different skin colors ; however such fairness may severely break down when applied to data collected in adverse visual conditions , such as inclement weather , poor lighting , or other digital artifacts . Our experiments also find that previous state-of-the-art fairness algorithms would be jeopardized if distributional shifts are present in test data , as illustrated in Figure 1 ( b ) . The above findings beg the following question : How to achieve practically sustainable fairness , e.g. , even under unseen distribution shifts ? To answer that , we first propose a new fairness objective , termed Equalized Robustness ( ER ) , which aims to impose “ equalized robustness ” against unseen distribution shifts across the majority and minority groups , so that the learned fairness can sustain even with test data perturbed . ER explicitly considers a new dimension of fairness that is practically significant yet so far largely overlooked . In other words , ER assesses fairness on “ out-of-distribution ” . Therefore it works as a complement instead of a replacement for previous fairness metrics , which focus on assessing the “ in-distribution ” fairness . Previous research has shown that model robustness against input perturbation is highly correlated with loss curvature smoothness ( Bartlett et al. , 2017 ; Moosavi-Dezfooli et al. , 2019 ; Weng et al. , 2018 ) . Our experiments also observed that , the local loss curvature of minority group is often larger than that of majority group , leading to the two group ’ s robustness discrepancy against distribution shifts . To this end , we propose to empirically quantify the robustness discrepancy as the maximum mean discrepancy ( MMD ) ( Gretton et al. , 2012 ) distance between the local model smoothness distributions , for data samples from the majority and minority groups . We experimentally demonstrate that our new metric aligns well with model performance under real-world distribution shifts . On top of that , we further propose a new fair learning algorithm , termed Curvature Matching ( CUMA ) , to simultaneously achieve both traditional in-distribution fairness and ER . CUMA matches the local curvature distribution between data points from the two different groups , as illustrated in Figure 1 ( c ) , by adding a curvature-matching regularizer that can be efficiently computed via a one-shot power iteration method . Our codes will be released upon acceptance . Our contributions can be summarized as bellow : • We propose Equalized Robustness ( ER ) , a new fairness objective for machine learning models , to impose equalized model robustness against unforeseeable distributions shifts across majority and minority groups . • We further propose a new fairness learning algorithm dubbed Curvature Matching ( CUMA ) , which enforces ER during training by utilizing a one-shot power iteration method . • Experiments show that CUMA achieves much more robust fairness against distribution shifts , without more sacrifice on either overall accuracies or the in-distribution fairness , compared with traditional in-distribution fair learning methods . 2 PRELIMINARIES . 2.1 MACHINE LEARNING FAIRNESS . Problem Setting and Metrics Machine learning fairness can be generally categorized into individual fairness and group fairness ( Du et al. , 2020 ) . Individual fairness requires similar inputs to have similar predictions ( Dwork et al. , 2012 ) . Compared with individual fairness , group fairness is a more popular setting and thus the focus of our paper . Given input data X ∈ Rn with sensitive attributes A ∈ { 0 , 1 } and their corresponding ground truth labels Y ∈ { 0 , 1 } , group fairness requires a learned binary classifier f ( · ; θ ) : Rn → { 0 , 1 } parameterized by θ to give equally accurate predictions ( denoted as Ŷ : = f ( X ) ) on the two groups with A = 0 and A = 1 . Multiple fairness criteria have been defined in this context . Demographic parity ( DP ) ( Edwards & Storkey , 2016 ) requires identical ratio of positive predictions between two groups : P ( Ŷ = 1|A = 0 ) = P ( Ŷ = 1|A = 1 ) . Equalized Odds ( EO ) ( Hardt et al. , 2016 ) requires identical false positive rates ( FPRs ) and false negative rates ( FNRs ) between the two groups : P ( Ŷ 6= Y |A = 0 , Y = y ) = P ( Ŷ 6= Y |A = 1 , Y = y ) , ∀y ∈ { 0 , 1 } . Equalized Opportunity ( EOpp ) ( Hardt et al. , 2016 ) requires only equal FNRs between the groups : P ( Ŷ 6= Y |A = 0 , Y = 0 ) = P ( Ŷ 6= Y |A = 1 , Y = 0 ) . Based on these fairness criteria , quantified metrics are defined to measure fairness . Specifically , DP , EO and EOpp distances ( Madras et al. , 2018 ) are defined as follows : ∆DP : = |P ( Ŷ = 1|A = 0 ) − P ( Ŷ = 1|A = 1 ) | ( 1 ) ∆EO : = ∑ y∈ { 0,1 } |P ( Ŷ 6= Y |A = 0 , Y = y ) − P ( Ŷ 6= Y |A = 1 , Y = y ) | ( 2 ) ∆EOpp : = |P ( Ŷ 6= Y |A = 0 , Y = 0 ) − P ( Ŷ 6= Y |A = 1 , Y = 0 ) | ( 3 ) MMD has been previously used to define fairness metric in ( Quadrianto & Sharmanska , 2017 ) defines a more general fairness metric using MMD distance , and shows ∆DP , ∆EO and ∆EOpp to be spatial cases of their unified metric . All these metrics consider the in-distribution fairness , while our Equalized Generalizibility is the first fairness metric explicitly aware of robust generalization ability on unseen distributions . Bias Mitigation Methods Many methods have been proposed to mitigate model bias . Data preprocessing methods such as re-weighting ( Kamiran & Calders , 2012 ) and data-transformation ( Calmon et al. , 2017 ) have been used to reduce discrimination before model training . In contrast , Hardt et al . ( 2016 ) and Zhao et al . ( 2017 ) propose post-processing methods to calibrate model predictions towards a desired fair distribution after model training . Instead of pre- or post-processing , researchers have explored to enhance fairness during training . For example , Madras et al . ( 2018 ) uses a adversarial training technique and shows the learned fair representations can transfer to unseen target tasks . The key technique , adversarial training ( Edwards & Storkey , 2016 ) , was designed for feature disentanglement on hidden representations such that sensitive ( Edwards & Storkey , 2016 ) or domain-specific information ( Ganin et al. , 2016 ) will be removed while keeping other useful information for the target task . The hidden representations are typically the output of intermediate layers of neural networks ( Ganin et al. , 2016 ; Edwards & Storkey , 2016 ; Madras et al. , 2018 ) . Instead , methods , like adversarial debiasing ( Zhang et al. , 2018 ) and its simplified version ( Wadsworth et al. , 2018 ) , directly apply the adversary on the output layer of the classifier , which also promotes the model fairness . Observing the unfairness due to ignoring the worst learning risk of specific samples , Hashimoto et al . ( 2018 ) proposes to use distributionally robust optimization which provably bounds the worst-case risk over groups . Creager et al . ( 2019 ) proposes a flexible fair representation learning framework based on VAE ( Kingma & Welling , 2013 ) , that can be easily adapted for different sensitive attribute settings during run-time . Sarhan et al . ( 2020 ) uses orthogonality constraints as a proxy for independence to disentangles the utility and sensitive representations . Martinez et al . ( 2020 ) formulates group fairness with multiple sensitive attributes as a multi-objective learning problem and proposes a simple optimization algorithm to find the Pareto optimality . Another line of research focuses on learning unbiased representations from biased ones ( Bahng et al. , 2020 ; Nam et al. , 2020 ) . Bahng et al . ( 2020 ) proposes a novel framework to learn unbiased representations by explicitly enforcing them to be different from a set of pre-defined biased representations . Nam et al . ( 2020 ) observes that data bias can be either benign or malicious , and removing malicious bias along can achieve fairness . Li & Vasconcelos ( 2019 ) jointly learns a data re-sampling weight distribution that penalizes easy samples and network parameters . Applications in Computer Vision When many fairness metrics and debiasing algorithms are designed for general learning problems as aforementioned , there are a line of research and applications focusing on fairness-encouraged computer vision tasks . For instance , Buolamwini et al . ( Buolamwini & Gebru , 2018 ) shows current commercial gender-recognition systems have substantial accuracy disparities among groups with different genders and skin colors . Wilson et al . ( 2019 ) observe that state-of-the-art segmentation models achieve better performance on pedestrians with lighter skin colors . In ( Shankar et al. , 2017 ; de Vries et al. , 2019 ) , it is found that the common geographical bias in public image databases can lead to strong performance disparities among images from locales with different income levels . Nagpal et al . ( 2019 ) reveal that the focus region of face-classification models depends on people ’ s ages or races , which may explain the source of age- and race-biases of classifiers . On the awareness of the unfairness , many efforts have been devoted to mitigate such biases in computer vision tasks . Wang et al . ( 2019 ) shows the effectiveness of adversarial debiasing technique ( Zhang et al. , 2018 ) in fair image classification and activity recognition tasks . Beyond the supervised learning , FairFaceGAN ( Hwang et al. , 2020 ) is proposed to prevent undesired sensitive feature translation during image editing . Similar ideas have also been successfully applied to visual question answering ( Park et al. , 2020 ) . | This paper proposes a new fairness metric, Equalized Robustness (ER), to assess model robustness for sensitive subgroups. ER measures the maximum mean discrepancy (MMD) between the loss curvature of the two sensitive groups. The paper proposes using gradient direction to approximate the spectral norm and using finite differences to approximate the Hessian. The MMD is calculated using the RBF kernel. The paper shows that existing in-distribution fairness promoting methods do not achieve parity with respect to the new metric. A new method, curvature matching (CUMA), is proposed to achieve both in-distribution and robust fairness. CUMA adds the MMD distance as a regularizer to the standard adversarially fair learning approach (which includes a cross entropy loss term and an adversarially fair loss term for in-distribution fairness). The paper performs ablation studies for the hyper parameter used in the RBF used to compute MMD. | SP:9c57d3125e4ccdb69c7ce9cbaf907520e1957af3 |
Pseudo-Labeled Auto-Curriculum Learning for Semi-Supervised Keypoint Localization | 1 INTRODUCTION . Keypoints ( also termed as landmarks ) are a popular representation of objects that precisely represent locations of object parts and contain concise information about shapes and poses . Example keypoints are ” right shoulder ” on a human body or the ” tail tip ” of a cat . Keypoint localization is the basis of many visual tasks , including action recognition ( Yan et al. , 2018 ) , face recognition ( Bulat & Tzimiropoulos , 2017 ) , fine-grained classification ( Gavves et al. , 2013 ; 2015 ) and reidentification ( Zhao et al. , 2017 ; Miao et al. , 2019 ) . Keypoint localization has achieved great success with the advent of deep learning in recent years . However , the success of deep networks relies on vast amounts of labeled data , which is often expensive and time-consuming to collect . Semi-supervised learning ( SSL ) is one of the most important approaches for solving this problem . It leverages extensive amounts of unlabeled data in addition to sparsely labeled data to obtain gains in performance . Pseudo-labeling ( PL ) has become one of the most popular SSL approaches due to its simplicity . PL-based methods iteratively add unlabeled samples into the training data by pseudo-labeling them with a model trained on a combination of labeled and pseudo-labeled samples . PL-based methods commonly require a predefined handpicked threshold ( Lee et al. , 2013 ; Oliver et al. , 2018 ) , to filter out low-confidence noisy predictions . However , a single fixed threshold does not take into account the dynamic capacity of the current model for handling noisy pseudo-labels , leading to sub-optimal performance . In this work , we borrow ideas from Curriculum Learning ( CL ) ( Bengio et al. , 2009 ) and design our curriculum as a series of thresholds for PL , which is tuned according to the feedback from the model . CL is a widely used strategy to control the model training pace by selecting from easier to harder samples . With a carefully designed curriculum , noticeable improvement is obtained . However , traditional CL methods suffer from hand-designed curricula , which heavily rely on expertise and detailed analysis for specific domains . Manual curriculum design based on handcrafted criteria is always tedious and sub-optimal . Moreover , curriculum design ( or threshold setting ) is complicated . High-confidence pseudo-labels typically correspond to easier samples with clean labels , while low-confidence pseudo-labels correspond to harder samples with noisy labels . How to design a curriculum to balance the correctness , representativeness , and difficulty of pseudo-labeled data is an open problem . This paper is devoted to tackling the aforementioned problem , i.e . how to automatically learn an optimal learning curriculum for pseudo-labeling in a data-driven way . To this end , we propose a novel method , called PseudoLabeled Auto-Curriculum Learning ( PLACL ) . PLACL formulates the curriculum design problem as a decision-making problem and leverages the reinforcement learning ( RL ) framework to solve it . Additionally , PL-based methods suffer from confirmation bias ( Tarvainen & Valpola , 2017 ) , also known as noise accumulation ( Zhang et al. , 2016 ) , and concept drift ( Cascante-Bonilla et al. , 2021 ) . This long-standing issue stems from the use of noisy or incorrect pseudo-labels in subsequent training stages . As a consequence , the noise accumulates and the performance degrades as the learning process evolves over time . To mitigate this problem , we propose the cross-training strategy which alternatively performs pseudo-label prediction and model training on separate sub-datasets . We benchmark PLACL on six keypoint localization datasets , including LSPET ( Johnson & Everingham , 2011 ) , MPII ( Andriluka et al. , 2014 ) , CUB-200-2011 ( Welinder et al. , 2010 ) , ATRW ( Li et al. , 2019b ) , MS-COCO Lin et al . ( 2014 ) , and AnimalPose ( Cao et al. , 2019 ) . We empirically show that PLACL is general and can be applied to various keypoint localization tasks ( human and animal pose estimation ) and different keypoint localization networks . With a simple yet effective search paradigm , our method significantly boosts the keypoint estimation performance and achieves superior performance to other SSL methods . We hope our method will inspire the community to rethink the potential of PL-based methods for semi-supervised keypoint localization . Our main contributions can be summarized as follows : • We propose Pseudo-Labeled Auto-Curriculum Learning ( PLACL ) . It is an an automatic pseudo-labeled data selection method , which learns a series of dynamic thresholds ( or curriculum ) via reinforcement learning . To the best of our knowledge , this is the first work that explores automatic curriculum learning for semi-supervised keypoint localization . • We propose the cross-training strategy for pseudo-labeling to mitigate the long-standing problem of confirmation bias . • Extensive experiments on a wide range of popular datasets demonstrate the superiority of PLACL over the previous state-of-the-art SSL approaches . In addition , PLACL is modelagnostic and can be easily applied to different keypoint localization networks . 2 RELATED WORKS . 2.1 SEMI-SUPERVISED KEYPOINT LOCALIZATION . Keypoint localization focuses on predicting the keypoints of detected objects , e.g . human body parts ( Lin et al. , 2014 ; Jin et al. , 2020 ) , facial landmarks ( Bulat & Tzimiropoulos , 2017 ) , hand keypoints ( Zimmermann & Brox , 2017 ) and animal poses ( Li & Lee , 2021 ; Cao et al. , 2019 ) . However , training a keypoint localization model often requires a large amount of data , which is expensive and time-consuming to collect . Semi-supervised keypoint localization is one of the most promising ways to solve this problem . Semi-supervised keypoint localization can be categorized into consistency regularization based methods and pseudo-labeling based methods . Consistency regularization methods ( Honari et al. , 2018 ; Moskvyak et al. , 2020 ) assume that the output of the model should not be invariant to realistic perturbations . These approaches typically rely on modality-specific augmentation techniques for regularization . Pseudo-labeling methods ( Ukita & Uematsu , 2018 ; Dong & Yang , 2019 ; Cao et al. , 2019 ; Li & Lee , 2021 ) use labeled data to predict the labels of the unlabeled data , and then train the model in a supervised way with a combination of labeled and selected pseudo-labeled data . Our approach also builds upon pseudo-labeling methods . In contrast to previous works , we propose to learn pseudo-labeled data selection via reinforcement learning . 2.2 CURRICULUM LEARNING . Curriculum learning is firstly introduced by Bengio et al . ( 2009 ) . It is a training strategy that trains machine learning models from easy to complex samples , imitating human education . The curriculum is often pre-determined by heuristics ( Khan et al. , 2011 ; Bengio et al. , 2009 ; Spitkovsky et al. , 2009 ) . However , it requires expert domain knowledge and exhaustive trials to find a good curriculum suitable for a specific task and its dataset . Recently , automatic curriculum learning methods are introduced to break through these limits . Popular ones include self-paced learning methods ( Kumar et al. , 2010 ; Jiang et al. , 2014 ; Zhao et al. , 2015 ) and reinforcement learning ( RL ) based methods ( Graves et al. , 2017 ; Matiisen et al. , 2019 ; Fan et al. , 2018 ) . Our approach can be categorized as RL-based methods . Unlike previous works that mainly focus on supervised learning , our approach is specially designed for the SSL paradigm . Our work is mostly related to Curriculum Labeling ( Cascante-Bonilla et al. , 2021 ) . It adopts a hand-crafted curriculum based on Extreme Value Theory ( EVT ) to facilitate model training . In contrast , we propose an automatic curriculum learning approach by searching for dynamic thresholds for pseudo-labeling . In addition , the curriculum of ( Cascante-Bonilla et al. , 2021 ) is coarse-grained on the round level , while our curriculum is fine-grained on the epoch level . 2.3 REINFORCEMENT LEARNING FOR AUTOML . Reinforcement learning ( RL ) has shown impressive results in a range of applications . Well-known examples include game playing ( Mnih et al. , 2015 ; Silver et al. , 2016 ; 2017 ) and robotics control ( Schulman et al. , 2015 ; Lillicrap et al. , 2016 ) . Recent works have employed RL to the AutoML , automating the design of a machine learning system , e.g . searching for neural architectures ( Zoph & Le , 2017 ; Zoph et al. , 2018 ; Baker et al. , 2017 ; Pham et al. , 2018 ) , augmentation policies ( Cubuk et al. , 2019 ) , activation functions ( Ramachandran et al. , 2017 ) , loss functions ( Li et al. , 2019a ; 2021 ) , and training hyperparameters ( Dong et al. , 2020 ) . In contrast to these works , we apply RL to the automatic selection of pseudo-labeled data in the context of pseudo-labeling . 3 PSEUDO-LABELED AUTO-CURRICULUM LEARNING ( PLACL ) . 3.1 OVERVIEW . Our PLACL algorithm is illustrated in Fig . 1 . The training process consists ofR self-training rounds and each round consists of N training epochs . ( 0 ) In the initial round ( r = 0 ) , we pre-train a keypoint localization network Θ0ω on the labeled data , where ω denotes the weights of the network . And for the r-th round , ( 1 ) The trained network Θrω is used to predict pseudo-labels for unlabeled data . ( 2 ) We adopt reinforcement learning ( RL ) to automatically generate the learning curriculum . Specifically , our curriculum ( Γr ) consists of a series of thresholds for pseudo-labeled data selection . Γr = [ γr1 , . . . , γ r N ] , where γ r i ∈ [ 0 , 1 ] is the threshold for each epoch i . ( 3 ) We then select reliable pseudo-labeled data by the searched curriculum . ( 4 ) We retrain a new model ( Θr+1ω ) using both the labeled samples and selected pseudo-labeled samples . ( 5 ) This process is repeated for R rounds . 3.2 PSEUDO-LABEL SELECTION FOR SEMI-SUPERVISED KEYPOINT LOCALIZATION . We denote the labeled dataset with Nl samples as Dl = { ( I li , Y l i ) ∣∣Nl i=1 } , where Ii and Yi denote the i-th training image and its keypoint annotations ( the x-y coordinates of K keypoints ) . The Nu unlabeled images are denoted as Du = { ( Iui ) | Nu i=1 } , which are not associated with any ground-truth keypoint labels . Generally , we have |Nl| |Nu| . Pseudo-labeling based method builds upon the general idea of self-training ( McLachlan , 1975 ) , where the keypoint localization network Θω goes through multiple rounds of training . In the initialization round , the model is first trained with the small labeled training set Dtrain = Dl in a usual supervised manner . In subsequent rounds , the trained model is used to estimate labels for the unla- beled data D̃u = { ( Iui , Ỹ u i ) ∣∣∣Nu i=1 } . Here , we omit the superscript r for simplicity . Specifically , given an unlabeled image Iui , the trained keypoint localization network Θω predicts K heatmaps . Each heatmap is a 2D Gaussian centered on the joint location , which represents the confidence of the k-th keypoint . The output pseudo-labeled keypoint location ( Ỹ ui ) is the highest response in the heatmap space . And the confidence score C ( Θω ( Iui ) ) is the response value at the keypoint location . Then , pseudo-label selection process is adopted . Let g = [ g1 , ... , gNu ] ⊆ { 0 , 1 } Nu be a binary vector representing the selection of pseudo-labels , where gi denotes whether the keypoint prediction on Iui is selected . gi = { 1 , if C ( Θω ( Iui ) ) > γ 0 , otherwise ( 1 ) where γ ∈ ( 0 , 1 ) is the confidence threshold . Pseudo-labeled samples with higher confidence are added to the training set . Dtrain = { ( I li , Y l i ) ∣∣Nl i=1 } ∪ { ( Iui , Ỹ u i ) ∣∣∣Nu i=1 where gi = 1 } . ( 2 ) Then the keypoint localization network is retrained with a combination of labeled and pseudolabeled training data Dtrain . | 1. This paper introduces Curriculum Learning to semi-supervised keypoint localization, which is an automatic pseudo-labeled data selection method. The method uses reinforcement learning to learns a series of dynamic thresholds. 2. Besides, this paper proposes the cross-training strategy for pseudo-labeling to alleviate confirmation bias. 3. The experiments shows that the proposed method can effectively improve the performance in different dataset and surpass other semi-supervised methods. | SP:b21c3f2a54ad5f18eedde82abd5aa77a083b778e |
Pseudo-Labeled Auto-Curriculum Learning for Semi-Supervised Keypoint Localization | 1 INTRODUCTION . Keypoints ( also termed as landmarks ) are a popular representation of objects that precisely represent locations of object parts and contain concise information about shapes and poses . Example keypoints are ” right shoulder ” on a human body or the ” tail tip ” of a cat . Keypoint localization is the basis of many visual tasks , including action recognition ( Yan et al. , 2018 ) , face recognition ( Bulat & Tzimiropoulos , 2017 ) , fine-grained classification ( Gavves et al. , 2013 ; 2015 ) and reidentification ( Zhao et al. , 2017 ; Miao et al. , 2019 ) . Keypoint localization has achieved great success with the advent of deep learning in recent years . However , the success of deep networks relies on vast amounts of labeled data , which is often expensive and time-consuming to collect . Semi-supervised learning ( SSL ) is one of the most important approaches for solving this problem . It leverages extensive amounts of unlabeled data in addition to sparsely labeled data to obtain gains in performance . Pseudo-labeling ( PL ) has become one of the most popular SSL approaches due to its simplicity . PL-based methods iteratively add unlabeled samples into the training data by pseudo-labeling them with a model trained on a combination of labeled and pseudo-labeled samples . PL-based methods commonly require a predefined handpicked threshold ( Lee et al. , 2013 ; Oliver et al. , 2018 ) , to filter out low-confidence noisy predictions . However , a single fixed threshold does not take into account the dynamic capacity of the current model for handling noisy pseudo-labels , leading to sub-optimal performance . In this work , we borrow ideas from Curriculum Learning ( CL ) ( Bengio et al. , 2009 ) and design our curriculum as a series of thresholds for PL , which is tuned according to the feedback from the model . CL is a widely used strategy to control the model training pace by selecting from easier to harder samples . With a carefully designed curriculum , noticeable improvement is obtained . However , traditional CL methods suffer from hand-designed curricula , which heavily rely on expertise and detailed analysis for specific domains . Manual curriculum design based on handcrafted criteria is always tedious and sub-optimal . Moreover , curriculum design ( or threshold setting ) is complicated . High-confidence pseudo-labels typically correspond to easier samples with clean labels , while low-confidence pseudo-labels correspond to harder samples with noisy labels . How to design a curriculum to balance the correctness , representativeness , and difficulty of pseudo-labeled data is an open problem . This paper is devoted to tackling the aforementioned problem , i.e . how to automatically learn an optimal learning curriculum for pseudo-labeling in a data-driven way . To this end , we propose a novel method , called PseudoLabeled Auto-Curriculum Learning ( PLACL ) . PLACL formulates the curriculum design problem as a decision-making problem and leverages the reinforcement learning ( RL ) framework to solve it . Additionally , PL-based methods suffer from confirmation bias ( Tarvainen & Valpola , 2017 ) , also known as noise accumulation ( Zhang et al. , 2016 ) , and concept drift ( Cascante-Bonilla et al. , 2021 ) . This long-standing issue stems from the use of noisy or incorrect pseudo-labels in subsequent training stages . As a consequence , the noise accumulates and the performance degrades as the learning process evolves over time . To mitigate this problem , we propose the cross-training strategy which alternatively performs pseudo-label prediction and model training on separate sub-datasets . We benchmark PLACL on six keypoint localization datasets , including LSPET ( Johnson & Everingham , 2011 ) , MPII ( Andriluka et al. , 2014 ) , CUB-200-2011 ( Welinder et al. , 2010 ) , ATRW ( Li et al. , 2019b ) , MS-COCO Lin et al . ( 2014 ) , and AnimalPose ( Cao et al. , 2019 ) . We empirically show that PLACL is general and can be applied to various keypoint localization tasks ( human and animal pose estimation ) and different keypoint localization networks . With a simple yet effective search paradigm , our method significantly boosts the keypoint estimation performance and achieves superior performance to other SSL methods . We hope our method will inspire the community to rethink the potential of PL-based methods for semi-supervised keypoint localization . Our main contributions can be summarized as follows : • We propose Pseudo-Labeled Auto-Curriculum Learning ( PLACL ) . It is an an automatic pseudo-labeled data selection method , which learns a series of dynamic thresholds ( or curriculum ) via reinforcement learning . To the best of our knowledge , this is the first work that explores automatic curriculum learning for semi-supervised keypoint localization . • We propose the cross-training strategy for pseudo-labeling to mitigate the long-standing problem of confirmation bias . • Extensive experiments on a wide range of popular datasets demonstrate the superiority of PLACL over the previous state-of-the-art SSL approaches . In addition , PLACL is modelagnostic and can be easily applied to different keypoint localization networks . 2 RELATED WORKS . 2.1 SEMI-SUPERVISED KEYPOINT LOCALIZATION . Keypoint localization focuses on predicting the keypoints of detected objects , e.g . human body parts ( Lin et al. , 2014 ; Jin et al. , 2020 ) , facial landmarks ( Bulat & Tzimiropoulos , 2017 ) , hand keypoints ( Zimmermann & Brox , 2017 ) and animal poses ( Li & Lee , 2021 ; Cao et al. , 2019 ) . However , training a keypoint localization model often requires a large amount of data , which is expensive and time-consuming to collect . Semi-supervised keypoint localization is one of the most promising ways to solve this problem . Semi-supervised keypoint localization can be categorized into consistency regularization based methods and pseudo-labeling based methods . Consistency regularization methods ( Honari et al. , 2018 ; Moskvyak et al. , 2020 ) assume that the output of the model should not be invariant to realistic perturbations . These approaches typically rely on modality-specific augmentation techniques for regularization . Pseudo-labeling methods ( Ukita & Uematsu , 2018 ; Dong & Yang , 2019 ; Cao et al. , 2019 ; Li & Lee , 2021 ) use labeled data to predict the labels of the unlabeled data , and then train the model in a supervised way with a combination of labeled and selected pseudo-labeled data . Our approach also builds upon pseudo-labeling methods . In contrast to previous works , we propose to learn pseudo-labeled data selection via reinforcement learning . 2.2 CURRICULUM LEARNING . Curriculum learning is firstly introduced by Bengio et al . ( 2009 ) . It is a training strategy that trains machine learning models from easy to complex samples , imitating human education . The curriculum is often pre-determined by heuristics ( Khan et al. , 2011 ; Bengio et al. , 2009 ; Spitkovsky et al. , 2009 ) . However , it requires expert domain knowledge and exhaustive trials to find a good curriculum suitable for a specific task and its dataset . Recently , automatic curriculum learning methods are introduced to break through these limits . Popular ones include self-paced learning methods ( Kumar et al. , 2010 ; Jiang et al. , 2014 ; Zhao et al. , 2015 ) and reinforcement learning ( RL ) based methods ( Graves et al. , 2017 ; Matiisen et al. , 2019 ; Fan et al. , 2018 ) . Our approach can be categorized as RL-based methods . Unlike previous works that mainly focus on supervised learning , our approach is specially designed for the SSL paradigm . Our work is mostly related to Curriculum Labeling ( Cascante-Bonilla et al. , 2021 ) . It adopts a hand-crafted curriculum based on Extreme Value Theory ( EVT ) to facilitate model training . In contrast , we propose an automatic curriculum learning approach by searching for dynamic thresholds for pseudo-labeling . In addition , the curriculum of ( Cascante-Bonilla et al. , 2021 ) is coarse-grained on the round level , while our curriculum is fine-grained on the epoch level . 2.3 REINFORCEMENT LEARNING FOR AUTOML . Reinforcement learning ( RL ) has shown impressive results in a range of applications . Well-known examples include game playing ( Mnih et al. , 2015 ; Silver et al. , 2016 ; 2017 ) and robotics control ( Schulman et al. , 2015 ; Lillicrap et al. , 2016 ) . Recent works have employed RL to the AutoML , automating the design of a machine learning system , e.g . searching for neural architectures ( Zoph & Le , 2017 ; Zoph et al. , 2018 ; Baker et al. , 2017 ; Pham et al. , 2018 ) , augmentation policies ( Cubuk et al. , 2019 ) , activation functions ( Ramachandran et al. , 2017 ) , loss functions ( Li et al. , 2019a ; 2021 ) , and training hyperparameters ( Dong et al. , 2020 ) . In contrast to these works , we apply RL to the automatic selection of pseudo-labeled data in the context of pseudo-labeling . 3 PSEUDO-LABELED AUTO-CURRICULUM LEARNING ( PLACL ) . 3.1 OVERVIEW . Our PLACL algorithm is illustrated in Fig . 1 . The training process consists ofR self-training rounds and each round consists of N training epochs . ( 0 ) In the initial round ( r = 0 ) , we pre-train a keypoint localization network Θ0ω on the labeled data , where ω denotes the weights of the network . And for the r-th round , ( 1 ) The trained network Θrω is used to predict pseudo-labels for unlabeled data . ( 2 ) We adopt reinforcement learning ( RL ) to automatically generate the learning curriculum . Specifically , our curriculum ( Γr ) consists of a series of thresholds for pseudo-labeled data selection . Γr = [ γr1 , . . . , γ r N ] , where γ r i ∈ [ 0 , 1 ] is the threshold for each epoch i . ( 3 ) We then select reliable pseudo-labeled data by the searched curriculum . ( 4 ) We retrain a new model ( Θr+1ω ) using both the labeled samples and selected pseudo-labeled samples . ( 5 ) This process is repeated for R rounds . 3.2 PSEUDO-LABEL SELECTION FOR SEMI-SUPERVISED KEYPOINT LOCALIZATION . We denote the labeled dataset with Nl samples as Dl = { ( I li , Y l i ) ∣∣Nl i=1 } , where Ii and Yi denote the i-th training image and its keypoint annotations ( the x-y coordinates of K keypoints ) . The Nu unlabeled images are denoted as Du = { ( Iui ) | Nu i=1 } , which are not associated with any ground-truth keypoint labels . Generally , we have |Nl| |Nu| . Pseudo-labeling based method builds upon the general idea of self-training ( McLachlan , 1975 ) , where the keypoint localization network Θω goes through multiple rounds of training . In the initialization round , the model is first trained with the small labeled training set Dtrain = Dl in a usual supervised manner . In subsequent rounds , the trained model is used to estimate labels for the unla- beled data D̃u = { ( Iui , Ỹ u i ) ∣∣∣Nu i=1 } . Here , we omit the superscript r for simplicity . Specifically , given an unlabeled image Iui , the trained keypoint localization network Θω predicts K heatmaps . Each heatmap is a 2D Gaussian centered on the joint location , which represents the confidence of the k-th keypoint . The output pseudo-labeled keypoint location ( Ỹ ui ) is the highest response in the heatmap space . And the confidence score C ( Θω ( Iui ) ) is the response value at the keypoint location . Then , pseudo-label selection process is adopted . Let g = [ g1 , ... , gNu ] ⊆ { 0 , 1 } Nu be a binary vector representing the selection of pseudo-labels , where gi denotes whether the keypoint prediction on Iui is selected . gi = { 1 , if C ( Θω ( Iui ) ) > γ 0 , otherwise ( 1 ) where γ ∈ ( 0 , 1 ) is the confidence threshold . Pseudo-labeled samples with higher confidence are added to the training set . Dtrain = { ( I li , Y l i ) ∣∣Nl i=1 } ∪ { ( Iui , Ỹ u i ) ∣∣∣Nu i=1 where gi = 1 } . ( 2 ) Then the keypoint localization network is retrained with a combination of labeled and pseudolabeled training data Dtrain . | A semi-supervised learning method (PLACL) is proposed. This method employs a Pseudo-Labeling (PL) approach. It consists in iteratively (these iterations are called rounds): 1. predicting pseudo-labels to unlabeled data using the current model, 2. training a series of models from scratch using the labeled data and selections of pseudo-labeled data. The pseudo-label selection is performed using a series of thresholds (called curriculum) over the scores output by the model. The authors propose an Auto-Curriculum Learning (ACL) strategy to automatically update the curriculum using a reinforcement learning approach (PPO2). The fact that the curriculum is updated at each round is called "Curriculum Residual Learning". They also employ a cross-training strategy to prevent the issue of confirmation bias. The performances of PLACL are evaluated on a keypoint localization application on 5 different datasets. When the percentage of labeled data is very low (5% or 10%), PLACL outperforms the state of the art semi-supervised learning competitors. | SP:b21c3f2a54ad5f18eedde82abd5aa77a083b778e |
Pseudo-Labeled Auto-Curriculum Learning for Semi-Supervised Keypoint Localization | 1 INTRODUCTION . Keypoints ( also termed as landmarks ) are a popular representation of objects that precisely represent locations of object parts and contain concise information about shapes and poses . Example keypoints are ” right shoulder ” on a human body or the ” tail tip ” of a cat . Keypoint localization is the basis of many visual tasks , including action recognition ( Yan et al. , 2018 ) , face recognition ( Bulat & Tzimiropoulos , 2017 ) , fine-grained classification ( Gavves et al. , 2013 ; 2015 ) and reidentification ( Zhao et al. , 2017 ; Miao et al. , 2019 ) . Keypoint localization has achieved great success with the advent of deep learning in recent years . However , the success of deep networks relies on vast amounts of labeled data , which is often expensive and time-consuming to collect . Semi-supervised learning ( SSL ) is one of the most important approaches for solving this problem . It leverages extensive amounts of unlabeled data in addition to sparsely labeled data to obtain gains in performance . Pseudo-labeling ( PL ) has become one of the most popular SSL approaches due to its simplicity . PL-based methods iteratively add unlabeled samples into the training data by pseudo-labeling them with a model trained on a combination of labeled and pseudo-labeled samples . PL-based methods commonly require a predefined handpicked threshold ( Lee et al. , 2013 ; Oliver et al. , 2018 ) , to filter out low-confidence noisy predictions . However , a single fixed threshold does not take into account the dynamic capacity of the current model for handling noisy pseudo-labels , leading to sub-optimal performance . In this work , we borrow ideas from Curriculum Learning ( CL ) ( Bengio et al. , 2009 ) and design our curriculum as a series of thresholds for PL , which is tuned according to the feedback from the model . CL is a widely used strategy to control the model training pace by selecting from easier to harder samples . With a carefully designed curriculum , noticeable improvement is obtained . However , traditional CL methods suffer from hand-designed curricula , which heavily rely on expertise and detailed analysis for specific domains . Manual curriculum design based on handcrafted criteria is always tedious and sub-optimal . Moreover , curriculum design ( or threshold setting ) is complicated . High-confidence pseudo-labels typically correspond to easier samples with clean labels , while low-confidence pseudo-labels correspond to harder samples with noisy labels . How to design a curriculum to balance the correctness , representativeness , and difficulty of pseudo-labeled data is an open problem . This paper is devoted to tackling the aforementioned problem , i.e . how to automatically learn an optimal learning curriculum for pseudo-labeling in a data-driven way . To this end , we propose a novel method , called PseudoLabeled Auto-Curriculum Learning ( PLACL ) . PLACL formulates the curriculum design problem as a decision-making problem and leverages the reinforcement learning ( RL ) framework to solve it . Additionally , PL-based methods suffer from confirmation bias ( Tarvainen & Valpola , 2017 ) , also known as noise accumulation ( Zhang et al. , 2016 ) , and concept drift ( Cascante-Bonilla et al. , 2021 ) . This long-standing issue stems from the use of noisy or incorrect pseudo-labels in subsequent training stages . As a consequence , the noise accumulates and the performance degrades as the learning process evolves over time . To mitigate this problem , we propose the cross-training strategy which alternatively performs pseudo-label prediction and model training on separate sub-datasets . We benchmark PLACL on six keypoint localization datasets , including LSPET ( Johnson & Everingham , 2011 ) , MPII ( Andriluka et al. , 2014 ) , CUB-200-2011 ( Welinder et al. , 2010 ) , ATRW ( Li et al. , 2019b ) , MS-COCO Lin et al . ( 2014 ) , and AnimalPose ( Cao et al. , 2019 ) . We empirically show that PLACL is general and can be applied to various keypoint localization tasks ( human and animal pose estimation ) and different keypoint localization networks . With a simple yet effective search paradigm , our method significantly boosts the keypoint estimation performance and achieves superior performance to other SSL methods . We hope our method will inspire the community to rethink the potential of PL-based methods for semi-supervised keypoint localization . Our main contributions can be summarized as follows : • We propose Pseudo-Labeled Auto-Curriculum Learning ( PLACL ) . It is an an automatic pseudo-labeled data selection method , which learns a series of dynamic thresholds ( or curriculum ) via reinforcement learning . To the best of our knowledge , this is the first work that explores automatic curriculum learning for semi-supervised keypoint localization . • We propose the cross-training strategy for pseudo-labeling to mitigate the long-standing problem of confirmation bias . • Extensive experiments on a wide range of popular datasets demonstrate the superiority of PLACL over the previous state-of-the-art SSL approaches . In addition , PLACL is modelagnostic and can be easily applied to different keypoint localization networks . 2 RELATED WORKS . 2.1 SEMI-SUPERVISED KEYPOINT LOCALIZATION . Keypoint localization focuses on predicting the keypoints of detected objects , e.g . human body parts ( Lin et al. , 2014 ; Jin et al. , 2020 ) , facial landmarks ( Bulat & Tzimiropoulos , 2017 ) , hand keypoints ( Zimmermann & Brox , 2017 ) and animal poses ( Li & Lee , 2021 ; Cao et al. , 2019 ) . However , training a keypoint localization model often requires a large amount of data , which is expensive and time-consuming to collect . Semi-supervised keypoint localization is one of the most promising ways to solve this problem . Semi-supervised keypoint localization can be categorized into consistency regularization based methods and pseudo-labeling based methods . Consistency regularization methods ( Honari et al. , 2018 ; Moskvyak et al. , 2020 ) assume that the output of the model should not be invariant to realistic perturbations . These approaches typically rely on modality-specific augmentation techniques for regularization . Pseudo-labeling methods ( Ukita & Uematsu , 2018 ; Dong & Yang , 2019 ; Cao et al. , 2019 ; Li & Lee , 2021 ) use labeled data to predict the labels of the unlabeled data , and then train the model in a supervised way with a combination of labeled and selected pseudo-labeled data . Our approach also builds upon pseudo-labeling methods . In contrast to previous works , we propose to learn pseudo-labeled data selection via reinforcement learning . 2.2 CURRICULUM LEARNING . Curriculum learning is firstly introduced by Bengio et al . ( 2009 ) . It is a training strategy that trains machine learning models from easy to complex samples , imitating human education . The curriculum is often pre-determined by heuristics ( Khan et al. , 2011 ; Bengio et al. , 2009 ; Spitkovsky et al. , 2009 ) . However , it requires expert domain knowledge and exhaustive trials to find a good curriculum suitable for a specific task and its dataset . Recently , automatic curriculum learning methods are introduced to break through these limits . Popular ones include self-paced learning methods ( Kumar et al. , 2010 ; Jiang et al. , 2014 ; Zhao et al. , 2015 ) and reinforcement learning ( RL ) based methods ( Graves et al. , 2017 ; Matiisen et al. , 2019 ; Fan et al. , 2018 ) . Our approach can be categorized as RL-based methods . Unlike previous works that mainly focus on supervised learning , our approach is specially designed for the SSL paradigm . Our work is mostly related to Curriculum Labeling ( Cascante-Bonilla et al. , 2021 ) . It adopts a hand-crafted curriculum based on Extreme Value Theory ( EVT ) to facilitate model training . In contrast , we propose an automatic curriculum learning approach by searching for dynamic thresholds for pseudo-labeling . In addition , the curriculum of ( Cascante-Bonilla et al. , 2021 ) is coarse-grained on the round level , while our curriculum is fine-grained on the epoch level . 2.3 REINFORCEMENT LEARNING FOR AUTOML . Reinforcement learning ( RL ) has shown impressive results in a range of applications . Well-known examples include game playing ( Mnih et al. , 2015 ; Silver et al. , 2016 ; 2017 ) and robotics control ( Schulman et al. , 2015 ; Lillicrap et al. , 2016 ) . Recent works have employed RL to the AutoML , automating the design of a machine learning system , e.g . searching for neural architectures ( Zoph & Le , 2017 ; Zoph et al. , 2018 ; Baker et al. , 2017 ; Pham et al. , 2018 ) , augmentation policies ( Cubuk et al. , 2019 ) , activation functions ( Ramachandran et al. , 2017 ) , loss functions ( Li et al. , 2019a ; 2021 ) , and training hyperparameters ( Dong et al. , 2020 ) . In contrast to these works , we apply RL to the automatic selection of pseudo-labeled data in the context of pseudo-labeling . 3 PSEUDO-LABELED AUTO-CURRICULUM LEARNING ( PLACL ) . 3.1 OVERVIEW . Our PLACL algorithm is illustrated in Fig . 1 . The training process consists ofR self-training rounds and each round consists of N training epochs . ( 0 ) In the initial round ( r = 0 ) , we pre-train a keypoint localization network Θ0ω on the labeled data , where ω denotes the weights of the network . And for the r-th round , ( 1 ) The trained network Θrω is used to predict pseudo-labels for unlabeled data . ( 2 ) We adopt reinforcement learning ( RL ) to automatically generate the learning curriculum . Specifically , our curriculum ( Γr ) consists of a series of thresholds for pseudo-labeled data selection . Γr = [ γr1 , . . . , γ r N ] , where γ r i ∈ [ 0 , 1 ] is the threshold for each epoch i . ( 3 ) We then select reliable pseudo-labeled data by the searched curriculum . ( 4 ) We retrain a new model ( Θr+1ω ) using both the labeled samples and selected pseudo-labeled samples . ( 5 ) This process is repeated for R rounds . 3.2 PSEUDO-LABEL SELECTION FOR SEMI-SUPERVISED KEYPOINT LOCALIZATION . We denote the labeled dataset with Nl samples as Dl = { ( I li , Y l i ) ∣∣Nl i=1 } , where Ii and Yi denote the i-th training image and its keypoint annotations ( the x-y coordinates of K keypoints ) . The Nu unlabeled images are denoted as Du = { ( Iui ) | Nu i=1 } , which are not associated with any ground-truth keypoint labels . Generally , we have |Nl| |Nu| . Pseudo-labeling based method builds upon the general idea of self-training ( McLachlan , 1975 ) , where the keypoint localization network Θω goes through multiple rounds of training . In the initialization round , the model is first trained with the small labeled training set Dtrain = Dl in a usual supervised manner . In subsequent rounds , the trained model is used to estimate labels for the unla- beled data D̃u = { ( Iui , Ỹ u i ) ∣∣∣Nu i=1 } . Here , we omit the superscript r for simplicity . Specifically , given an unlabeled image Iui , the trained keypoint localization network Θω predicts K heatmaps . Each heatmap is a 2D Gaussian centered on the joint location , which represents the confidence of the k-th keypoint . The output pseudo-labeled keypoint location ( Ỹ ui ) is the highest response in the heatmap space . And the confidence score C ( Θω ( Iui ) ) is the response value at the keypoint location . Then , pseudo-label selection process is adopted . Let g = [ g1 , ... , gNu ] ⊆ { 0 , 1 } Nu be a binary vector representing the selection of pseudo-labels , where gi denotes whether the keypoint prediction on Iui is selected . gi = { 1 , if C ( Θω ( Iui ) ) > γ 0 , otherwise ( 1 ) where γ ∈ ( 0 , 1 ) is the confidence threshold . Pseudo-labeled samples with higher confidence are added to the training set . Dtrain = { ( I li , Y l i ) ∣∣Nl i=1 } ∪ { ( Iui , Ỹ u i ) ∣∣∣Nu i=1 where gi = 1 } . ( 2 ) Then the keypoint localization network is retrained with a combination of labeled and pseudolabeled training data Dtrain . | The paper introduces a method for semi-supervised keypoint localization based on pseudo-labeling with auto-curriculum learning. The Auto-curriculum learning approach learns a series of dynamic thresholds for automatic selection of high-quality pseudo-labeled examples for model retraining. The reinforcement learning (RL) framework, more specifically, the proximal policy optimization algorithm, is used to search for the optimal curriculum. The method is evaluated on four benchmarks in keypoint localization. | SP:b21c3f2a54ad5f18eedde82abd5aa77a083b778e |
Tessellated 2D Convolution Networks: A Robust Defence against Adversarial Attacks | 1 INTRODUCTION . Deep neural networks are known to be susceptible to adversarial attacks . Image representations learned by a deep neural network differ from their visual interpretation . Attackers exploit this fact by introducing imperceptible evasive perturbation in a set of test images such that the victim network misclassifies them ( Joseph et al. , 2019 ) . Defending neural networks against such adversarial attacks is of significant theoretical and practical importance . Major approaches to defence against such adversarial threats include adversarial training ( Madry et al. , 2018 ) , network distillation ( Papernot et al. , 2016 ) , input randomization ( Xie et al. , 2018 ) , activation pruning ( Dhillon et al. , 2018 ) , gradient masking ( Goodfellow , 2018 ) , input transformation ( AprilPyone & Kiya , 2020 ) , and ensemble methods ( Tramèr et al. , 2017 ) to name a few . Architectural changes in the network topology is a promising means of achieving adversarial robustness . Well known evasive attacks include the gradient based input perturbation strategies such as fast gradient sign method ( FGSM ) ( Goodfellow et al. , 2015 ) , and the projected gradient descent ( PGD ) ( Madry et al. , 2018 ) methodologies . Universal attacks that are image-agnostic and add the same perturbation for all input images while still modifying the class labels are also prevalent ( MoosaviDezfooli et al. , 2017 ) . Norm based attacks seeking to optimize the perturbation were subsequently proposed to victimize newer defence strategies ( Carlini & Wagner , 2017 ; Croce & Hein , 2019 ) . Patch attacks , which involve perturbing image segments rather than the image pixels , have also been attempted Sharif et al . ( 2016 ) . More recent attacking approaches include the use of ensemblingbased strategies with a capability to adapt on the defence mechanisms employed ( Tramèr et al. , 2020 ) . Depending on the amount of information exposed to an attacker , an attack corresponds to one of the two types , namely i ) black-box attack , those with little or no knowledge about the target model , and ii ) white-box attack , where additional information about the network is available ( e.g. , in the form of architecture , optimization function used , model parameters etc. ) . A black-box attack often involves substituting the victim network by a proxy network , constructed with the help of a small number of interactions with an oracle ( Papernot et al. , 2016 ) . In between the two extremes of the black-box and white-box variants lies the gray-box attack , where the parameter values of a trained model are not available to an attacker ; however , other information about the model ( e.g. , architecture details and optimization/activation functions ) are available ( Vivek et al. , 2018 ) . It has been reported that attacks methods can usually be effectively transferred to similar networks in a gray-box threat scenario . Numerous other threat scenarios like transfer-based , score-based , and decision-based black-box attacks are known in the literature ( Ren et al. , 2020 ; Dong et al. , 2020 ) . As newer attacks are being developed , designing networks that are robust to adversarial attacks has been an ongoing game . Among the most popular defence mechanisms are the ones that are based on adversarial training using the samples generated by attacks such as FGSM Goodfellow et al . ( 2015 ) and PGD Madry et al . ( 2018 ) or their ensemble ( Tramèr et al. , 2017 ) . State-of-the-art defences as reported in the RobustBench ( Croce et al. , 2020 ) benchmark dataset include those based on data augmentation for adversarial training ( Rebuffi et al. , 2021 ) , as well as those that are based on transformation or randomization of model parameters ( Gowal et al. , 2021 ) . Various randomized image transformation schemes such as cropping , padding , compression , block segmentation , noise addition to convolution layer features demonstrate adversarial robustness ( Xie et al. , 2017 ; Liu et al. , 2018 ; AprilPyone & Kiya , 2020 ) . Input rectification schemes attempts to remove adversarial perturbations by denoising , image blurring and depth reduction Xu et al . ( 2017 ) . Transformation of the features at the output of the convolution layers like activation pruning ( Goodfellow , 2018 ) , denoising , are often equally effective Dhillon et al . ( 2018 ) ; Liao et al . ( 2018 ) . Regularization and dropout are recently being used for achieving adversarial robustness ( Wang et al. , 2018 ; B.S . & Babu , 2020 ; Jordão & Pedrini , 2021 ) . A study on the effect of regularization and sparsity with respect to the adversarial robustness of a network can be found in ( Schwartz et al. , 2020 ; Pang et al. , 2020 ) . Generating diverse structured networks as a tool for robustness has been proposed in ( Du et al. , 2021 ; Pang et al. , 2019 ) . An alternative convolutional network ( CNN ) architecture which randomly masks parts of the feature maps also demonstrates adversarial robustness ( Luo et al. , 2020 ) . Architectural robustness provides an attractive defense mechanism that is agnostic to attack strategies . As a motivation of the work in this paper , we hypothesize that modification of the network structure leading to implicit feature transformation , cropping , masking , and distillation may result in improved robustness against adversarial attacks in an attacking method agnostic manner . Incorporation of diversity in network topology may also act as an effective defence against ensemble attacks . Consequently , reconfiguring the topology of a network may provide effective defence against adaptive adversarial attacks . In this paper , we propose two dimensional tessellated convolutional networks ( TCNN ) that incorporates the effects of cropping , masking and feature transformation within a single framework . In our approach , an input image is partitioned into blocks ( tiles ) according to a tessellation ( tiling ) pattern . Each region of the input image makes use of a separate branch in the computation graph to propagate its effects forward in the form of feature representations . The individual feature representations then interact with each other for the eventual prediction of an image class ( see Figure 1 for a schematic representation ) . We investigate the use of three types of rectangular tessellation patterns , namely , regular grid tiling , tiling with non-uniform rectangles , and Mondrian partitioning ( Roy et al. , 2008 ) with a set of additional constraints on the rectangles . Existing research has applied Mondrian kernels for generating features Balog et al . ( 2016 ) , and has also generalized Mondrian partitions for higher than 2 dimensions LeFevre et al . ( 2006 ) . Specifically , constraints in Mondrian tiling correspond to the following . • The rectangular tiles are pairwise non-congruent , i.e. , each rectangle must have a different dimension ( widths and height values ) , e.g. , a 2x8 rectangle can only be used only once . Note that this constraint does not prevent the use of another rectangle with a different dimension but identical , e.g. , a 4x4 rectangle can be used in combination with a 2x8 one . • The difference in the area of the largest and the smallest tiles is to be minimized . This difference is known as the score of the tiling . While the first constraint ensures that there exist no parts in the overall computational graph with duplicate dimensions , the second one prevents solutions that employ too large or too small image regions . The implication of the former is that it is difficult for an adversarial attack to expose a vulnerable sub-network more than once ( thus increasing the overall vulnerability ) , while the implication of the latter is that the individual feature representations of the tiles adequately represent meaningful parts of the overall image . In our experiments , we find that 2D tessellated convolutional networks ( 2D-TCNNs ) are more robust to well known attacks as compared to standard networks . Moreover , among the three different tiling approaches explored , a Mondrian tiling based 2D-TCNN leads to more robust results against adversarial attacks . 2 TESSELLATED CONVOLUTIONAL NETWORK . In this section , we describe our proposed method of Tessellated Convolutional Network ( TCNN ) . We specifically focus on the 2D convolutional networks . Figure 1 presents the idea of a TCNN . An input image is first partitioned into non-overlapping rectangular tiles using a tessellation scheme . Parallel branches of convolution and pooling layers of the tiled CNN then process each input segment . The convolution and pooling layers in each branch terminates in a dense layer of parameters leading to a feature representation of a part of the overall image corresponding to that tile . The output from these dense layers , each representing an abstract representation of a rectangular region of an image , are then concatenated in the merge layer and processed through yet another dense layer . The output layer is a softmax that is finally used to predict the discrete class label . We use three tessellation schemes , namely , regular ( or uniform ) , non-regular ( or non-uniform ) , and Mondrian . Details of these partitions are presented next . The main focus of our paper is investigate if the divide-and-conquer based approach of a tessellated network can lead to more robust defences against adversarial threats . For simplicity , we thus restrict our investigation to simple 2D convolution networks , instead of experimenting with more complex ( in terms of depth and width ) networks , e.g . ImageNet ( Szegedy et al. , 2015 ) or networks that use more involved connections between layers , e.g . the ResNet ( He et al. , 2016 ) . However , our proposed divide-and-conquer based approach is generic enough to be applied on more complex computation graphs such as those of ImageNet or ResNet , which we leave as future work . 2.1 TESSELLATION METHODS . A tessellation of an d× d square image is a complete tiling of the image with non-overlapping tiles . Although the concept of tessellation can , in general , involve ( even non-convex ) polygons , the tiles , with which we cover an input image always refers to rectangles in the context of our problem . A parameter to the tessellation process is the number of mutually disjoint rectangles used . Formally , each input x ∈ Rd×d is partitioned into k sub-instances xi such that ∪ixi = x . To uniquely specify a tessellation of an input instance x ∈ Rd×d , each tile xi ∈ Rhi×wi of width wi and height hi is associated with a location , as specified by the row and column index of its top-left location , i.e. , p ( xi ) = ( ri , ci ) such that 1 ≤ ri ≤ d− hi and 1 ≤ ci ≤ d− wi . Each tiling method , that we investigate , generates a list of such rectangular tiles . 2.1.1 REGULAR TESSELLATION . The simplest tessellation that we investigate is the uniform one , where each tile is a square . The parameter k for regular rectangular tessellation controls the number of squares used to cover x ∈ Rd×d , and is a perfect square , i.e. , k = m2 for some m ∈ Z . 2.1.2 APERIODIC TESSELLATION . In non-uniform tessellation , an input image of size d× d is split into rectangular blocks of arbitrary sizes with a low likelihood that any two rectangles will be of equal area . We employ a recursive split and merge approach to generate a non-uniform tessellation . At each step we employ either a split or a merge operation depending on whether m ( the present number of tiles ) is higher than or lower than k ( the desired number of tiles ) . If m < l , we randomly select a rectangle and split it into two parts . The position of the splitting line and its direction ( horizontal or vertical ) is chosen randomly . The split operation always leads to increasing the total number of tiles by 1 ( see Figure 2b for an illustrative example ) . Otherwise , if m > l , we merge a rectangle with other rectangles that are adjacent to it with respect to a direction ( one of top , right , bottom or left ) . Figure 2c illustrates an example of merging a tile with the ones that are right-adjacent to it . The merge operation mostly leads to increasing the number of tiles . We carry out a sequence of random split and merge operations on randomly selected tiles ( sampled with uniform probability ) unless the desired number of tiles ( the parameter k ) is reached . After every split or merge operation , we employ a post-hoc step which checks if any of the tiles is too small or too large ( specifically , area less than 52 or greater than ( 3/4d ) 2 ) . If the split or merge operation generates a rectangle whose area is either less than or higher than the two thresholds , then the step is undone . It is also possible to generate non-uniform tessellations with other policies as well , e.g. , with the use of Bayesian non-parametric space partition methods as surveyed in ( Fan et al. , 2021 ) . | This paper presents a tessellated convolution network that is more robust to adversarial attacks. In the paper, authors proposed three different ways of tiling. Experiments show this method is more robust to FGSM and PGD for classification tasks on fashion MNIST and CIFAR10. | SP:3c18b1a15a861d6e00e5f582029ef2f6836e0d0f |
Tessellated 2D Convolution Networks: A Robust Defence against Adversarial Attacks | 1 INTRODUCTION . Deep neural networks are known to be susceptible to adversarial attacks . Image representations learned by a deep neural network differ from their visual interpretation . Attackers exploit this fact by introducing imperceptible evasive perturbation in a set of test images such that the victim network misclassifies them ( Joseph et al. , 2019 ) . Defending neural networks against such adversarial attacks is of significant theoretical and practical importance . Major approaches to defence against such adversarial threats include adversarial training ( Madry et al. , 2018 ) , network distillation ( Papernot et al. , 2016 ) , input randomization ( Xie et al. , 2018 ) , activation pruning ( Dhillon et al. , 2018 ) , gradient masking ( Goodfellow , 2018 ) , input transformation ( AprilPyone & Kiya , 2020 ) , and ensemble methods ( Tramèr et al. , 2017 ) to name a few . Architectural changes in the network topology is a promising means of achieving adversarial robustness . Well known evasive attacks include the gradient based input perturbation strategies such as fast gradient sign method ( FGSM ) ( Goodfellow et al. , 2015 ) , and the projected gradient descent ( PGD ) ( Madry et al. , 2018 ) methodologies . Universal attacks that are image-agnostic and add the same perturbation for all input images while still modifying the class labels are also prevalent ( MoosaviDezfooli et al. , 2017 ) . Norm based attacks seeking to optimize the perturbation were subsequently proposed to victimize newer defence strategies ( Carlini & Wagner , 2017 ; Croce & Hein , 2019 ) . Patch attacks , which involve perturbing image segments rather than the image pixels , have also been attempted Sharif et al . ( 2016 ) . More recent attacking approaches include the use of ensemblingbased strategies with a capability to adapt on the defence mechanisms employed ( Tramèr et al. , 2020 ) . Depending on the amount of information exposed to an attacker , an attack corresponds to one of the two types , namely i ) black-box attack , those with little or no knowledge about the target model , and ii ) white-box attack , where additional information about the network is available ( e.g. , in the form of architecture , optimization function used , model parameters etc. ) . A black-box attack often involves substituting the victim network by a proxy network , constructed with the help of a small number of interactions with an oracle ( Papernot et al. , 2016 ) . In between the two extremes of the black-box and white-box variants lies the gray-box attack , where the parameter values of a trained model are not available to an attacker ; however , other information about the model ( e.g. , architecture details and optimization/activation functions ) are available ( Vivek et al. , 2018 ) . It has been reported that attacks methods can usually be effectively transferred to similar networks in a gray-box threat scenario . Numerous other threat scenarios like transfer-based , score-based , and decision-based black-box attacks are known in the literature ( Ren et al. , 2020 ; Dong et al. , 2020 ) . As newer attacks are being developed , designing networks that are robust to adversarial attacks has been an ongoing game . Among the most popular defence mechanisms are the ones that are based on adversarial training using the samples generated by attacks such as FGSM Goodfellow et al . ( 2015 ) and PGD Madry et al . ( 2018 ) or their ensemble ( Tramèr et al. , 2017 ) . State-of-the-art defences as reported in the RobustBench ( Croce et al. , 2020 ) benchmark dataset include those based on data augmentation for adversarial training ( Rebuffi et al. , 2021 ) , as well as those that are based on transformation or randomization of model parameters ( Gowal et al. , 2021 ) . Various randomized image transformation schemes such as cropping , padding , compression , block segmentation , noise addition to convolution layer features demonstrate adversarial robustness ( Xie et al. , 2017 ; Liu et al. , 2018 ; AprilPyone & Kiya , 2020 ) . Input rectification schemes attempts to remove adversarial perturbations by denoising , image blurring and depth reduction Xu et al . ( 2017 ) . Transformation of the features at the output of the convolution layers like activation pruning ( Goodfellow , 2018 ) , denoising , are often equally effective Dhillon et al . ( 2018 ) ; Liao et al . ( 2018 ) . Regularization and dropout are recently being used for achieving adversarial robustness ( Wang et al. , 2018 ; B.S . & Babu , 2020 ; Jordão & Pedrini , 2021 ) . A study on the effect of regularization and sparsity with respect to the adversarial robustness of a network can be found in ( Schwartz et al. , 2020 ; Pang et al. , 2020 ) . Generating diverse structured networks as a tool for robustness has been proposed in ( Du et al. , 2021 ; Pang et al. , 2019 ) . An alternative convolutional network ( CNN ) architecture which randomly masks parts of the feature maps also demonstrates adversarial robustness ( Luo et al. , 2020 ) . Architectural robustness provides an attractive defense mechanism that is agnostic to attack strategies . As a motivation of the work in this paper , we hypothesize that modification of the network structure leading to implicit feature transformation , cropping , masking , and distillation may result in improved robustness against adversarial attacks in an attacking method agnostic manner . Incorporation of diversity in network topology may also act as an effective defence against ensemble attacks . Consequently , reconfiguring the topology of a network may provide effective defence against adaptive adversarial attacks . In this paper , we propose two dimensional tessellated convolutional networks ( TCNN ) that incorporates the effects of cropping , masking and feature transformation within a single framework . In our approach , an input image is partitioned into blocks ( tiles ) according to a tessellation ( tiling ) pattern . Each region of the input image makes use of a separate branch in the computation graph to propagate its effects forward in the form of feature representations . The individual feature representations then interact with each other for the eventual prediction of an image class ( see Figure 1 for a schematic representation ) . We investigate the use of three types of rectangular tessellation patterns , namely , regular grid tiling , tiling with non-uniform rectangles , and Mondrian partitioning ( Roy et al. , 2008 ) with a set of additional constraints on the rectangles . Existing research has applied Mondrian kernels for generating features Balog et al . ( 2016 ) , and has also generalized Mondrian partitions for higher than 2 dimensions LeFevre et al . ( 2006 ) . Specifically , constraints in Mondrian tiling correspond to the following . • The rectangular tiles are pairwise non-congruent , i.e. , each rectangle must have a different dimension ( widths and height values ) , e.g. , a 2x8 rectangle can only be used only once . Note that this constraint does not prevent the use of another rectangle with a different dimension but identical , e.g. , a 4x4 rectangle can be used in combination with a 2x8 one . • The difference in the area of the largest and the smallest tiles is to be minimized . This difference is known as the score of the tiling . While the first constraint ensures that there exist no parts in the overall computational graph with duplicate dimensions , the second one prevents solutions that employ too large or too small image regions . The implication of the former is that it is difficult for an adversarial attack to expose a vulnerable sub-network more than once ( thus increasing the overall vulnerability ) , while the implication of the latter is that the individual feature representations of the tiles adequately represent meaningful parts of the overall image . In our experiments , we find that 2D tessellated convolutional networks ( 2D-TCNNs ) are more robust to well known attacks as compared to standard networks . Moreover , among the three different tiling approaches explored , a Mondrian tiling based 2D-TCNN leads to more robust results against adversarial attacks . 2 TESSELLATED CONVOLUTIONAL NETWORK . In this section , we describe our proposed method of Tessellated Convolutional Network ( TCNN ) . We specifically focus on the 2D convolutional networks . Figure 1 presents the idea of a TCNN . An input image is first partitioned into non-overlapping rectangular tiles using a tessellation scheme . Parallel branches of convolution and pooling layers of the tiled CNN then process each input segment . The convolution and pooling layers in each branch terminates in a dense layer of parameters leading to a feature representation of a part of the overall image corresponding to that tile . The output from these dense layers , each representing an abstract representation of a rectangular region of an image , are then concatenated in the merge layer and processed through yet another dense layer . The output layer is a softmax that is finally used to predict the discrete class label . We use three tessellation schemes , namely , regular ( or uniform ) , non-regular ( or non-uniform ) , and Mondrian . Details of these partitions are presented next . The main focus of our paper is investigate if the divide-and-conquer based approach of a tessellated network can lead to more robust defences against adversarial threats . For simplicity , we thus restrict our investigation to simple 2D convolution networks , instead of experimenting with more complex ( in terms of depth and width ) networks , e.g . ImageNet ( Szegedy et al. , 2015 ) or networks that use more involved connections between layers , e.g . the ResNet ( He et al. , 2016 ) . However , our proposed divide-and-conquer based approach is generic enough to be applied on more complex computation graphs such as those of ImageNet or ResNet , which we leave as future work . 2.1 TESSELLATION METHODS . A tessellation of an d× d square image is a complete tiling of the image with non-overlapping tiles . Although the concept of tessellation can , in general , involve ( even non-convex ) polygons , the tiles , with which we cover an input image always refers to rectangles in the context of our problem . A parameter to the tessellation process is the number of mutually disjoint rectangles used . Formally , each input x ∈ Rd×d is partitioned into k sub-instances xi such that ∪ixi = x . To uniquely specify a tessellation of an input instance x ∈ Rd×d , each tile xi ∈ Rhi×wi of width wi and height hi is associated with a location , as specified by the row and column index of its top-left location , i.e. , p ( xi ) = ( ri , ci ) such that 1 ≤ ri ≤ d− hi and 1 ≤ ci ≤ d− wi . Each tiling method , that we investigate , generates a list of such rectangular tiles . 2.1.1 REGULAR TESSELLATION . The simplest tessellation that we investigate is the uniform one , where each tile is a square . The parameter k for regular rectangular tessellation controls the number of squares used to cover x ∈ Rd×d , and is a perfect square , i.e. , k = m2 for some m ∈ Z . 2.1.2 APERIODIC TESSELLATION . In non-uniform tessellation , an input image of size d× d is split into rectangular blocks of arbitrary sizes with a low likelihood that any two rectangles will be of equal area . We employ a recursive split and merge approach to generate a non-uniform tessellation . At each step we employ either a split or a merge operation depending on whether m ( the present number of tiles ) is higher than or lower than k ( the desired number of tiles ) . If m < l , we randomly select a rectangle and split it into two parts . The position of the splitting line and its direction ( horizontal or vertical ) is chosen randomly . The split operation always leads to increasing the total number of tiles by 1 ( see Figure 2b for an illustrative example ) . Otherwise , if m > l , we merge a rectangle with other rectangles that are adjacent to it with respect to a direction ( one of top , right , bottom or left ) . Figure 2c illustrates an example of merging a tile with the ones that are right-adjacent to it . The merge operation mostly leads to increasing the number of tiles . We carry out a sequence of random split and merge operations on randomly selected tiles ( sampled with uniform probability ) unless the desired number of tiles ( the parameter k ) is reached . After every split or merge operation , we employ a post-hoc step which checks if any of the tiles is too small or too large ( specifically , area less than 52 or greater than ( 3/4d ) 2 ) . If the split or merge operation generates a rectangle whose area is either less than or higher than the two thresholds , then the step is undone . It is also possible to generate non-uniform tessellations with other policies as well , e.g. , with the use of Bayesian non-parametric space partition methods as surveyed in ( Fan et al. , 2021 ) . | This paper presents a new architecture for image classification neural networks based on various forms of image tessellation. They split the input image up into numerous patches, feed each patch through the 2d convolutional network and then combine the representations of each patch before a final dense classification layer. They show that this architecture results in better 'black box' adversarial robustness. | SP:3c18b1a15a861d6e00e5f582029ef2f6836e0d0f |
Tessellated 2D Convolution Networks: A Robust Defence against Adversarial Attacks | 1 INTRODUCTION . Deep neural networks are known to be susceptible to adversarial attacks . Image representations learned by a deep neural network differ from their visual interpretation . Attackers exploit this fact by introducing imperceptible evasive perturbation in a set of test images such that the victim network misclassifies them ( Joseph et al. , 2019 ) . Defending neural networks against such adversarial attacks is of significant theoretical and practical importance . Major approaches to defence against such adversarial threats include adversarial training ( Madry et al. , 2018 ) , network distillation ( Papernot et al. , 2016 ) , input randomization ( Xie et al. , 2018 ) , activation pruning ( Dhillon et al. , 2018 ) , gradient masking ( Goodfellow , 2018 ) , input transformation ( AprilPyone & Kiya , 2020 ) , and ensemble methods ( Tramèr et al. , 2017 ) to name a few . Architectural changes in the network topology is a promising means of achieving adversarial robustness . Well known evasive attacks include the gradient based input perturbation strategies such as fast gradient sign method ( FGSM ) ( Goodfellow et al. , 2015 ) , and the projected gradient descent ( PGD ) ( Madry et al. , 2018 ) methodologies . Universal attacks that are image-agnostic and add the same perturbation for all input images while still modifying the class labels are also prevalent ( MoosaviDezfooli et al. , 2017 ) . Norm based attacks seeking to optimize the perturbation were subsequently proposed to victimize newer defence strategies ( Carlini & Wagner , 2017 ; Croce & Hein , 2019 ) . Patch attacks , which involve perturbing image segments rather than the image pixels , have also been attempted Sharif et al . ( 2016 ) . More recent attacking approaches include the use of ensemblingbased strategies with a capability to adapt on the defence mechanisms employed ( Tramèr et al. , 2020 ) . Depending on the amount of information exposed to an attacker , an attack corresponds to one of the two types , namely i ) black-box attack , those with little or no knowledge about the target model , and ii ) white-box attack , where additional information about the network is available ( e.g. , in the form of architecture , optimization function used , model parameters etc. ) . A black-box attack often involves substituting the victim network by a proxy network , constructed with the help of a small number of interactions with an oracle ( Papernot et al. , 2016 ) . In between the two extremes of the black-box and white-box variants lies the gray-box attack , where the parameter values of a trained model are not available to an attacker ; however , other information about the model ( e.g. , architecture details and optimization/activation functions ) are available ( Vivek et al. , 2018 ) . It has been reported that attacks methods can usually be effectively transferred to similar networks in a gray-box threat scenario . Numerous other threat scenarios like transfer-based , score-based , and decision-based black-box attacks are known in the literature ( Ren et al. , 2020 ; Dong et al. , 2020 ) . As newer attacks are being developed , designing networks that are robust to adversarial attacks has been an ongoing game . Among the most popular defence mechanisms are the ones that are based on adversarial training using the samples generated by attacks such as FGSM Goodfellow et al . ( 2015 ) and PGD Madry et al . ( 2018 ) or their ensemble ( Tramèr et al. , 2017 ) . State-of-the-art defences as reported in the RobustBench ( Croce et al. , 2020 ) benchmark dataset include those based on data augmentation for adversarial training ( Rebuffi et al. , 2021 ) , as well as those that are based on transformation or randomization of model parameters ( Gowal et al. , 2021 ) . Various randomized image transformation schemes such as cropping , padding , compression , block segmentation , noise addition to convolution layer features demonstrate adversarial robustness ( Xie et al. , 2017 ; Liu et al. , 2018 ; AprilPyone & Kiya , 2020 ) . Input rectification schemes attempts to remove adversarial perturbations by denoising , image blurring and depth reduction Xu et al . ( 2017 ) . Transformation of the features at the output of the convolution layers like activation pruning ( Goodfellow , 2018 ) , denoising , are often equally effective Dhillon et al . ( 2018 ) ; Liao et al . ( 2018 ) . Regularization and dropout are recently being used for achieving adversarial robustness ( Wang et al. , 2018 ; B.S . & Babu , 2020 ; Jordão & Pedrini , 2021 ) . A study on the effect of regularization and sparsity with respect to the adversarial robustness of a network can be found in ( Schwartz et al. , 2020 ; Pang et al. , 2020 ) . Generating diverse structured networks as a tool for robustness has been proposed in ( Du et al. , 2021 ; Pang et al. , 2019 ) . An alternative convolutional network ( CNN ) architecture which randomly masks parts of the feature maps also demonstrates adversarial robustness ( Luo et al. , 2020 ) . Architectural robustness provides an attractive defense mechanism that is agnostic to attack strategies . As a motivation of the work in this paper , we hypothesize that modification of the network structure leading to implicit feature transformation , cropping , masking , and distillation may result in improved robustness against adversarial attacks in an attacking method agnostic manner . Incorporation of diversity in network topology may also act as an effective defence against ensemble attacks . Consequently , reconfiguring the topology of a network may provide effective defence against adaptive adversarial attacks . In this paper , we propose two dimensional tessellated convolutional networks ( TCNN ) that incorporates the effects of cropping , masking and feature transformation within a single framework . In our approach , an input image is partitioned into blocks ( tiles ) according to a tessellation ( tiling ) pattern . Each region of the input image makes use of a separate branch in the computation graph to propagate its effects forward in the form of feature representations . The individual feature representations then interact with each other for the eventual prediction of an image class ( see Figure 1 for a schematic representation ) . We investigate the use of three types of rectangular tessellation patterns , namely , regular grid tiling , tiling with non-uniform rectangles , and Mondrian partitioning ( Roy et al. , 2008 ) with a set of additional constraints on the rectangles . Existing research has applied Mondrian kernels for generating features Balog et al . ( 2016 ) , and has also generalized Mondrian partitions for higher than 2 dimensions LeFevre et al . ( 2006 ) . Specifically , constraints in Mondrian tiling correspond to the following . • The rectangular tiles are pairwise non-congruent , i.e. , each rectangle must have a different dimension ( widths and height values ) , e.g. , a 2x8 rectangle can only be used only once . Note that this constraint does not prevent the use of another rectangle with a different dimension but identical , e.g. , a 4x4 rectangle can be used in combination with a 2x8 one . • The difference in the area of the largest and the smallest tiles is to be minimized . This difference is known as the score of the tiling . While the first constraint ensures that there exist no parts in the overall computational graph with duplicate dimensions , the second one prevents solutions that employ too large or too small image regions . The implication of the former is that it is difficult for an adversarial attack to expose a vulnerable sub-network more than once ( thus increasing the overall vulnerability ) , while the implication of the latter is that the individual feature representations of the tiles adequately represent meaningful parts of the overall image . In our experiments , we find that 2D tessellated convolutional networks ( 2D-TCNNs ) are more robust to well known attacks as compared to standard networks . Moreover , among the three different tiling approaches explored , a Mondrian tiling based 2D-TCNN leads to more robust results against adversarial attacks . 2 TESSELLATED CONVOLUTIONAL NETWORK . In this section , we describe our proposed method of Tessellated Convolutional Network ( TCNN ) . We specifically focus on the 2D convolutional networks . Figure 1 presents the idea of a TCNN . An input image is first partitioned into non-overlapping rectangular tiles using a tessellation scheme . Parallel branches of convolution and pooling layers of the tiled CNN then process each input segment . The convolution and pooling layers in each branch terminates in a dense layer of parameters leading to a feature representation of a part of the overall image corresponding to that tile . The output from these dense layers , each representing an abstract representation of a rectangular region of an image , are then concatenated in the merge layer and processed through yet another dense layer . The output layer is a softmax that is finally used to predict the discrete class label . We use three tessellation schemes , namely , regular ( or uniform ) , non-regular ( or non-uniform ) , and Mondrian . Details of these partitions are presented next . The main focus of our paper is investigate if the divide-and-conquer based approach of a tessellated network can lead to more robust defences against adversarial threats . For simplicity , we thus restrict our investigation to simple 2D convolution networks , instead of experimenting with more complex ( in terms of depth and width ) networks , e.g . ImageNet ( Szegedy et al. , 2015 ) or networks that use more involved connections between layers , e.g . the ResNet ( He et al. , 2016 ) . However , our proposed divide-and-conquer based approach is generic enough to be applied on more complex computation graphs such as those of ImageNet or ResNet , which we leave as future work . 2.1 TESSELLATION METHODS . A tessellation of an d× d square image is a complete tiling of the image with non-overlapping tiles . Although the concept of tessellation can , in general , involve ( even non-convex ) polygons , the tiles , with which we cover an input image always refers to rectangles in the context of our problem . A parameter to the tessellation process is the number of mutually disjoint rectangles used . Formally , each input x ∈ Rd×d is partitioned into k sub-instances xi such that ∪ixi = x . To uniquely specify a tessellation of an input instance x ∈ Rd×d , each tile xi ∈ Rhi×wi of width wi and height hi is associated with a location , as specified by the row and column index of its top-left location , i.e. , p ( xi ) = ( ri , ci ) such that 1 ≤ ri ≤ d− hi and 1 ≤ ci ≤ d− wi . Each tiling method , that we investigate , generates a list of such rectangular tiles . 2.1.1 REGULAR TESSELLATION . The simplest tessellation that we investigate is the uniform one , where each tile is a square . The parameter k for regular rectangular tessellation controls the number of squares used to cover x ∈ Rd×d , and is a perfect square , i.e. , k = m2 for some m ∈ Z . 2.1.2 APERIODIC TESSELLATION . In non-uniform tessellation , an input image of size d× d is split into rectangular blocks of arbitrary sizes with a low likelihood that any two rectangles will be of equal area . We employ a recursive split and merge approach to generate a non-uniform tessellation . At each step we employ either a split or a merge operation depending on whether m ( the present number of tiles ) is higher than or lower than k ( the desired number of tiles ) . If m < l , we randomly select a rectangle and split it into two parts . The position of the splitting line and its direction ( horizontal or vertical ) is chosen randomly . The split operation always leads to increasing the total number of tiles by 1 ( see Figure 2b for an illustrative example ) . Otherwise , if m > l , we merge a rectangle with other rectangles that are adjacent to it with respect to a direction ( one of top , right , bottom or left ) . Figure 2c illustrates an example of merging a tile with the ones that are right-adjacent to it . The merge operation mostly leads to increasing the number of tiles . We carry out a sequence of random split and merge operations on randomly selected tiles ( sampled with uniform probability ) unless the desired number of tiles ( the parameter k ) is reached . After every split or merge operation , we employ a post-hoc step which checks if any of the tiles is too small or too large ( specifically , area less than 52 or greater than ( 3/4d ) 2 ) . If the split or merge operation generates a rectangle whose area is either less than or higher than the two thresholds , then the step is undone . It is also possible to generate non-uniform tessellations with other policies as well , e.g. , with the use of Bayesian non-parametric space partition methods as surveyed in ( Fan et al. , 2021 ) . | This paper studies defense against adversarial attacks. In particular, the proposal is to partition the image into non-overlapping sub-rectangles, run a separate CNN on each, and finally merge to generate the prediction. The defense effectiveness is evaluated on MNIST and CIFAR-10. | SP:3c18b1a15a861d6e00e5f582029ef2f6836e0d0f |
Label Augmentation with Reinforced Labeling for Weak Supervision | 1 INTRODUCTION . Supervised machine learning has proven to be very powerful and effective for solving various classification problems . However , training fully-supervised models can be costly since many applications require large amounts of labeled data . Manually annotating each data point of a large dataset may take up to weeks or even months . Furthermore , only domain experts can label the data in highly specialized scenarios such as healthcare and industrial production . Thus , the costs of data labeling might become very high . In the past few years , a new weak supervision ( WS ) approach , namely data programming [ Ratner et al . ( 2016 ; 2017 ) ] , has been proposed to significantly reduce the time for dataset preparation . In this approach , a domain expert writes heuristic functions named labeling functions ( LFs ) instead of labeling each data point . Each function annotates a subset of the dataset with an accuracy expected to be better than a random prediction . Data programming has been successfully applied to various classification tasks . However , writing LFs might not always be trivial , for instance , when data points are huge vectors of numbers or when they are not intuitively understandable . Developers can quickly code a few simple functions , but having heuristics to cover many corner cases is still a burden . Further , simple heuristics might cover only a tiny portion of the unlabeled dataset ( small coverage problem ) . The existing data programming framework Snorkel [ Ratner et al . ( 2016 ; 2017 ) ] implements a machine learning pipeline as follows . The LFs are applied to the unlabeled data points and the outcomes of LFs produce a labeling matrix where each data point might be annotated by multiple , even conflicting , labels . A generative model processes the labeling matrix to make single label predictions for a subset of data points , based on the agreements and disagreements on the LF outputs for a given data point x ( i ) using techniques such as majority voting ( MV ) or minimizing the marginalized log-likelihood estimates . Later , the label predictions are used to train a supervised model that serves as the end classifier ( discriminative model ) . This approach has two major limitations : 1 ) Coarse information about the dataset ( only LF outputs ) fed to the generative model , 2 ) Lack of generalization due to the sparsity of labeling matrix and relying only on end classifier to generalize . The current data programming does not take the data points ’ data features into account during the generative process , even though they are available throughout the pipeline . It utilizes the data features of only the data points with label predictions to train the end classifier . Various additional techniques are considered to complement the existing approach [ Varma & Ré ( 2018 ) ; Chatterjee et al . ( 2020 ) ; Varma et al . ( 2019 ) ; Nashaat et al . ( 2018 ) ; Varma et al . ( 2016 ) ] and improve the learning process . However , these approaches do not address this major problem in the design of existing data programming . This article proposes a label augmentation approach for weak supervision that takes the data features and the LF outputs into account earlier in the generative process . The proposed approach utilizes the features for augmenting labels . The augmentation algorithm , namely reinforcement labeling ( RL ) , checks similarities between data features to project existing LF outcomes to non-existing labels in the matrix ( i.e. , to unknown cases or abstains ) . Moreover , it uses a heuristic that considers unknown cases “ gravitate ” towards the known cases with LF output labels . In such a way , RL enables generalization early on and creates a “ reinforced ” label set to train an end classifier . Label augmentation extends the data programming to new scenarios , such as when LFs have low coverage , domain experts can implement only a limited number of LFs , or LFs outcome result in a sparse labeling matrix . Label augmentation can provide satisfactory performances in these cases , although data programming was previously non-applicable . The proposed approach can reduce the time spent by the domain experts to train a classifier as they need to implement fewer LFs . One advantage compared to the existing complementary approaches is that RL does not require any additional effort for labeling data , annotating data , or implementing additional LFs . In other words , the label augmentation enhances classification without any further development burden or assumption of available labeled datasets ( e.g. , the so-called “ gold data ” ) . Furthermore , one can easily combine this approach with the existing solutions . The RL method is implemented and tested compared to Snorkel ( Sn ) using different fully-supervised models as end classifiers . The experimental results span classification tasks from several domains ( YouTube comments , white/red wine datasets , weather prediction ) . The new approach outperforms the existing model in terms of accuracy and F1 scores , having closer outcomes to the fully-supervised learning , thanks to the improved coverage that enables end classifier convergence . 2 METHOD DESCRIPTION . 2.1 BACKGROUND ON DATA PROGRAMMING . In data programming [ Bach et al . ( 2019 ) ; Ratner et al . ( 2017 ) ] , a set of LFs annotate a portion ( subset ) of the original unlabeled dataset X = { x ( 1 ) , x ( 2 ) , . . . , x ( k ) } with a total labeling coverage of γ ∗ |X| , where γ ∈ [ 0 , 1 ] . Given a data point x ( i ) , an LFj takes x ( i ) as input and annotates the input with a label . LFs are considered weak supervisors implemented by application developers , and they can programmatically annotate many data points at once , as opposed to hand-labeling data points one by one . On the other hand , LFs may have lower accuracies than ground truth for the data points . For a binary classification task , an LF may return two classes or abstain from making a prediction . For simplicity , let us consider LFj returning 1 or 0 as the class labels and -1 ( abstain ) when it refrains from class prediction . LFs ’ outputs form a labeling matrix where rows represent the data point indices x ( 1 ) , x ( 2 ) , . . . , x ( k ) , and columns represent the LF indices LF1 , LF2 , . . . , LFm . A generative model takes the labeling matrix as input , filters out the data points with no label ( all LFs voted for abstains ) , and tries to predict a label for the remaining data points . An example of a generative model might be a majority voter ( MV ) based on LF outputs or by minimizing the negative log marginal likelihood [ Ratner et al . ( 2017 ) ] ( likelihood over latent variables , i.e. , LF outputs ) . Dependency structures between the LFs are learned as shown in Alg . 1 in [ Bach et al . ( 2017 ) ] . In both MV and marginal likelihood approaches , the generative model takes the labeling matrix as input and tries to make a label decision based on the agreements or disagreements of LFs . The generative model may fail to make a decision in certain cases , such as when equal numbers of LFs disagree on a data point . Lastly , the features of the weakly-labeled data points within X and the labels from the generative model are used to supervise an end classifier ( discriminative ) model . The design of the data programming model is agnostic to the end classifier ( discriminative ) model , so various supervised machine learning models can be candidates as the end model . 2.2 LABEL AUGMENTATION AND REINFORCED LABELS . In the described design of data programming , the two limitations mentioned above ( in Sec . 1 ) , namely the coarse information in the labeling matrix and sparsity , lead to failure for generalizing to new and unseen data points . Therefore , these limitations may lead to reduced performances . In such scenarios , the outputs of the existing generative model may not be satisfactory to train the end classifier . Therefore , the end classifier model may not converge or generalize well enough to cover different cases . Implementing many LFs that cover different cases is costly and not very straightforward in most scenarios . Although various additional techniques focus on the weak supervision problem [ Varma & Ré ( 2018 ) ; Chatterjee et al . ( 2020 ) ; Varma et al . ( 2019 ) ; Nashaat et al . ( 2018 ) ; Varma et al . ( 2016 ) ] , they rather extend the existing pipeline with additional features . On the other hand , label augmentation targets these major limitations by eliminating the sparsity using data features . Thus , it can lead to higher accuracy . Fig . 1 illustrates the new pipeline for label augmentation . The new generative process brings together the outputs of 〈LF1 , LF2 , . . . , LFm〉 , and the data features f1 , f2 . . . , fn of data points x ( i ) = { x ( i ) 1 , x ( i ) 2 , . . . , x ( i ) n } in the unlabeled dataset early on . Different methods can utilize data features in the generative process for augmenting the labels in the labeling matrix . This label augmentation approach differs from the existing “ data augmentation ” approaches [ Wang et al . ( 2019 ) ; Tran et al . ( 2017 ) ; Cubuk et al . ( 2019 ) ] that create new ( synthetic ) data points , as the new goal is to project LF outcomes to the existing data points as opposed to creating new data points . The outcome of the new generative process can be more representative of the data and weak supervisors than the outputs of the previously existing generative process due to additional coverage and accuracy gains without any additional LF implementation or data annotation . For instance , abstain values ( -1s ) from the LFs ’ outputs representing the unknown cases ( left side of the matrix in Fig . 1 ) can be predicted by the new generative process ( as outlined in Sec . 2.3 ) . The abstain values in the labeling matrix can be augmented with classification prediction values . Data programming applies statistics only to data points that are already covered by LFs , resulting in a single predicted label for a subset of the dataset . Similarly , by using likelihood estimation over the augmented matrix , the generative process predicts “ reinforced labels ” . The details of the generative model implementation can be seen in [ Bach et al . ( 2017 ) ] . After the generative process , the reinforced labels are used to train the end classifier . The end classifier can still be the same supervised machine learning model . As the augmented matrix has more density compared to the labeling matrix , it may lead to a larger training set . As a simple example , a disagreement between two LFs for a data point can be eliminated by a new prediction for the abstain case of a third LF . As a result , more data points can be used to train the end model . The benefits of using the end classifier include further generalization for the data points that are still not labeled . Furthermore , the reinforced labels can fine-tune pretrained machine learning models . | This paper proposes an extension to the data programming / weak supervision method of Ratner et. al. 2016, in which heuristic functions called labeling functions (LF) are used to label training data. In the proposed extension, called "reinforced labeling", points that are close to those labeled by a labeling function in feature space (as determined by a heuristic "gravitation" algorithm) are also labeled, thereby augmenting the set of programmatically labeled examples. | SP:31286fa9f1c0545ae13cc923595c96c909f949a4 |
Label Augmentation with Reinforced Labeling for Weak Supervision | 1 INTRODUCTION . Supervised machine learning has proven to be very powerful and effective for solving various classification problems . However , training fully-supervised models can be costly since many applications require large amounts of labeled data . Manually annotating each data point of a large dataset may take up to weeks or even months . Furthermore , only domain experts can label the data in highly specialized scenarios such as healthcare and industrial production . Thus , the costs of data labeling might become very high . In the past few years , a new weak supervision ( WS ) approach , namely data programming [ Ratner et al . ( 2016 ; 2017 ) ] , has been proposed to significantly reduce the time for dataset preparation . In this approach , a domain expert writes heuristic functions named labeling functions ( LFs ) instead of labeling each data point . Each function annotates a subset of the dataset with an accuracy expected to be better than a random prediction . Data programming has been successfully applied to various classification tasks . However , writing LFs might not always be trivial , for instance , when data points are huge vectors of numbers or when they are not intuitively understandable . Developers can quickly code a few simple functions , but having heuristics to cover many corner cases is still a burden . Further , simple heuristics might cover only a tiny portion of the unlabeled dataset ( small coverage problem ) . The existing data programming framework Snorkel [ Ratner et al . ( 2016 ; 2017 ) ] implements a machine learning pipeline as follows . The LFs are applied to the unlabeled data points and the outcomes of LFs produce a labeling matrix where each data point might be annotated by multiple , even conflicting , labels . A generative model processes the labeling matrix to make single label predictions for a subset of data points , based on the agreements and disagreements on the LF outputs for a given data point x ( i ) using techniques such as majority voting ( MV ) or minimizing the marginalized log-likelihood estimates . Later , the label predictions are used to train a supervised model that serves as the end classifier ( discriminative model ) . This approach has two major limitations : 1 ) Coarse information about the dataset ( only LF outputs ) fed to the generative model , 2 ) Lack of generalization due to the sparsity of labeling matrix and relying only on end classifier to generalize . The current data programming does not take the data points ’ data features into account during the generative process , even though they are available throughout the pipeline . It utilizes the data features of only the data points with label predictions to train the end classifier . Various additional techniques are considered to complement the existing approach [ Varma & Ré ( 2018 ) ; Chatterjee et al . ( 2020 ) ; Varma et al . ( 2019 ) ; Nashaat et al . ( 2018 ) ; Varma et al . ( 2016 ) ] and improve the learning process . However , these approaches do not address this major problem in the design of existing data programming . This article proposes a label augmentation approach for weak supervision that takes the data features and the LF outputs into account earlier in the generative process . The proposed approach utilizes the features for augmenting labels . The augmentation algorithm , namely reinforcement labeling ( RL ) , checks similarities between data features to project existing LF outcomes to non-existing labels in the matrix ( i.e. , to unknown cases or abstains ) . Moreover , it uses a heuristic that considers unknown cases “ gravitate ” towards the known cases with LF output labels . In such a way , RL enables generalization early on and creates a “ reinforced ” label set to train an end classifier . Label augmentation extends the data programming to new scenarios , such as when LFs have low coverage , domain experts can implement only a limited number of LFs , or LFs outcome result in a sparse labeling matrix . Label augmentation can provide satisfactory performances in these cases , although data programming was previously non-applicable . The proposed approach can reduce the time spent by the domain experts to train a classifier as they need to implement fewer LFs . One advantage compared to the existing complementary approaches is that RL does not require any additional effort for labeling data , annotating data , or implementing additional LFs . In other words , the label augmentation enhances classification without any further development burden or assumption of available labeled datasets ( e.g. , the so-called “ gold data ” ) . Furthermore , one can easily combine this approach with the existing solutions . The RL method is implemented and tested compared to Snorkel ( Sn ) using different fully-supervised models as end classifiers . The experimental results span classification tasks from several domains ( YouTube comments , white/red wine datasets , weather prediction ) . The new approach outperforms the existing model in terms of accuracy and F1 scores , having closer outcomes to the fully-supervised learning , thanks to the improved coverage that enables end classifier convergence . 2 METHOD DESCRIPTION . 2.1 BACKGROUND ON DATA PROGRAMMING . In data programming [ Bach et al . ( 2019 ) ; Ratner et al . ( 2017 ) ] , a set of LFs annotate a portion ( subset ) of the original unlabeled dataset X = { x ( 1 ) , x ( 2 ) , . . . , x ( k ) } with a total labeling coverage of γ ∗ |X| , where γ ∈ [ 0 , 1 ] . Given a data point x ( i ) , an LFj takes x ( i ) as input and annotates the input with a label . LFs are considered weak supervisors implemented by application developers , and they can programmatically annotate many data points at once , as opposed to hand-labeling data points one by one . On the other hand , LFs may have lower accuracies than ground truth for the data points . For a binary classification task , an LF may return two classes or abstain from making a prediction . For simplicity , let us consider LFj returning 1 or 0 as the class labels and -1 ( abstain ) when it refrains from class prediction . LFs ’ outputs form a labeling matrix where rows represent the data point indices x ( 1 ) , x ( 2 ) , . . . , x ( k ) , and columns represent the LF indices LF1 , LF2 , . . . , LFm . A generative model takes the labeling matrix as input , filters out the data points with no label ( all LFs voted for abstains ) , and tries to predict a label for the remaining data points . An example of a generative model might be a majority voter ( MV ) based on LF outputs or by minimizing the negative log marginal likelihood [ Ratner et al . ( 2017 ) ] ( likelihood over latent variables , i.e. , LF outputs ) . Dependency structures between the LFs are learned as shown in Alg . 1 in [ Bach et al . ( 2017 ) ] . In both MV and marginal likelihood approaches , the generative model takes the labeling matrix as input and tries to make a label decision based on the agreements or disagreements of LFs . The generative model may fail to make a decision in certain cases , such as when equal numbers of LFs disagree on a data point . Lastly , the features of the weakly-labeled data points within X and the labels from the generative model are used to supervise an end classifier ( discriminative ) model . The design of the data programming model is agnostic to the end classifier ( discriminative ) model , so various supervised machine learning models can be candidates as the end model . 2.2 LABEL AUGMENTATION AND REINFORCED LABELS . In the described design of data programming , the two limitations mentioned above ( in Sec . 1 ) , namely the coarse information in the labeling matrix and sparsity , lead to failure for generalizing to new and unseen data points . Therefore , these limitations may lead to reduced performances . In such scenarios , the outputs of the existing generative model may not be satisfactory to train the end classifier . Therefore , the end classifier model may not converge or generalize well enough to cover different cases . Implementing many LFs that cover different cases is costly and not very straightforward in most scenarios . Although various additional techniques focus on the weak supervision problem [ Varma & Ré ( 2018 ) ; Chatterjee et al . ( 2020 ) ; Varma et al . ( 2019 ) ; Nashaat et al . ( 2018 ) ; Varma et al . ( 2016 ) ] , they rather extend the existing pipeline with additional features . On the other hand , label augmentation targets these major limitations by eliminating the sparsity using data features . Thus , it can lead to higher accuracy . Fig . 1 illustrates the new pipeline for label augmentation . The new generative process brings together the outputs of 〈LF1 , LF2 , . . . , LFm〉 , and the data features f1 , f2 . . . , fn of data points x ( i ) = { x ( i ) 1 , x ( i ) 2 , . . . , x ( i ) n } in the unlabeled dataset early on . Different methods can utilize data features in the generative process for augmenting the labels in the labeling matrix . This label augmentation approach differs from the existing “ data augmentation ” approaches [ Wang et al . ( 2019 ) ; Tran et al . ( 2017 ) ; Cubuk et al . ( 2019 ) ] that create new ( synthetic ) data points , as the new goal is to project LF outcomes to the existing data points as opposed to creating new data points . The outcome of the new generative process can be more representative of the data and weak supervisors than the outputs of the previously existing generative process due to additional coverage and accuracy gains without any additional LF implementation or data annotation . For instance , abstain values ( -1s ) from the LFs ’ outputs representing the unknown cases ( left side of the matrix in Fig . 1 ) can be predicted by the new generative process ( as outlined in Sec . 2.3 ) . The abstain values in the labeling matrix can be augmented with classification prediction values . Data programming applies statistics only to data points that are already covered by LFs , resulting in a single predicted label for a subset of the dataset . Similarly , by using likelihood estimation over the augmented matrix , the generative process predicts “ reinforced labels ” . The details of the generative model implementation can be seen in [ Bach et al . ( 2017 ) ] . After the generative process , the reinforced labels are used to train the end classifier . The end classifier can still be the same supervised machine learning model . As the augmented matrix has more density compared to the labeling matrix , it may lead to a larger training set . As a simple example , a disagreement between two LFs for a data point can be eliminated by a new prediction for the abstain case of a third LF . As a result , more data points can be used to train the end model . The benefits of using the end classifier include further generalization for the data points that are still not labeled . Furthermore , the reinforced labels can fine-tune pretrained machine learning models . | This paper describes a method to improve the coverage of labeling functions in weak supervision. Labeling functions in weak supervision can abstain if they do not vote on a particular point. The method replaces abstentions with a gravitation-based method based on the other points that the labeling function has voted on. The method uses similarities between features of points for the gravitation-based method. The authors claim performance benefits over Snorkel. | SP:31286fa9f1c0545ae13cc923595c96c909f949a4 |
Label Augmentation with Reinforced Labeling for Weak Supervision | 1 INTRODUCTION . Supervised machine learning has proven to be very powerful and effective for solving various classification problems . However , training fully-supervised models can be costly since many applications require large amounts of labeled data . Manually annotating each data point of a large dataset may take up to weeks or even months . Furthermore , only domain experts can label the data in highly specialized scenarios such as healthcare and industrial production . Thus , the costs of data labeling might become very high . In the past few years , a new weak supervision ( WS ) approach , namely data programming [ Ratner et al . ( 2016 ; 2017 ) ] , has been proposed to significantly reduce the time for dataset preparation . In this approach , a domain expert writes heuristic functions named labeling functions ( LFs ) instead of labeling each data point . Each function annotates a subset of the dataset with an accuracy expected to be better than a random prediction . Data programming has been successfully applied to various classification tasks . However , writing LFs might not always be trivial , for instance , when data points are huge vectors of numbers or when they are not intuitively understandable . Developers can quickly code a few simple functions , but having heuristics to cover many corner cases is still a burden . Further , simple heuristics might cover only a tiny portion of the unlabeled dataset ( small coverage problem ) . The existing data programming framework Snorkel [ Ratner et al . ( 2016 ; 2017 ) ] implements a machine learning pipeline as follows . The LFs are applied to the unlabeled data points and the outcomes of LFs produce a labeling matrix where each data point might be annotated by multiple , even conflicting , labels . A generative model processes the labeling matrix to make single label predictions for a subset of data points , based on the agreements and disagreements on the LF outputs for a given data point x ( i ) using techniques such as majority voting ( MV ) or minimizing the marginalized log-likelihood estimates . Later , the label predictions are used to train a supervised model that serves as the end classifier ( discriminative model ) . This approach has two major limitations : 1 ) Coarse information about the dataset ( only LF outputs ) fed to the generative model , 2 ) Lack of generalization due to the sparsity of labeling matrix and relying only on end classifier to generalize . The current data programming does not take the data points ’ data features into account during the generative process , even though they are available throughout the pipeline . It utilizes the data features of only the data points with label predictions to train the end classifier . Various additional techniques are considered to complement the existing approach [ Varma & Ré ( 2018 ) ; Chatterjee et al . ( 2020 ) ; Varma et al . ( 2019 ) ; Nashaat et al . ( 2018 ) ; Varma et al . ( 2016 ) ] and improve the learning process . However , these approaches do not address this major problem in the design of existing data programming . This article proposes a label augmentation approach for weak supervision that takes the data features and the LF outputs into account earlier in the generative process . The proposed approach utilizes the features for augmenting labels . The augmentation algorithm , namely reinforcement labeling ( RL ) , checks similarities between data features to project existing LF outcomes to non-existing labels in the matrix ( i.e. , to unknown cases or abstains ) . Moreover , it uses a heuristic that considers unknown cases “ gravitate ” towards the known cases with LF output labels . In such a way , RL enables generalization early on and creates a “ reinforced ” label set to train an end classifier . Label augmentation extends the data programming to new scenarios , such as when LFs have low coverage , domain experts can implement only a limited number of LFs , or LFs outcome result in a sparse labeling matrix . Label augmentation can provide satisfactory performances in these cases , although data programming was previously non-applicable . The proposed approach can reduce the time spent by the domain experts to train a classifier as they need to implement fewer LFs . One advantage compared to the existing complementary approaches is that RL does not require any additional effort for labeling data , annotating data , or implementing additional LFs . In other words , the label augmentation enhances classification without any further development burden or assumption of available labeled datasets ( e.g. , the so-called “ gold data ” ) . Furthermore , one can easily combine this approach with the existing solutions . The RL method is implemented and tested compared to Snorkel ( Sn ) using different fully-supervised models as end classifiers . The experimental results span classification tasks from several domains ( YouTube comments , white/red wine datasets , weather prediction ) . The new approach outperforms the existing model in terms of accuracy and F1 scores , having closer outcomes to the fully-supervised learning , thanks to the improved coverage that enables end classifier convergence . 2 METHOD DESCRIPTION . 2.1 BACKGROUND ON DATA PROGRAMMING . In data programming [ Bach et al . ( 2019 ) ; Ratner et al . ( 2017 ) ] , a set of LFs annotate a portion ( subset ) of the original unlabeled dataset X = { x ( 1 ) , x ( 2 ) , . . . , x ( k ) } with a total labeling coverage of γ ∗ |X| , where γ ∈ [ 0 , 1 ] . Given a data point x ( i ) , an LFj takes x ( i ) as input and annotates the input with a label . LFs are considered weak supervisors implemented by application developers , and they can programmatically annotate many data points at once , as opposed to hand-labeling data points one by one . On the other hand , LFs may have lower accuracies than ground truth for the data points . For a binary classification task , an LF may return two classes or abstain from making a prediction . For simplicity , let us consider LFj returning 1 or 0 as the class labels and -1 ( abstain ) when it refrains from class prediction . LFs ’ outputs form a labeling matrix where rows represent the data point indices x ( 1 ) , x ( 2 ) , . . . , x ( k ) , and columns represent the LF indices LF1 , LF2 , . . . , LFm . A generative model takes the labeling matrix as input , filters out the data points with no label ( all LFs voted for abstains ) , and tries to predict a label for the remaining data points . An example of a generative model might be a majority voter ( MV ) based on LF outputs or by minimizing the negative log marginal likelihood [ Ratner et al . ( 2017 ) ] ( likelihood over latent variables , i.e. , LF outputs ) . Dependency structures between the LFs are learned as shown in Alg . 1 in [ Bach et al . ( 2017 ) ] . In both MV and marginal likelihood approaches , the generative model takes the labeling matrix as input and tries to make a label decision based on the agreements or disagreements of LFs . The generative model may fail to make a decision in certain cases , such as when equal numbers of LFs disagree on a data point . Lastly , the features of the weakly-labeled data points within X and the labels from the generative model are used to supervise an end classifier ( discriminative ) model . The design of the data programming model is agnostic to the end classifier ( discriminative ) model , so various supervised machine learning models can be candidates as the end model . 2.2 LABEL AUGMENTATION AND REINFORCED LABELS . In the described design of data programming , the two limitations mentioned above ( in Sec . 1 ) , namely the coarse information in the labeling matrix and sparsity , lead to failure for generalizing to new and unseen data points . Therefore , these limitations may lead to reduced performances . In such scenarios , the outputs of the existing generative model may not be satisfactory to train the end classifier . Therefore , the end classifier model may not converge or generalize well enough to cover different cases . Implementing many LFs that cover different cases is costly and not very straightforward in most scenarios . Although various additional techniques focus on the weak supervision problem [ Varma & Ré ( 2018 ) ; Chatterjee et al . ( 2020 ) ; Varma et al . ( 2019 ) ; Nashaat et al . ( 2018 ) ; Varma et al . ( 2016 ) ] , they rather extend the existing pipeline with additional features . On the other hand , label augmentation targets these major limitations by eliminating the sparsity using data features . Thus , it can lead to higher accuracy . Fig . 1 illustrates the new pipeline for label augmentation . The new generative process brings together the outputs of 〈LF1 , LF2 , . . . , LFm〉 , and the data features f1 , f2 . . . , fn of data points x ( i ) = { x ( i ) 1 , x ( i ) 2 , . . . , x ( i ) n } in the unlabeled dataset early on . Different methods can utilize data features in the generative process for augmenting the labels in the labeling matrix . This label augmentation approach differs from the existing “ data augmentation ” approaches [ Wang et al . ( 2019 ) ; Tran et al . ( 2017 ) ; Cubuk et al . ( 2019 ) ] that create new ( synthetic ) data points , as the new goal is to project LF outcomes to the existing data points as opposed to creating new data points . The outcome of the new generative process can be more representative of the data and weak supervisors than the outputs of the previously existing generative process due to additional coverage and accuracy gains without any additional LF implementation or data annotation . For instance , abstain values ( -1s ) from the LFs ’ outputs representing the unknown cases ( left side of the matrix in Fig . 1 ) can be predicted by the new generative process ( as outlined in Sec . 2.3 ) . The abstain values in the labeling matrix can be augmented with classification prediction values . Data programming applies statistics only to data points that are already covered by LFs , resulting in a single predicted label for a subset of the dataset . Similarly , by using likelihood estimation over the augmented matrix , the generative process predicts “ reinforced labels ” . The details of the generative model implementation can be seen in [ Bach et al . ( 2017 ) ] . After the generative process , the reinforced labels are used to train the end classifier . The end classifier can still be the same supervised machine learning model . As the augmented matrix has more density compared to the labeling matrix , it may lead to a larger training set . As a simple example , a disagreement between two LFs for a data point can be eliminated by a new prediction for the abstain case of a third LF . As a result , more data points can be used to train the end model . The benefits of using the end classifier include further generalization for the data points that are still not labeled . Furthermore , the reinforced labels can fine-tune pretrained machine learning models . | This paper tackles the problem of designing data programming, which is a practical approach in weak supervision. The authors state that prior effects neglect to utilize data features during the generative process, and therefore have suboptimal performance. Based on this, this paper proposes to exploit the sample similarities to augment the outputs of labeling functions. Empirical evaluations are provided to verify the effectiveness of the proposed method. | SP:31286fa9f1c0545ae13cc923595c96c909f949a4 |
Revisiting Locality-Sensitive Binary Codes from Random Fourier Features | 1 INTRODUCTION . Developing efficient machine learning algorithms in large-scale problems has been an important research topic to deal with massive data . In this paper , we focus on efficient retrieval/search methods , specifically , by designing similarity-preserving binary representations of the data . That is , for each data vector x ∈ Rd , we hash it into a length-b binary 0/1 vector h ( x ) ∈ { 0 , 1 } b , where the geometry of the data should be well preserved in the Hamming space . Searching with binary codes has been widely applied in many applications , such as large-scale image retrieval ( Weiss et al. , 2008 ; Gong & Lazebnik , 2011 ; Kulis & Darrell , 2009 ; He et al. , 2013 ; Lin et al. , 2015 ; Liu et al. , 2016 ; 2017 ; Song et al. , 2018 ; Yu et al. , 2018 ; Yan et al. , 2021 ) . The benefits are two-fold . Firstly , it may largely reduce the memory cost for storing massive datasets , especially with high-dimensional data . Secondly , it can significantly speedup the retrieval process . For instance , the binary codes can be used to build hash tables ( e.g. , Indyk & Motwani ( 1998 ) ) for sub-linear time approximate nearest neighbor ( ANN ) search . Moreover , in the Hamming space , we can also apply exhaustive search , which is much faster than computing the Euclidean distances , plus the technique of multi-index hashing ( Norouzi et al. , 2012 ) can further accelerate the exact Hamming search by orders of magnitude . In general , binary hashing methods can be categorized into supervised and unsupervised approaches . In this work , we focus on the unsupervised setting . Locality-Sensitive Hashing ( LSH ) ( Indyk & Motwani , 1998 ) is one of the early hashing methods leading to binary embedding . The LSH targeting at cosine similarity ( Charikar , 2002 ) , also known as SimHash , generates binary hash codes using random hyperplanes by taking the sign of data-independent random Gaussian projections . For the cosine similarity , LSH has strict theoretical guarantee on the approximation error and search efficiency , but typically requires relatively long codes to achieve good performance . Hence , many works have focused on learning data-dependent short binary hash codes , through different objective functions . Examples include Iterative Quantization ( ITQ ) ( Gong & Lazebnik , 2011 ) , Spectral Hashing ( SpecH ) ( Weiss et al. , 2008 ) and Binary Reconstruction Embedding ( BRE ) ( Kulis & Darrell , 2009 ) . Recently , some unsupervised deep learning based methods have been proposed in the computer vision community , many of which are , to some extent , “ task-specific ” for cross-modal/video/image retrieval , implemented based on some deep models like the autoencoder and VGG-16 ( Liu et al. , 2016 ; Do et al. , 2017 ; Chen et al. , 2018 ; Li et al. , 2019 ; Yang et al. , 2019 ; Hansen et al. , 2020 ; Liu et al. , 2020 ; Qiu et al. , 2021 ) . By taking the advantage of the complicated model structures ( e.g. , CNN layers ) , these deep methods show promising performance in many image retrieval tasks . Compared with the data-dependent methods ( including deep methods ) , LSH has three advantages : • Although the data-dependent procedures can provide improved performance with fewer binary codes , a known undesirable effect of many of these mechanisms is the performance degradation when we increase the code length b , as reported in prior literature ( Raginsky & Lazebnik , 2009 ; Joly & Buisson , 2011 ) . In our experiments , we will show that this may also be an issue for deep learning based methods . On the other hand , the performance ( i.e. , search accuracy ) of the data-independent LSH would keep boosting with larger b . In many scenarios , it is often the case that only using short codes ( e.g. , ≤ 128 bits ) can not achieve a desirable level of search accuracy for practical purposes . In these cases , one may need to use longer codes anyway , where LSH could be more favorable . • LSH is very simple to implement ( only with random projections ) , while data-dependent methods require additional optimization/training which might be costly . Moreover , large deep learning models would typically need longer inference time , which might be infeasible in practice where the query speed is important . • It is difficult to characterize the properties of the data-dependent methods theoretically , while LSH enjoys rigorous guarantees on the retrieval/approximation performance . Therefore , LSH is still a popular hashing method with great research interest and many practical applications ( Shrivastava & Li , 2014 ; Qi et al. , 2017 ; Driemel & Silvestri , 2017 ; Chen et al. , 2019 ; Zandieh et al. , 2020 ; Lei et al. , 2020 ; Daghaghi et al. , 2021 ) . 1.1 LOCALITY-SENSITIVE HASHING FROM RANDOM FOURIER FEATURES . Kernel methods have gained great success in many machine learning tasks ( Schölkopf & Smola , 2002 ; Zhu & Hastie , 2001 ; Avron et al. , 2017 ; Sun et al. , 2018 ) . However , standard kernel methods require the n × n kernel matrix , which becomes computationally expensive on large-scale datasets with massive data points . To this end , Rahimi & Recht ( 2007 ) proposes the method of random Fourier feature ( RFF ) , which defines a feature map that approximates shift-invariant kernels by the linear inner products . As such , the RFF preserves the “ non-linear locality structure ” of the data . This leads to numerous applications in large-scale learning where one trains linear models on RFF to approximate training non-linear kernel machines ( Yang et al. , 2012 ; Chwialkowski et al. , 2015 ; Sutherland & Schneider , 2015 ; Avron et al. , 2017 ; Sun et al. , 2018 ; Tompkins & Ramos , 2018 ) . Given the popularity of RFF , one natural step is to apply it to search problems . Raginsky & Lazebnik ( 2009 ) proposes to construct binary codes from the RFF using stochastic binary quantization . We call this method “ SQ-RFF ” , whose convergence ( as b→∞ ) and concentration can be theoretically characterized . The author showed that SQ-RFF can achieve competitive search accuracy with sufficient b , e.g. , b ≥ 512 . Since RFF itself is a widely used tool for large-scale kernel learning , SQ-RFF could be a convenient/useful tool in practical scenarios where RFF has been generated for training kernel machines , and the data scientist wants to further use it for efficient near neighbor retrieval . 1.2 OUR CONTRIBUTIONS . Given the benefits of LSH and RFF , we revisit hashing methods for non-linear kernels , and improve the prior RFF based hashing method . Our approach is named as “ SignRFF ” . Specifically , • We theoretically compare several linear and non-linear LSH methods in terms of a novel measure called the ranking efficiency , which is defined based on the probability of retrieving a wrong/reversed similarity ranking . Under this unified metric , the proposed SignRFF is uniformly better than SQ-RFF . Moreover , the ranking efficiency also indicates that typically one should prefer SignRFF over linear LSH when the near neighbors are close to each other , which is the first systematic comparison of linear vs. non-linear LSH in literature . • Empirically , we conduct near neighbor search experiments on benchmark image datasets to compare the proposed SignRFF with other popular hashing methods , which verifies the superiority of SignRFF over SQ-RFF . We validate that the ranking efficiency metric aligns well with the empirical results . Moreover , SignRFF outperforms various competing methods ( including deep methods ) with moderately large number of hash bits , indicating its advantage in applications to achieve a high search recall/precision . 2 PRELIMINARIES . 2.1 LOCALITY-SENSITIVE HASHING ( LSH ) . In large-scale information retrieval , exhaustive search of the exact nearest neighbors is usually too expensive . A common relaxation in this setting is the Approximate Nearest Neighbor ( ANN ) search , where we return the “ good ” neighbors of a query with high probability . In this paper , we will consider the search problem with data points in Rd . X denotes the database consisting of n data points , and q is a query point . x , y are two data points with ρ = cos ( x , y ) . Definition 2.1 ( S̃-neighbor ) . For a similarity measure S : Rd × Rd 7→ R , the S̃-neighbor set of q is defined as { x ∈X : S ( x , q ) > S̃ } . Definition 2.2 ( ( c , S̃ ) -ANN ) . Assume δ > 0 is a parameter . An algorithm A is a ( c , S̃ ) -ANN method provided the following : with probability at least 1− δ , for 0 < c < 1 , if there exists an S̃-neighbor of q in X , A returns a cS̃-neighbor of q . One popular method satisfying Definition 2.2 is the Locality-Sensitive Hashing ( LSH ) . Definition 2.3 ( Indyk & Motwani ( 1998 ) ) . A family of hash functions H is called ( S̃ , cS̃ , p1 , p2 ) locality-sensitive for similarity measure S and 0 < c < 1 , if for ∀x , y ∈ Rd and hash function h uniformly chosen from H , it holds that : 1 ) If S ( x , y ) ≥ S̃ , then P ( h ( x ) = h ( y ) ) ≥ p1 ; 2 ) If S ( x , y ) ≤ cS̃ , then P ( h ( x ) = h ( y ) ) ≤ p2 , with p2 < p1 . A key intuition of LSH is that , similar data points with have higher chance of hash collision in the Hamming space . In this paper , we will specifically consider the LSH for the cosine similarity ( Charikar , 2002 ) . For a data vector x ∈ Rd , the LSH binary code is given by LSH : hLSH ( x ) = sign ( wTx ) , ( 1 ) where wT is a standard Gaussian random vector . We use b i.i.d . w1 , ... , wb to generate b LSH binary codes . The collision probability between the codes of two data points x , y is P ( hLSH ( x ) = hLSH ( y ) ) = 1− cos−1 ( ρ ) π , ( 2 ) where ρ = cos ( x , y ) is their cosine similarity . Note that P ( hLSH ( x ) = hLSH ( y ) ) is increasing in ρ , which , By Definition 2.3 , is the key to ensure the locality sensitivity . 2.2 KERNELIZED LOCALITY-SENSITIVE HASHING ( KLSH ) . In this paper , we will consider the popular Gaussian kernel function defined for x , y ∈ Rd as k ( x , y ) = exp ( −γ2‖x− y‖2 2 ) , where γ is a hyper-parameter . Let Ψ : Rd 7→ F be the feature map with the kernel induced feature spaceF . To incorporate non-linearity in LSH , Kulis & Grauman ( 2009 ) proposes Kernelized Locality-Sensitive Hashing ( KLSH ) , by applying LSH ( 1 ) in the kernel induced feature space F , i.e. , h ( x ) = sign ( wTΨ ( x ) ) . However , as in many cases ( e.g. , for the Gaussian kernel ) the map Ψ can not be explicitly identified , constructing the random Gaussian projection vector w needs some careful design . KLSH approximates the random Gaussian distribution using a sufficient number of data points , by the Central Limit Theorem ( CLT ) in the Reproducing Kernel Hilbert Space . One first samples m data points from X to form a kernel matrix K , then uniformly picks t points from [ 1 , ... , m ] at random to approximate the Gaussian distribution . The hash code has the form KLSH : hKLSH ( x ) = sign ( m∑ i=1 w ( i ) k ( x , xi ) ) , ( 3 ) where w = K−1/2et , and et ∈ { 0 , 1 } m has ones in the entries with indices of the t selected points . We see that the codes h1 , ... , hb are actually dependent , and the quality of using CLT to approximate Gaussian distribution is not guaranteed , especially in high-dimensional kernel feature space . Jiang et al . ( 2015 ) re-formulates KLSH as applying LSH on the kernel principle components in the kernel induced feature space , resolving a theoretical concern of KLSH . Notably , since KLSH uses a pool of data samples to approximate the Gaussian distribution , the hash codes are in fact dependent in practical implementation . It is observed that the performance of KLSH also drops as b increases ( Joly & Buisson , 2011 ) , similar to the behavior of many data-dependent methods . We provide more detailed explanation in Appendix C . | The paper revisits the binary hashing from Random Fourier Feature (RFF) for approximate nearest neighbor search. The authors propose a simple and effective RFF-based hashing method SignRFF and demonstrate its locality-sensitive property. They also introduce a new measure called ranking efficiency to evaluate the performance of different LSH methods theoretically. Extensive experiments on three real-life image data sets validate the effectiveness of SignRFF and the consistency of the ranking efficiency from theoretical evaluation. | SP:da9d10c667fd1afada0abd335a3eeb15c103ea1f |
Revisiting Locality-Sensitive Binary Codes from Random Fourier Features | 1 INTRODUCTION . Developing efficient machine learning algorithms in large-scale problems has been an important research topic to deal with massive data . In this paper , we focus on efficient retrieval/search methods , specifically , by designing similarity-preserving binary representations of the data . That is , for each data vector x ∈ Rd , we hash it into a length-b binary 0/1 vector h ( x ) ∈ { 0 , 1 } b , where the geometry of the data should be well preserved in the Hamming space . Searching with binary codes has been widely applied in many applications , such as large-scale image retrieval ( Weiss et al. , 2008 ; Gong & Lazebnik , 2011 ; Kulis & Darrell , 2009 ; He et al. , 2013 ; Lin et al. , 2015 ; Liu et al. , 2016 ; 2017 ; Song et al. , 2018 ; Yu et al. , 2018 ; Yan et al. , 2021 ) . The benefits are two-fold . Firstly , it may largely reduce the memory cost for storing massive datasets , especially with high-dimensional data . Secondly , it can significantly speedup the retrieval process . For instance , the binary codes can be used to build hash tables ( e.g. , Indyk & Motwani ( 1998 ) ) for sub-linear time approximate nearest neighbor ( ANN ) search . Moreover , in the Hamming space , we can also apply exhaustive search , which is much faster than computing the Euclidean distances , plus the technique of multi-index hashing ( Norouzi et al. , 2012 ) can further accelerate the exact Hamming search by orders of magnitude . In general , binary hashing methods can be categorized into supervised and unsupervised approaches . In this work , we focus on the unsupervised setting . Locality-Sensitive Hashing ( LSH ) ( Indyk & Motwani , 1998 ) is one of the early hashing methods leading to binary embedding . The LSH targeting at cosine similarity ( Charikar , 2002 ) , also known as SimHash , generates binary hash codes using random hyperplanes by taking the sign of data-independent random Gaussian projections . For the cosine similarity , LSH has strict theoretical guarantee on the approximation error and search efficiency , but typically requires relatively long codes to achieve good performance . Hence , many works have focused on learning data-dependent short binary hash codes , through different objective functions . Examples include Iterative Quantization ( ITQ ) ( Gong & Lazebnik , 2011 ) , Spectral Hashing ( SpecH ) ( Weiss et al. , 2008 ) and Binary Reconstruction Embedding ( BRE ) ( Kulis & Darrell , 2009 ) . Recently , some unsupervised deep learning based methods have been proposed in the computer vision community , many of which are , to some extent , “ task-specific ” for cross-modal/video/image retrieval , implemented based on some deep models like the autoencoder and VGG-16 ( Liu et al. , 2016 ; Do et al. , 2017 ; Chen et al. , 2018 ; Li et al. , 2019 ; Yang et al. , 2019 ; Hansen et al. , 2020 ; Liu et al. , 2020 ; Qiu et al. , 2021 ) . By taking the advantage of the complicated model structures ( e.g. , CNN layers ) , these deep methods show promising performance in many image retrieval tasks . Compared with the data-dependent methods ( including deep methods ) , LSH has three advantages : • Although the data-dependent procedures can provide improved performance with fewer binary codes , a known undesirable effect of many of these mechanisms is the performance degradation when we increase the code length b , as reported in prior literature ( Raginsky & Lazebnik , 2009 ; Joly & Buisson , 2011 ) . In our experiments , we will show that this may also be an issue for deep learning based methods . On the other hand , the performance ( i.e. , search accuracy ) of the data-independent LSH would keep boosting with larger b . In many scenarios , it is often the case that only using short codes ( e.g. , ≤ 128 bits ) can not achieve a desirable level of search accuracy for practical purposes . In these cases , one may need to use longer codes anyway , where LSH could be more favorable . • LSH is very simple to implement ( only with random projections ) , while data-dependent methods require additional optimization/training which might be costly . Moreover , large deep learning models would typically need longer inference time , which might be infeasible in practice where the query speed is important . • It is difficult to characterize the properties of the data-dependent methods theoretically , while LSH enjoys rigorous guarantees on the retrieval/approximation performance . Therefore , LSH is still a popular hashing method with great research interest and many practical applications ( Shrivastava & Li , 2014 ; Qi et al. , 2017 ; Driemel & Silvestri , 2017 ; Chen et al. , 2019 ; Zandieh et al. , 2020 ; Lei et al. , 2020 ; Daghaghi et al. , 2021 ) . 1.1 LOCALITY-SENSITIVE HASHING FROM RANDOM FOURIER FEATURES . Kernel methods have gained great success in many machine learning tasks ( Schölkopf & Smola , 2002 ; Zhu & Hastie , 2001 ; Avron et al. , 2017 ; Sun et al. , 2018 ) . However , standard kernel methods require the n × n kernel matrix , which becomes computationally expensive on large-scale datasets with massive data points . To this end , Rahimi & Recht ( 2007 ) proposes the method of random Fourier feature ( RFF ) , which defines a feature map that approximates shift-invariant kernels by the linear inner products . As such , the RFF preserves the “ non-linear locality structure ” of the data . This leads to numerous applications in large-scale learning where one trains linear models on RFF to approximate training non-linear kernel machines ( Yang et al. , 2012 ; Chwialkowski et al. , 2015 ; Sutherland & Schneider , 2015 ; Avron et al. , 2017 ; Sun et al. , 2018 ; Tompkins & Ramos , 2018 ) . Given the popularity of RFF , one natural step is to apply it to search problems . Raginsky & Lazebnik ( 2009 ) proposes to construct binary codes from the RFF using stochastic binary quantization . We call this method “ SQ-RFF ” , whose convergence ( as b→∞ ) and concentration can be theoretically characterized . The author showed that SQ-RFF can achieve competitive search accuracy with sufficient b , e.g. , b ≥ 512 . Since RFF itself is a widely used tool for large-scale kernel learning , SQ-RFF could be a convenient/useful tool in practical scenarios where RFF has been generated for training kernel machines , and the data scientist wants to further use it for efficient near neighbor retrieval . 1.2 OUR CONTRIBUTIONS . Given the benefits of LSH and RFF , we revisit hashing methods for non-linear kernels , and improve the prior RFF based hashing method . Our approach is named as “ SignRFF ” . Specifically , • We theoretically compare several linear and non-linear LSH methods in terms of a novel measure called the ranking efficiency , which is defined based on the probability of retrieving a wrong/reversed similarity ranking . Under this unified metric , the proposed SignRFF is uniformly better than SQ-RFF . Moreover , the ranking efficiency also indicates that typically one should prefer SignRFF over linear LSH when the near neighbors are close to each other , which is the first systematic comparison of linear vs. non-linear LSH in literature . • Empirically , we conduct near neighbor search experiments on benchmark image datasets to compare the proposed SignRFF with other popular hashing methods , which verifies the superiority of SignRFF over SQ-RFF . We validate that the ranking efficiency metric aligns well with the empirical results . Moreover , SignRFF outperforms various competing methods ( including deep methods ) with moderately large number of hash bits , indicating its advantage in applications to achieve a high search recall/precision . 2 PRELIMINARIES . 2.1 LOCALITY-SENSITIVE HASHING ( LSH ) . In large-scale information retrieval , exhaustive search of the exact nearest neighbors is usually too expensive . A common relaxation in this setting is the Approximate Nearest Neighbor ( ANN ) search , where we return the “ good ” neighbors of a query with high probability . In this paper , we will consider the search problem with data points in Rd . X denotes the database consisting of n data points , and q is a query point . x , y are two data points with ρ = cos ( x , y ) . Definition 2.1 ( S̃-neighbor ) . For a similarity measure S : Rd × Rd 7→ R , the S̃-neighbor set of q is defined as { x ∈X : S ( x , q ) > S̃ } . Definition 2.2 ( ( c , S̃ ) -ANN ) . Assume δ > 0 is a parameter . An algorithm A is a ( c , S̃ ) -ANN method provided the following : with probability at least 1− δ , for 0 < c < 1 , if there exists an S̃-neighbor of q in X , A returns a cS̃-neighbor of q . One popular method satisfying Definition 2.2 is the Locality-Sensitive Hashing ( LSH ) . Definition 2.3 ( Indyk & Motwani ( 1998 ) ) . A family of hash functions H is called ( S̃ , cS̃ , p1 , p2 ) locality-sensitive for similarity measure S and 0 < c < 1 , if for ∀x , y ∈ Rd and hash function h uniformly chosen from H , it holds that : 1 ) If S ( x , y ) ≥ S̃ , then P ( h ( x ) = h ( y ) ) ≥ p1 ; 2 ) If S ( x , y ) ≤ cS̃ , then P ( h ( x ) = h ( y ) ) ≤ p2 , with p2 < p1 . A key intuition of LSH is that , similar data points with have higher chance of hash collision in the Hamming space . In this paper , we will specifically consider the LSH for the cosine similarity ( Charikar , 2002 ) . For a data vector x ∈ Rd , the LSH binary code is given by LSH : hLSH ( x ) = sign ( wTx ) , ( 1 ) where wT is a standard Gaussian random vector . We use b i.i.d . w1 , ... , wb to generate b LSH binary codes . The collision probability between the codes of two data points x , y is P ( hLSH ( x ) = hLSH ( y ) ) = 1− cos−1 ( ρ ) π , ( 2 ) where ρ = cos ( x , y ) is their cosine similarity . Note that P ( hLSH ( x ) = hLSH ( y ) ) is increasing in ρ , which , By Definition 2.3 , is the key to ensure the locality sensitivity . 2.2 KERNELIZED LOCALITY-SENSITIVE HASHING ( KLSH ) . In this paper , we will consider the popular Gaussian kernel function defined for x , y ∈ Rd as k ( x , y ) = exp ( −γ2‖x− y‖2 2 ) , where γ is a hyper-parameter . Let Ψ : Rd 7→ F be the feature map with the kernel induced feature spaceF . To incorporate non-linearity in LSH , Kulis & Grauman ( 2009 ) proposes Kernelized Locality-Sensitive Hashing ( KLSH ) , by applying LSH ( 1 ) in the kernel induced feature space F , i.e. , h ( x ) = sign ( wTΨ ( x ) ) . However , as in many cases ( e.g. , for the Gaussian kernel ) the map Ψ can not be explicitly identified , constructing the random Gaussian projection vector w needs some careful design . KLSH approximates the random Gaussian distribution using a sufficient number of data points , by the Central Limit Theorem ( CLT ) in the Reproducing Kernel Hilbert Space . One first samples m data points from X to form a kernel matrix K , then uniformly picks t points from [ 1 , ... , m ] at random to approximate the Gaussian distribution . The hash code has the form KLSH : hKLSH ( x ) = sign ( m∑ i=1 w ( i ) k ( x , xi ) ) , ( 3 ) where w = K−1/2et , and et ∈ { 0 , 1 } m has ones in the entries with indices of the t selected points . We see that the codes h1 , ... , hb are actually dependent , and the quality of using CLT to approximate Gaussian distribution is not guaranteed , especially in high-dimensional kernel feature space . Jiang et al . ( 2015 ) re-formulates KLSH as applying LSH on the kernel principle components in the kernel induced feature space , resolving a theoretical concern of KLSH . Notably , since KLSH uses a pool of data samples to approximate the Gaussian distribution , the hash codes are in fact dependent in practical implementation . It is observed that the performance of KLSH also drops as b increases ( Joly & Buisson , 2011 ) , similar to the behavior of many data-dependent methods . We provide more detailed explanation in Appendix C . | This paper proposed an improved version of Random Fourier Feature (RFF) based binary feature coding method as well as a new measure(ranking efficiency) to compare different Locality-Sensitive Hashing (LSH) methods. Under the new measure, the proposed method is better than previous methods. The authors also validated by visualization the consistency between theoretical comparisons based the proposed measure and the empirical results. | SP:da9d10c667fd1afada0abd335a3eeb15c103ea1f |
Revisiting Locality-Sensitive Binary Codes from Random Fourier Features | 1 INTRODUCTION . Developing efficient machine learning algorithms in large-scale problems has been an important research topic to deal with massive data . In this paper , we focus on efficient retrieval/search methods , specifically , by designing similarity-preserving binary representations of the data . That is , for each data vector x ∈ Rd , we hash it into a length-b binary 0/1 vector h ( x ) ∈ { 0 , 1 } b , where the geometry of the data should be well preserved in the Hamming space . Searching with binary codes has been widely applied in many applications , such as large-scale image retrieval ( Weiss et al. , 2008 ; Gong & Lazebnik , 2011 ; Kulis & Darrell , 2009 ; He et al. , 2013 ; Lin et al. , 2015 ; Liu et al. , 2016 ; 2017 ; Song et al. , 2018 ; Yu et al. , 2018 ; Yan et al. , 2021 ) . The benefits are two-fold . Firstly , it may largely reduce the memory cost for storing massive datasets , especially with high-dimensional data . Secondly , it can significantly speedup the retrieval process . For instance , the binary codes can be used to build hash tables ( e.g. , Indyk & Motwani ( 1998 ) ) for sub-linear time approximate nearest neighbor ( ANN ) search . Moreover , in the Hamming space , we can also apply exhaustive search , which is much faster than computing the Euclidean distances , plus the technique of multi-index hashing ( Norouzi et al. , 2012 ) can further accelerate the exact Hamming search by orders of magnitude . In general , binary hashing methods can be categorized into supervised and unsupervised approaches . In this work , we focus on the unsupervised setting . Locality-Sensitive Hashing ( LSH ) ( Indyk & Motwani , 1998 ) is one of the early hashing methods leading to binary embedding . The LSH targeting at cosine similarity ( Charikar , 2002 ) , also known as SimHash , generates binary hash codes using random hyperplanes by taking the sign of data-independent random Gaussian projections . For the cosine similarity , LSH has strict theoretical guarantee on the approximation error and search efficiency , but typically requires relatively long codes to achieve good performance . Hence , many works have focused on learning data-dependent short binary hash codes , through different objective functions . Examples include Iterative Quantization ( ITQ ) ( Gong & Lazebnik , 2011 ) , Spectral Hashing ( SpecH ) ( Weiss et al. , 2008 ) and Binary Reconstruction Embedding ( BRE ) ( Kulis & Darrell , 2009 ) . Recently , some unsupervised deep learning based methods have been proposed in the computer vision community , many of which are , to some extent , “ task-specific ” for cross-modal/video/image retrieval , implemented based on some deep models like the autoencoder and VGG-16 ( Liu et al. , 2016 ; Do et al. , 2017 ; Chen et al. , 2018 ; Li et al. , 2019 ; Yang et al. , 2019 ; Hansen et al. , 2020 ; Liu et al. , 2020 ; Qiu et al. , 2021 ) . By taking the advantage of the complicated model structures ( e.g. , CNN layers ) , these deep methods show promising performance in many image retrieval tasks . Compared with the data-dependent methods ( including deep methods ) , LSH has three advantages : • Although the data-dependent procedures can provide improved performance with fewer binary codes , a known undesirable effect of many of these mechanisms is the performance degradation when we increase the code length b , as reported in prior literature ( Raginsky & Lazebnik , 2009 ; Joly & Buisson , 2011 ) . In our experiments , we will show that this may also be an issue for deep learning based methods . On the other hand , the performance ( i.e. , search accuracy ) of the data-independent LSH would keep boosting with larger b . In many scenarios , it is often the case that only using short codes ( e.g. , ≤ 128 bits ) can not achieve a desirable level of search accuracy for practical purposes . In these cases , one may need to use longer codes anyway , where LSH could be more favorable . • LSH is very simple to implement ( only with random projections ) , while data-dependent methods require additional optimization/training which might be costly . Moreover , large deep learning models would typically need longer inference time , which might be infeasible in practice where the query speed is important . • It is difficult to characterize the properties of the data-dependent methods theoretically , while LSH enjoys rigorous guarantees on the retrieval/approximation performance . Therefore , LSH is still a popular hashing method with great research interest and many practical applications ( Shrivastava & Li , 2014 ; Qi et al. , 2017 ; Driemel & Silvestri , 2017 ; Chen et al. , 2019 ; Zandieh et al. , 2020 ; Lei et al. , 2020 ; Daghaghi et al. , 2021 ) . 1.1 LOCALITY-SENSITIVE HASHING FROM RANDOM FOURIER FEATURES . Kernel methods have gained great success in many machine learning tasks ( Schölkopf & Smola , 2002 ; Zhu & Hastie , 2001 ; Avron et al. , 2017 ; Sun et al. , 2018 ) . However , standard kernel methods require the n × n kernel matrix , which becomes computationally expensive on large-scale datasets with massive data points . To this end , Rahimi & Recht ( 2007 ) proposes the method of random Fourier feature ( RFF ) , which defines a feature map that approximates shift-invariant kernels by the linear inner products . As such , the RFF preserves the “ non-linear locality structure ” of the data . This leads to numerous applications in large-scale learning where one trains linear models on RFF to approximate training non-linear kernel machines ( Yang et al. , 2012 ; Chwialkowski et al. , 2015 ; Sutherland & Schneider , 2015 ; Avron et al. , 2017 ; Sun et al. , 2018 ; Tompkins & Ramos , 2018 ) . Given the popularity of RFF , one natural step is to apply it to search problems . Raginsky & Lazebnik ( 2009 ) proposes to construct binary codes from the RFF using stochastic binary quantization . We call this method “ SQ-RFF ” , whose convergence ( as b→∞ ) and concentration can be theoretically characterized . The author showed that SQ-RFF can achieve competitive search accuracy with sufficient b , e.g. , b ≥ 512 . Since RFF itself is a widely used tool for large-scale kernel learning , SQ-RFF could be a convenient/useful tool in practical scenarios where RFF has been generated for training kernel machines , and the data scientist wants to further use it for efficient near neighbor retrieval . 1.2 OUR CONTRIBUTIONS . Given the benefits of LSH and RFF , we revisit hashing methods for non-linear kernels , and improve the prior RFF based hashing method . Our approach is named as “ SignRFF ” . Specifically , • We theoretically compare several linear and non-linear LSH methods in terms of a novel measure called the ranking efficiency , which is defined based on the probability of retrieving a wrong/reversed similarity ranking . Under this unified metric , the proposed SignRFF is uniformly better than SQ-RFF . Moreover , the ranking efficiency also indicates that typically one should prefer SignRFF over linear LSH when the near neighbors are close to each other , which is the first systematic comparison of linear vs. non-linear LSH in literature . • Empirically , we conduct near neighbor search experiments on benchmark image datasets to compare the proposed SignRFF with other popular hashing methods , which verifies the superiority of SignRFF over SQ-RFF . We validate that the ranking efficiency metric aligns well with the empirical results . Moreover , SignRFF outperforms various competing methods ( including deep methods ) with moderately large number of hash bits , indicating its advantage in applications to achieve a high search recall/precision . 2 PRELIMINARIES . 2.1 LOCALITY-SENSITIVE HASHING ( LSH ) . In large-scale information retrieval , exhaustive search of the exact nearest neighbors is usually too expensive . A common relaxation in this setting is the Approximate Nearest Neighbor ( ANN ) search , where we return the “ good ” neighbors of a query with high probability . In this paper , we will consider the search problem with data points in Rd . X denotes the database consisting of n data points , and q is a query point . x , y are two data points with ρ = cos ( x , y ) . Definition 2.1 ( S̃-neighbor ) . For a similarity measure S : Rd × Rd 7→ R , the S̃-neighbor set of q is defined as { x ∈X : S ( x , q ) > S̃ } . Definition 2.2 ( ( c , S̃ ) -ANN ) . Assume δ > 0 is a parameter . An algorithm A is a ( c , S̃ ) -ANN method provided the following : with probability at least 1− δ , for 0 < c < 1 , if there exists an S̃-neighbor of q in X , A returns a cS̃-neighbor of q . One popular method satisfying Definition 2.2 is the Locality-Sensitive Hashing ( LSH ) . Definition 2.3 ( Indyk & Motwani ( 1998 ) ) . A family of hash functions H is called ( S̃ , cS̃ , p1 , p2 ) locality-sensitive for similarity measure S and 0 < c < 1 , if for ∀x , y ∈ Rd and hash function h uniformly chosen from H , it holds that : 1 ) If S ( x , y ) ≥ S̃ , then P ( h ( x ) = h ( y ) ) ≥ p1 ; 2 ) If S ( x , y ) ≤ cS̃ , then P ( h ( x ) = h ( y ) ) ≤ p2 , with p2 < p1 . A key intuition of LSH is that , similar data points with have higher chance of hash collision in the Hamming space . In this paper , we will specifically consider the LSH for the cosine similarity ( Charikar , 2002 ) . For a data vector x ∈ Rd , the LSH binary code is given by LSH : hLSH ( x ) = sign ( wTx ) , ( 1 ) where wT is a standard Gaussian random vector . We use b i.i.d . w1 , ... , wb to generate b LSH binary codes . The collision probability between the codes of two data points x , y is P ( hLSH ( x ) = hLSH ( y ) ) = 1− cos−1 ( ρ ) π , ( 2 ) where ρ = cos ( x , y ) is their cosine similarity . Note that P ( hLSH ( x ) = hLSH ( y ) ) is increasing in ρ , which , By Definition 2.3 , is the key to ensure the locality sensitivity . 2.2 KERNELIZED LOCALITY-SENSITIVE HASHING ( KLSH ) . In this paper , we will consider the popular Gaussian kernel function defined for x , y ∈ Rd as k ( x , y ) = exp ( −γ2‖x− y‖2 2 ) , where γ is a hyper-parameter . Let Ψ : Rd 7→ F be the feature map with the kernel induced feature spaceF . To incorporate non-linearity in LSH , Kulis & Grauman ( 2009 ) proposes Kernelized Locality-Sensitive Hashing ( KLSH ) , by applying LSH ( 1 ) in the kernel induced feature space F , i.e. , h ( x ) = sign ( wTΨ ( x ) ) . However , as in many cases ( e.g. , for the Gaussian kernel ) the map Ψ can not be explicitly identified , constructing the random Gaussian projection vector w needs some careful design . KLSH approximates the random Gaussian distribution using a sufficient number of data points , by the Central Limit Theorem ( CLT ) in the Reproducing Kernel Hilbert Space . One first samples m data points from X to form a kernel matrix K , then uniformly picks t points from [ 1 , ... , m ] at random to approximate the Gaussian distribution . The hash code has the form KLSH : hKLSH ( x ) = sign ( m∑ i=1 w ( i ) k ( x , xi ) ) , ( 3 ) where w = K−1/2et , and et ∈ { 0 , 1 } m has ones in the entries with indices of the t selected points . We see that the codes h1 , ... , hb are actually dependent , and the quality of using CLT to approximate Gaussian distribution is not guaranteed , especially in high-dimensional kernel feature space . Jiang et al . ( 2015 ) re-formulates KLSH as applying LSH on the kernel principle components in the kernel induced feature space , resolving a theoretical concern of KLSH . Notably , since KLSH uses a pool of data samples to approximate the Gaussian distribution , the hash codes are in fact dependent in practical implementation . It is observed that the performance of KLSH also drops as b increases ( Joly & Buisson , 2011 ) , similar to the behavior of many data-dependent methods . We provide more detailed explanation in Appendix C . | In this paper, the authors propose a simple strategy to extract random Fourier feature based binary codes. The authors also propose a new measure, ranking efficiency, to compare the search accuracy over two datapoints for locality-sensitive hashing methods. Experiments are conducted on several image retrieval datasets to validate the effectiveness of the proposed SignRFF. | SP:da9d10c667fd1afada0abd335a3eeb15c103ea1f |
Asymmetry Learning for Counterfactually-invariant Classification in OOD Tasks | Generalizing from observed to new related environments ( out-of-distribution ) is central to the reliability of classifiers . However , most classifiers fail to predict label Y from input X when the change in environment is due a ( stochastic ) input transformation T te ˝X 1 not observed in training , as in training we observe T tr ˝X 1 , where X 1 is a hidden variable . This work argues that when the transformations in train T tr and test T te are ( arbitrary ) symmetry transformations induced by a collection of known m equivalence relations , the task of finding a robust OOD classifier can be defined as finding the simplest causal model that defines a causal connection between the target labels and the symmetry transformations that are associated with label changes . We then propose a new learning paradigm , asymmetry learning , that identifies which symmetries the classifier must break in order to correctly predict Y in both train and test . Asymmetry learning performs a causal model search that , under certain identifiability conditions , finds classifiers that perform equally well in-distribution and out-of-distribution . Finally , we show how to learn counterfactually-invariant representations with asymmetry learning in two simulated physics tasks and six image classification tasks . 1 INTRODUCTION . A significant challenge in classification tasks happens when the test distribution differs from the training distribution ( i.e. , the task requires out-of-distribution ( OOD ) generalization ) , since not accounting for the distribution shift can lead to poor generalization accuracy ( Geirhos et al. , 2020 ; Hu et al. , 2020 ; Koh et al. , 2020 ; D ’ Amour et al. , 2020 ) . If the learner sees examples from the test distribution , finding a classifier invariant to the distribution shift can still be a data-driven task ( e.g. , classical domain adaptation Ben-David et al . ( 2007 ) ; Muandet et al . ( 2013 ) ; Zhao et al . ( 2019 ) ) . This includes cases such as invariant risk minimization ( Arjovsky et al. , 2019 ) and its generalizations ( Bellot & van der Schaar , 2020 ) , where the training data and the test data distributions overlap in a way that can be exploited by data-driven algorithms ( Creager et al. , 2021 ; Krueger et al. , 2021 ; Rosenfeld et al. , 2020 ) . However , if the learner sees no examples from the test distribution , the task is not purely data-driven and requires assumptions about the data generation process . More formally , our work considers general OOD tasks with training distribution P pY tr , X trq , where X tr : “ T tr ˝ X : , with X : as a hidden variable with distribution P pX : q and T tr P T is a random input transformation in training T tr : X Ñ X , where t ˝ x is the application of transformation t P T on x P X . The difference between train and test is a change in input transformation with Y te : “ Y tr and X te : “ T te ˝ X : , where P pT trq ‰ P pT teq . We are interested in learning an invariant classifier that generalizes well in held out examples from the training and test distributions . The definition of transformation matters in this task . We first seek to generalize the existing literature on transformation invariances , e.g . ( Shawe-Taylor , 1993 ; Kondor & Trivedi , 2018 ; Finzi et al. , 2021 ; Maron et al. , 2018 ; Murphy et al. , 2019b ; Mouli & Ribeiro , 2021 ; Bronstein et al. , 2017 ) . Our transformations are tied to equivalence relations rather than transformation groups , which frees them from the need to have inverses ( in order to form a transformation group ) . Our transformations may not have inverses . We also explain why the task of learning an invariant OOD classifier is not , in general , solvable via traditional ( interventional ) data augmentation . Before we continue describing our OOD learning task , it is important to clarify the connection between Pearl ’ s causal hierarchy and invariant representation learning . Pearl ’ s causal hierarchy and invariant representation learning . Pearl ’ s causal hierarchy ( Pearl & Mackenzie , 2018 ; Bareinboim et al. , 2020 ) ) has three layers : Observational ( Layer 1 ) , interventional ( Layer 2 ) , and counterfactual ( Layer 3 ) . Upper layers can perform lower layer tasks , but not vice-versa ( see Bareinboim et al . ( 2020 ) ) . Tasks should be described using the lowest layer that can solve them . Layer 1 : Any task that can be performed without constraints on the causal model , i.e. , by data alone , is observational ( Layer 1 ) . Traditional domain adaptation is a Layer 1 task . Note that a classifier that performs well OOD is itself a Layer 1 classifier , since it tries to predict P pY te|X teq . Layer 2 : Without observations from P pX teq and/or P pY te|X teq , learning an OOD classifier requires some assumptions about the data generation process ( Layers 2 or 3 assumptions ) . Data augmentation is traditionally an interventional task ( Layer 2 ) , with new interesting methods increasingly using causal language ( Ilse et al. , 2021 ; Teney et al. , 2020 ) . For instance , in a task predicting an image ’ s foreground , knowing how to act on an image in training X tr to change the background seen in training to the backgrounds seen in test X te “ T ˝X tr with a transformation T , implies we know how to predict P pY |X , dopT qq . Following the recent literature , we will define the do operator as Y pT “ tq : “ Y |dopT “ tq . Layer 3 : Counterfactuals are the most challenging task . We start our description with an example . Consider a random continuous transformation T tr2 ( in training ) which changes to random transformation T te2 ( in test ) . Let X : describe a hidden variable such that X tr : “ T1 ˝ T tr2 ˝ T3 ˝ X : and X te : “ T1 ˝ T te2 ˝ T3 ˝X : , where T1 and T3 are independent continuous random transformations and P pT tr2 q ‰ P pT te2 q . Assume the target variable Y depends only onX : , T1 , and T3 . To counterfactually ask what would have happened to the observed input x if we had forced dopT tr2 “ t̃2q , we are inquiring about XpT tr2 “ t̃2q|X tr “ x . Note that dopT tr2 “ t̃2q does not change Y . Also note that the knowledge of X tr “ x is an indirect statement about T tr2 since P pT tr2 |X tr “ xq ‰ P pT tr2 q . That is , for x , x1 P X , P pXpT tr2 “ t̃2q “ x1|X tr “ xq “ ż t P pXpT tr2 “ t̃2q “ x1|T tr2 “ t , X tr “ xqdP pT tr2 “ t|X tr “ xq . ( 1 ) Equation ( 1 ) and the difference between the causal hierarchy layers will be relevant for our results . Contributions . Our contributions can be described as follows : 1 . We introduce a generalization of transformation groups via symmetry transformations tied to equivalence classes that removes the requirement of invertible transformations common in definitions using transformation groups . 2 . We introduce the concept of counterfactual invariant representations for symmetry transformations and show how it can be described as a counterfactual task for causal structure discovery . 3 . Finally , we introduce asymmetry learning , which describes a representation regularization that , under a set of assumptions , learns the correct counterfactual invariant OOD classifier . 2 SYMMETRIES AND TRANSFORMATIONS . Geometrically , an object is called symmetric if there is a transformation on the object that does not change its shape ( in some definition of shape ) . For example , a square is symmetric with respect to rotations . The notion of symmetry however is not restricted to geometric notions . In general , we can define a mathematical object as symmetric if there is a transformation on the object that returns another object equivalent to the first ( Rosen , 2008 , Chapter 10 ) . It is clear from this definition of symmetry that we first need to define what we mean by equivalent objects . For instance , we say two geometrical objects are equivalent if they have the same shape , but we need a more general definition . We define an input symmetry in a space X with at least two elements as an equivalence relation „ . An equivalence relation in X is a binary relation „ such that for all a , b , c P X , we have ( i ) a „ a , ( ii ) a „ b ðñ b „ a , and ( iii ) ( a „ b and b „ cq ùñ a „ c. Equivalence relations allow us to define equivalent objects in X : a „ b means a is equivalent to b . The set of all objects equivalent to some a P X is called the equivalence class of a , defined as ras : “ tx P X : x „ au . Note that one can define m ě 2 equivalence relations on the same input space . The equivalence class of x with respect to equivalence relation k is denoted rxspkq , k “ 1 , . . . , m. Two inputs a , b P X might be equivalent under one equivalence relation „ 1 , but not equivalent under a different equivalence relation „ 2 , that is , we can have both b P rasp1q and b R rasp2q . Still , even in this last case it is possible that a is equivalent to some other input c ‰ b in both equivalence relations , i.e. , it is possible Dc P X , c ‰ a , s.t . c P rasp1q X rasp2q . We denote the collection of equivalence classes of X under the equivalence relation „ k as the quotient space X { „ k : “ trxspkq | x P X u . Transformation group example . Consider the bijective transformations t : X Ñ X of a transformation group G , t P G. We now define an equivalence relation over G as t ˝ x „ G x for all t P G. The equivalence class rxspGq is x ’ s orbit defined as rxspGq : “ tx1 : Dt P G , x1 “ t ˝ xu . For example , if G is the group that permutes the elements of vectors in R3 , then p1 , 2 , 3q „ G p2 , 1 , 3q . Property functions example . Another way of deriving an equivalence relation is via functions of the input space z : X Ñ Rp , where the output zpxq is a particular property of the vector x P X . For example , given an observation of length T from a dynamical system , x P RdˆT , a possible property function could be zenergyp¨q that computes the energy of the dynamical system . Assuming there are m known properties z1 , . . . , zm with zi : X Ñ Rpi , we can construct corresponding equivalence relations „ 1 , . . . , „ m such that for any x , x1 P X , x „ i x1 if zjpxq “ zjpx1q , @ j ‰ i . In words , two inputs are equivalent under „ i if they have the same properties for all zj , j ‰ i. Symmetry transformations . As seen above , symmetries can be defined without defining how the input is transformed to create the equivalence classes , although defining a set of transformations is useful when describing the equivalence class . Given an equivalence relation „ , we can define a set of transformations T that respect the equivalence relation such that @ t P T , @ x P X , t ˝x „ x . We call T the set of symmetry transformations of „ . Similar to transformations groups , T always has the identity transformation tid ˝ x “ x , but in contrast , all the transformations in T need not be bijective . Join of equivalence relations . Similar to how two groups can be joined to form a larger group , two equivalence relations can be joined to form a coarser equivalence relation . Given two equivalence relations , „ 1 and „ 2 , their join „ 1 _ „ 2 is defined as : for all x , x1 , xp „ 1 _ „ 2qx1 if and only if there exists a chain of equivalence relations x „ k1 x1 , . . . , xh´1 „ kh x1 with all kj P t1 , 2u . It is easy to check that „ 1 _ „ 2 is an equivalence relation . We are now ready to define a general causal model that defines the training and test distributions in our setting . | The authors propose an approach for constructing classifiers that achieve out-of-distribution (OOD) generalization using a new learning paradigm they call _asymmetry learning_. They consider OOD tasks where the test input is obtained from the training input by applying a sequence of (random) input transformations. To obtain an invariant OOD classifier that generalizes well to both in-distribution and out-of-distribution samples, the authors introduce the concept of _counterfactual invariant representations over symmetric transformations_. They show how learning the invariant representations can be cast as a causal structure discovery task and propose a score-based (GES-based) algorithm for finding the causal directed acyclic graph (DAG) that best describes the invariances. | SP:fbfa05b6508930991d90474bc920a57ae305bdc6 |
Asymmetry Learning for Counterfactually-invariant Classification in OOD Tasks | Generalizing from observed to new related environments ( out-of-distribution ) is central to the reliability of classifiers . However , most classifiers fail to predict label Y from input X when the change in environment is due a ( stochastic ) input transformation T te ˝X 1 not observed in training , as in training we observe T tr ˝X 1 , where X 1 is a hidden variable . This work argues that when the transformations in train T tr and test T te are ( arbitrary ) symmetry transformations induced by a collection of known m equivalence relations , the task of finding a robust OOD classifier can be defined as finding the simplest causal model that defines a causal connection between the target labels and the symmetry transformations that are associated with label changes . We then propose a new learning paradigm , asymmetry learning , that identifies which symmetries the classifier must break in order to correctly predict Y in both train and test . Asymmetry learning performs a causal model search that , under certain identifiability conditions , finds classifiers that perform equally well in-distribution and out-of-distribution . Finally , we show how to learn counterfactually-invariant representations with asymmetry learning in two simulated physics tasks and six image classification tasks . 1 INTRODUCTION . A significant challenge in classification tasks happens when the test distribution differs from the training distribution ( i.e. , the task requires out-of-distribution ( OOD ) generalization ) , since not accounting for the distribution shift can lead to poor generalization accuracy ( Geirhos et al. , 2020 ; Hu et al. , 2020 ; Koh et al. , 2020 ; D ’ Amour et al. , 2020 ) . If the learner sees examples from the test distribution , finding a classifier invariant to the distribution shift can still be a data-driven task ( e.g. , classical domain adaptation Ben-David et al . ( 2007 ) ; Muandet et al . ( 2013 ) ; Zhao et al . ( 2019 ) ) . This includes cases such as invariant risk minimization ( Arjovsky et al. , 2019 ) and its generalizations ( Bellot & van der Schaar , 2020 ) , where the training data and the test data distributions overlap in a way that can be exploited by data-driven algorithms ( Creager et al. , 2021 ; Krueger et al. , 2021 ; Rosenfeld et al. , 2020 ) . However , if the learner sees no examples from the test distribution , the task is not purely data-driven and requires assumptions about the data generation process . More formally , our work considers general OOD tasks with training distribution P pY tr , X trq , where X tr : “ T tr ˝ X : , with X : as a hidden variable with distribution P pX : q and T tr P T is a random input transformation in training T tr : X Ñ X , where t ˝ x is the application of transformation t P T on x P X . The difference between train and test is a change in input transformation with Y te : “ Y tr and X te : “ T te ˝ X : , where P pT trq ‰ P pT teq . We are interested in learning an invariant classifier that generalizes well in held out examples from the training and test distributions . The definition of transformation matters in this task . We first seek to generalize the existing literature on transformation invariances , e.g . ( Shawe-Taylor , 1993 ; Kondor & Trivedi , 2018 ; Finzi et al. , 2021 ; Maron et al. , 2018 ; Murphy et al. , 2019b ; Mouli & Ribeiro , 2021 ; Bronstein et al. , 2017 ) . Our transformations are tied to equivalence relations rather than transformation groups , which frees them from the need to have inverses ( in order to form a transformation group ) . Our transformations may not have inverses . We also explain why the task of learning an invariant OOD classifier is not , in general , solvable via traditional ( interventional ) data augmentation . Before we continue describing our OOD learning task , it is important to clarify the connection between Pearl ’ s causal hierarchy and invariant representation learning . Pearl ’ s causal hierarchy and invariant representation learning . Pearl ’ s causal hierarchy ( Pearl & Mackenzie , 2018 ; Bareinboim et al. , 2020 ) ) has three layers : Observational ( Layer 1 ) , interventional ( Layer 2 ) , and counterfactual ( Layer 3 ) . Upper layers can perform lower layer tasks , but not vice-versa ( see Bareinboim et al . ( 2020 ) ) . Tasks should be described using the lowest layer that can solve them . Layer 1 : Any task that can be performed without constraints on the causal model , i.e. , by data alone , is observational ( Layer 1 ) . Traditional domain adaptation is a Layer 1 task . Note that a classifier that performs well OOD is itself a Layer 1 classifier , since it tries to predict P pY te|X teq . Layer 2 : Without observations from P pX teq and/or P pY te|X teq , learning an OOD classifier requires some assumptions about the data generation process ( Layers 2 or 3 assumptions ) . Data augmentation is traditionally an interventional task ( Layer 2 ) , with new interesting methods increasingly using causal language ( Ilse et al. , 2021 ; Teney et al. , 2020 ) . For instance , in a task predicting an image ’ s foreground , knowing how to act on an image in training X tr to change the background seen in training to the backgrounds seen in test X te “ T ˝X tr with a transformation T , implies we know how to predict P pY |X , dopT qq . Following the recent literature , we will define the do operator as Y pT “ tq : “ Y |dopT “ tq . Layer 3 : Counterfactuals are the most challenging task . We start our description with an example . Consider a random continuous transformation T tr2 ( in training ) which changes to random transformation T te2 ( in test ) . Let X : describe a hidden variable such that X tr : “ T1 ˝ T tr2 ˝ T3 ˝ X : and X te : “ T1 ˝ T te2 ˝ T3 ˝X : , where T1 and T3 are independent continuous random transformations and P pT tr2 q ‰ P pT te2 q . Assume the target variable Y depends only onX : , T1 , and T3 . To counterfactually ask what would have happened to the observed input x if we had forced dopT tr2 “ t̃2q , we are inquiring about XpT tr2 “ t̃2q|X tr “ x . Note that dopT tr2 “ t̃2q does not change Y . Also note that the knowledge of X tr “ x is an indirect statement about T tr2 since P pT tr2 |X tr “ xq ‰ P pT tr2 q . That is , for x , x1 P X , P pXpT tr2 “ t̃2q “ x1|X tr “ xq “ ż t P pXpT tr2 “ t̃2q “ x1|T tr2 “ t , X tr “ xqdP pT tr2 “ t|X tr “ xq . ( 1 ) Equation ( 1 ) and the difference between the causal hierarchy layers will be relevant for our results . Contributions . Our contributions can be described as follows : 1 . We introduce a generalization of transformation groups via symmetry transformations tied to equivalence classes that removes the requirement of invertible transformations common in definitions using transformation groups . 2 . We introduce the concept of counterfactual invariant representations for symmetry transformations and show how it can be described as a counterfactual task for causal structure discovery . 3 . Finally , we introduce asymmetry learning , which describes a representation regularization that , under a set of assumptions , learns the correct counterfactual invariant OOD classifier . 2 SYMMETRIES AND TRANSFORMATIONS . Geometrically , an object is called symmetric if there is a transformation on the object that does not change its shape ( in some definition of shape ) . For example , a square is symmetric with respect to rotations . The notion of symmetry however is not restricted to geometric notions . In general , we can define a mathematical object as symmetric if there is a transformation on the object that returns another object equivalent to the first ( Rosen , 2008 , Chapter 10 ) . It is clear from this definition of symmetry that we first need to define what we mean by equivalent objects . For instance , we say two geometrical objects are equivalent if they have the same shape , but we need a more general definition . We define an input symmetry in a space X with at least two elements as an equivalence relation „ . An equivalence relation in X is a binary relation „ such that for all a , b , c P X , we have ( i ) a „ a , ( ii ) a „ b ðñ b „ a , and ( iii ) ( a „ b and b „ cq ùñ a „ c. Equivalence relations allow us to define equivalent objects in X : a „ b means a is equivalent to b . The set of all objects equivalent to some a P X is called the equivalence class of a , defined as ras : “ tx P X : x „ au . Note that one can define m ě 2 equivalence relations on the same input space . The equivalence class of x with respect to equivalence relation k is denoted rxspkq , k “ 1 , . . . , m. Two inputs a , b P X might be equivalent under one equivalence relation „ 1 , but not equivalent under a different equivalence relation „ 2 , that is , we can have both b P rasp1q and b R rasp2q . Still , even in this last case it is possible that a is equivalent to some other input c ‰ b in both equivalence relations , i.e. , it is possible Dc P X , c ‰ a , s.t . c P rasp1q X rasp2q . We denote the collection of equivalence classes of X under the equivalence relation „ k as the quotient space X { „ k : “ trxspkq | x P X u . Transformation group example . Consider the bijective transformations t : X Ñ X of a transformation group G , t P G. We now define an equivalence relation over G as t ˝ x „ G x for all t P G. The equivalence class rxspGq is x ’ s orbit defined as rxspGq : “ tx1 : Dt P G , x1 “ t ˝ xu . For example , if G is the group that permutes the elements of vectors in R3 , then p1 , 2 , 3q „ G p2 , 1 , 3q . Property functions example . Another way of deriving an equivalence relation is via functions of the input space z : X Ñ Rp , where the output zpxq is a particular property of the vector x P X . For example , given an observation of length T from a dynamical system , x P RdˆT , a possible property function could be zenergyp¨q that computes the energy of the dynamical system . Assuming there are m known properties z1 , . . . , zm with zi : X Ñ Rpi , we can construct corresponding equivalence relations „ 1 , . . . , „ m such that for any x , x1 P X , x „ i x1 if zjpxq “ zjpx1q , @ j ‰ i . In words , two inputs are equivalent under „ i if they have the same properties for all zj , j ‰ i. Symmetry transformations . As seen above , symmetries can be defined without defining how the input is transformed to create the equivalence classes , although defining a set of transformations is useful when describing the equivalence class . Given an equivalence relation „ , we can define a set of transformations T that respect the equivalence relation such that @ t P T , @ x P X , t ˝x „ x . We call T the set of symmetry transformations of „ . Similar to transformations groups , T always has the identity transformation tid ˝ x “ x , but in contrast , all the transformations in T need not be bijective . Join of equivalence relations . Similar to how two groups can be joined to form a larger group , two equivalence relations can be joined to form a coarser equivalence relation . Given two equivalence relations , „ 1 and „ 2 , their join „ 1 _ „ 2 is defined as : for all x , x1 , xp „ 1 _ „ 2qx1 if and only if there exists a chain of equivalence relations x „ k1 x1 , . . . , xh´1 „ kh x1 with all kj P t1 , 2u . It is easy to check that „ 1 _ „ 2 is an equivalence relation . We are now ready to define a general causal model that defines the training and test distributions in our setting . | This paper considers a class of out of distribution (OOD) problems where at test time there may be new symmetry transformations of the input X (i.e., they don't change the label Y). The authors explain why standard invariances learned by data augmentation may not be OOD invariant. Next, the paper presents a method for learning OOD-invariant representations through causal structure discovery. This hinges on the concept of being counterfactually invariant to the symmetry transformations that could appear at test time but don't affect Y. Next is an algorithm for discovering the structure of a causal DAG which largely revolves around deciding whether or not there is an edge U_i -> Y; this existence question corresponds to whether or not Y is invariant to the transformation U_i (IIUC). The paper test this approach on tasks in a simple simulated physics environment. | SP:fbfa05b6508930991d90474bc920a57ae305bdc6 |
Asymmetry Learning for Counterfactually-invariant Classification in OOD Tasks | Generalizing from observed to new related environments ( out-of-distribution ) is central to the reliability of classifiers . However , most classifiers fail to predict label Y from input X when the change in environment is due a ( stochastic ) input transformation T te ˝X 1 not observed in training , as in training we observe T tr ˝X 1 , where X 1 is a hidden variable . This work argues that when the transformations in train T tr and test T te are ( arbitrary ) symmetry transformations induced by a collection of known m equivalence relations , the task of finding a robust OOD classifier can be defined as finding the simplest causal model that defines a causal connection between the target labels and the symmetry transformations that are associated with label changes . We then propose a new learning paradigm , asymmetry learning , that identifies which symmetries the classifier must break in order to correctly predict Y in both train and test . Asymmetry learning performs a causal model search that , under certain identifiability conditions , finds classifiers that perform equally well in-distribution and out-of-distribution . Finally , we show how to learn counterfactually-invariant representations with asymmetry learning in two simulated physics tasks and six image classification tasks . 1 INTRODUCTION . A significant challenge in classification tasks happens when the test distribution differs from the training distribution ( i.e. , the task requires out-of-distribution ( OOD ) generalization ) , since not accounting for the distribution shift can lead to poor generalization accuracy ( Geirhos et al. , 2020 ; Hu et al. , 2020 ; Koh et al. , 2020 ; D ’ Amour et al. , 2020 ) . If the learner sees examples from the test distribution , finding a classifier invariant to the distribution shift can still be a data-driven task ( e.g. , classical domain adaptation Ben-David et al . ( 2007 ) ; Muandet et al . ( 2013 ) ; Zhao et al . ( 2019 ) ) . This includes cases such as invariant risk minimization ( Arjovsky et al. , 2019 ) and its generalizations ( Bellot & van der Schaar , 2020 ) , where the training data and the test data distributions overlap in a way that can be exploited by data-driven algorithms ( Creager et al. , 2021 ; Krueger et al. , 2021 ; Rosenfeld et al. , 2020 ) . However , if the learner sees no examples from the test distribution , the task is not purely data-driven and requires assumptions about the data generation process . More formally , our work considers general OOD tasks with training distribution P pY tr , X trq , where X tr : “ T tr ˝ X : , with X : as a hidden variable with distribution P pX : q and T tr P T is a random input transformation in training T tr : X Ñ X , where t ˝ x is the application of transformation t P T on x P X . The difference between train and test is a change in input transformation with Y te : “ Y tr and X te : “ T te ˝ X : , where P pT trq ‰ P pT teq . We are interested in learning an invariant classifier that generalizes well in held out examples from the training and test distributions . The definition of transformation matters in this task . We first seek to generalize the existing literature on transformation invariances , e.g . ( Shawe-Taylor , 1993 ; Kondor & Trivedi , 2018 ; Finzi et al. , 2021 ; Maron et al. , 2018 ; Murphy et al. , 2019b ; Mouli & Ribeiro , 2021 ; Bronstein et al. , 2017 ) . Our transformations are tied to equivalence relations rather than transformation groups , which frees them from the need to have inverses ( in order to form a transformation group ) . Our transformations may not have inverses . We also explain why the task of learning an invariant OOD classifier is not , in general , solvable via traditional ( interventional ) data augmentation . Before we continue describing our OOD learning task , it is important to clarify the connection between Pearl ’ s causal hierarchy and invariant representation learning . Pearl ’ s causal hierarchy and invariant representation learning . Pearl ’ s causal hierarchy ( Pearl & Mackenzie , 2018 ; Bareinboim et al. , 2020 ) ) has three layers : Observational ( Layer 1 ) , interventional ( Layer 2 ) , and counterfactual ( Layer 3 ) . Upper layers can perform lower layer tasks , but not vice-versa ( see Bareinboim et al . ( 2020 ) ) . Tasks should be described using the lowest layer that can solve them . Layer 1 : Any task that can be performed without constraints on the causal model , i.e. , by data alone , is observational ( Layer 1 ) . Traditional domain adaptation is a Layer 1 task . Note that a classifier that performs well OOD is itself a Layer 1 classifier , since it tries to predict P pY te|X teq . Layer 2 : Without observations from P pX teq and/or P pY te|X teq , learning an OOD classifier requires some assumptions about the data generation process ( Layers 2 or 3 assumptions ) . Data augmentation is traditionally an interventional task ( Layer 2 ) , with new interesting methods increasingly using causal language ( Ilse et al. , 2021 ; Teney et al. , 2020 ) . For instance , in a task predicting an image ’ s foreground , knowing how to act on an image in training X tr to change the background seen in training to the backgrounds seen in test X te “ T ˝X tr with a transformation T , implies we know how to predict P pY |X , dopT qq . Following the recent literature , we will define the do operator as Y pT “ tq : “ Y |dopT “ tq . Layer 3 : Counterfactuals are the most challenging task . We start our description with an example . Consider a random continuous transformation T tr2 ( in training ) which changes to random transformation T te2 ( in test ) . Let X : describe a hidden variable such that X tr : “ T1 ˝ T tr2 ˝ T3 ˝ X : and X te : “ T1 ˝ T te2 ˝ T3 ˝X : , where T1 and T3 are independent continuous random transformations and P pT tr2 q ‰ P pT te2 q . Assume the target variable Y depends only onX : , T1 , and T3 . To counterfactually ask what would have happened to the observed input x if we had forced dopT tr2 “ t̃2q , we are inquiring about XpT tr2 “ t̃2q|X tr “ x . Note that dopT tr2 “ t̃2q does not change Y . Also note that the knowledge of X tr “ x is an indirect statement about T tr2 since P pT tr2 |X tr “ xq ‰ P pT tr2 q . That is , for x , x1 P X , P pXpT tr2 “ t̃2q “ x1|X tr “ xq “ ż t P pXpT tr2 “ t̃2q “ x1|T tr2 “ t , X tr “ xqdP pT tr2 “ t|X tr “ xq . ( 1 ) Equation ( 1 ) and the difference between the causal hierarchy layers will be relevant for our results . Contributions . Our contributions can be described as follows : 1 . We introduce a generalization of transformation groups via symmetry transformations tied to equivalence classes that removes the requirement of invertible transformations common in definitions using transformation groups . 2 . We introduce the concept of counterfactual invariant representations for symmetry transformations and show how it can be described as a counterfactual task for causal structure discovery . 3 . Finally , we introduce asymmetry learning , which describes a representation regularization that , under a set of assumptions , learns the correct counterfactual invariant OOD classifier . 2 SYMMETRIES AND TRANSFORMATIONS . Geometrically , an object is called symmetric if there is a transformation on the object that does not change its shape ( in some definition of shape ) . For example , a square is symmetric with respect to rotations . The notion of symmetry however is not restricted to geometric notions . In general , we can define a mathematical object as symmetric if there is a transformation on the object that returns another object equivalent to the first ( Rosen , 2008 , Chapter 10 ) . It is clear from this definition of symmetry that we first need to define what we mean by equivalent objects . For instance , we say two geometrical objects are equivalent if they have the same shape , but we need a more general definition . We define an input symmetry in a space X with at least two elements as an equivalence relation „ . An equivalence relation in X is a binary relation „ such that for all a , b , c P X , we have ( i ) a „ a , ( ii ) a „ b ðñ b „ a , and ( iii ) ( a „ b and b „ cq ùñ a „ c. Equivalence relations allow us to define equivalent objects in X : a „ b means a is equivalent to b . The set of all objects equivalent to some a P X is called the equivalence class of a , defined as ras : “ tx P X : x „ au . Note that one can define m ě 2 equivalence relations on the same input space . The equivalence class of x with respect to equivalence relation k is denoted rxspkq , k “ 1 , . . . , m. Two inputs a , b P X might be equivalent under one equivalence relation „ 1 , but not equivalent under a different equivalence relation „ 2 , that is , we can have both b P rasp1q and b R rasp2q . Still , even in this last case it is possible that a is equivalent to some other input c ‰ b in both equivalence relations , i.e. , it is possible Dc P X , c ‰ a , s.t . c P rasp1q X rasp2q . We denote the collection of equivalence classes of X under the equivalence relation „ k as the quotient space X { „ k : “ trxspkq | x P X u . Transformation group example . Consider the bijective transformations t : X Ñ X of a transformation group G , t P G. We now define an equivalence relation over G as t ˝ x „ G x for all t P G. The equivalence class rxspGq is x ’ s orbit defined as rxspGq : “ tx1 : Dt P G , x1 “ t ˝ xu . For example , if G is the group that permutes the elements of vectors in R3 , then p1 , 2 , 3q „ G p2 , 1 , 3q . Property functions example . Another way of deriving an equivalence relation is via functions of the input space z : X Ñ Rp , where the output zpxq is a particular property of the vector x P X . For example , given an observation of length T from a dynamical system , x P RdˆT , a possible property function could be zenergyp¨q that computes the energy of the dynamical system . Assuming there are m known properties z1 , . . . , zm with zi : X Ñ Rpi , we can construct corresponding equivalence relations „ 1 , . . . , „ m such that for any x , x1 P X , x „ i x1 if zjpxq “ zjpx1q , @ j ‰ i . In words , two inputs are equivalent under „ i if they have the same properties for all zj , j ‰ i. Symmetry transformations . As seen above , symmetries can be defined without defining how the input is transformed to create the equivalence classes , although defining a set of transformations is useful when describing the equivalence class . Given an equivalence relation „ , we can define a set of transformations T that respect the equivalence relation such that @ t P T , @ x P X , t ˝x „ x . We call T the set of symmetry transformations of „ . Similar to transformations groups , T always has the identity transformation tid ˝ x “ x , but in contrast , all the transformations in T need not be bijective . Join of equivalence relations . Similar to how two groups can be joined to form a larger group , two equivalence relations can be joined to form a coarser equivalence relation . Given two equivalence relations , „ 1 and „ 2 , their join „ 1 _ „ 2 is defined as : for all x , x1 , xp „ 1 _ „ 2qx1 if and only if there exists a chain of equivalence relations x „ k1 x1 , . . . , xh´1 „ kh x1 with all kj P t1 , 2u . It is easy to check that „ 1 _ „ 2 is an equivalence relation . We are now ready to define a general causal model that defines the training and test distributions in our setting . | Update I have read the author response and the updated version of this paper. I am delighted to see that the authors have incorporated my feedback and I believe this makes the paper stronger than its previous version. I have updated my scores and recommend that the paper be accepted. ------------------------------------------------------------------ This paper proposes Asymmetry Learning, a new learning paradigm to obtain counterfactually invariant classifiers. If the observed covariates are a result of some transformations applied to a hidden variable, and these transformations differ between training and test datasets, a classifier may not generalize to the test set. The authors argue that when these transformations are a result of a collection of equivalence relations, finding OOD-invariant classifier boils down to finding the simplest causal model that defines the causal relationships between the labels and these symmetry transformations. To this end, the authors propose a scoring criterion to identify the simplest DAG in a DAG search space that ensures that the label is invariant of all transformations while maximizing the likelihood of the observed training set. Using their proposed scoring function, the authors employ Greedy Equivalence Search to identify the DAG with the highest score. Experiments on simulated physics tasks suggest that the method works as intended. | SP:fbfa05b6508930991d90474bc920a57ae305bdc6 |
Independent SE(3)-Equivariant Models for End-to-End Rigid Protein Docking | Protein complex formation is a central problem in biology , being involved in most of the cell ’ s processes , and essential for applications , e.g . drug design or protein engineering . We tackle rigid body protein-protein docking , i.e. , computationally predicting the 3D structure of a protein-protein complex from the individual unbound structures , assuming no conformational change within the proteins happens during binding . We design a novel pairwise-independent SE ( 3 ) -equivariant graph matching network to predict the rotation and translation to place one of the proteins at the right docked position relative to the second protein . We mathematically guarantee a basic principle : the predicted complex is always identical regardless of the initial locations and orientations of the two structures . Our model , named EQUIDOCK , approximates the binding pockets and predicts the docking poses using keypoint matching and alignment , achieved through optimal transport and a differentiable Kabsch algorithm . Empirically , we achieve significant running time improvements and often outperform existing docking software despite not relying on heavy candidate sampling , structure refinement , or templates . 1 INTRODUCTION protein Z protein Z protein Z-dependent inhibitor protein Z-dependent inhibitor a. b. PDB ID : 3F1S Figure 1 : Different views of the 3D structure of a protein complex . a . Surface and b. cartoon view of protein Z and its inhibitor . In a recent breakthrough , ALPHAFOLD 2 ( Jumper et al. , 2021 ; Senior et al. , 2020 ) provides a solution to a grand challenge in biology—inferring a protein ’ s three-dimensional structure from its amino acid sequence ( Baek et al. , 2021 ) , following the dogma sequence determines structure . Besides their complex three-dimensional nature , proteins dynamically alter their function and structure in response to cellular signals , changes in the environment , or upon molecular docking . In par- ticular , protein interactions are involved in various biological processes including signal transduction , protein synthesis , DNA replication and repair . Molecular docking is key to understanding protein interactions ’ mechanisms and effects , and , subsequently , to developing therapeutic interventions . We here address the problem of rigid body protein-protein docking which refers to computationally predicting the 3D structure of a protein-protein complex given the 3D structures of the two proteins in unbound state . Rigid body means no deformations occur within any protein during binding , which is a realistic assumption in many biological settings . Popular docking software ( Chen et al. , 2003 ; Venkatraman et al. , 2009 ; De Vries et al. , 2010 ; Torchala et al. , 2013 ; Schindler et al. , 2017 ; Sunny and Jayaraj , 2021 ) are typically computationally expensive , taking between minutes and hours to solve a single example pair , while not being guaranteed to find accurate complex structures . These methods largely follow the steps : i . ) randomly sample a large number ( e.g. , millions ) of candidate initial complex structures , ii . ) employ a scoring function to rank the candidates , iii . ) adjust and refine the top complex structures based on an energy model ( e.g. , force field ) . We here take a first step towards tackling these issues by using deep learning models for direct prediction of protein complex structures . Contributions . We design EQUIDOCK , a fast , end-to-end method for rigid body docking that directly predicts the SE ( 3 ) transformation to place one of the proteins ( ligand ) at the right location and orientation with respect to the second protein ( receptor ) . Our method is based on the principle that the exact same complex structure should be predicted irrespectively of the initial 3D placements and roles of both constituents ( see Fig . 2 ) . We achieve this desideratum by incorporating the inductive biases of pairwise SE ( 3 ) –equivariance and commutativity , and deriving novel theoretical results for necessary and sufficient model constraints ( see Section 3 ) . Next , we create EQUIDOCK to satisfy these properties by design , being a combination of : i ) a novel type of pairwise independent SE ( 3 ) -equivariant graph matching networks , ii ) an attention-based keypoint selection algorithm that discovers representative points and aligns them with the binding pocket residues using optimal transport , and iii ) a differentiable superimposition model to recover the optimal global rigid transformation . Unlike prior work , our method does not use heavy candidate sampling or ranking , templates , task-specific geometric or chemical hand-crafted features , or pre-computed meshes . This enables us to achieve plausible structures with a speed-up of 80-500x compared to popular docking software , offering a promising competitive alternative to current solutions for this problem . 2 RELATED WORK . Geometric Deep Learning . Graph Neural Networks ( GNNs ) are becoming the de facto choice for learning with graph data ( Bruna et al. , 2013 ; Defferrard et al. , 2016 ; Kipf and Welling , 2016 ; Gilmer et al. , 2017 ; Xu et al. , 2018 ; Li et al. , 2019 ) . Motivated by symmetries naturally occurring in different data types , architectures are tailored to explicitly incorporate such properties ( Cohen and Welling , 2016a ; b ; Thomas et al. , 2018 ; Fuchs et al. , 2020 ; Finzi et al. , 2020 ; Eismann et al. , 2020 ; Satorras et al. , 2021 ) . GNNs are validated in a variety of tasks such as particle system dynamics or conformation-based energy estimation ( Weiler and Cesa , 2019 ; Rezende et al. , 2019 ) . Euclidean Neural Networks ( E ( 3 ) -NNs ) . However , plain GNNs and other deep learning methods do not understand data naturally lying in the 3D Euclidean space . For example , how should the output deterministically change with the input , e.g . when it is rotated ? The recent Euclidean neural networks address this problem , being designed from geometric first-principles . They make use of SE ( 3 ) - equivariant and invariant neural layers , thus avoiding expensive data augmentation strategies . Such constrained models ease optimization and have shown important improvements in biology or chemistry – e.g . for molecular structures ( Fuchs et al. , 2020 ; Hutchinson et al. , 2020 ; Wu et al. , 2021 ; Jumper et al. , 2021 ; Ganea et al. , 2021 ) and different types of 3D point clouds ( Thomas et al. , 2018 ) . Different from prior work , we here derive constraints for pairs of 3D objects via pairwise independent SE ( 3 ) -equivariances , and design a principled approach for modeling rigid body docking . Protein Folding . Deep neural networks have been used to predict inter-residue contacts , distance and/or orientations ( Adhikari and Cheng , 2018 ; Yang et al. , 2020 ; Senior et al. , 2020 ; Ju et al. , 2021 ) , that are subsequently transformed into additional constraints or differentiable energy terms for protein structure optimization . ALPHAFOLD 2 ( Jumper et al. , 2021 ) and Rosetta Fold ( Baek et al. , 2021 ) are state-of-the-art approaches , and directly predict protein structures from co-evolution information embedded in homologous sequences , using geometric deep learning and E ( 3 ) -NNs . Protein-Protein Docking and Interaction . Experimentally determining structures of protein complexes is often expensive and time-consuming , rendering a premium on computational methods ( Vakser , 2014 ) . Protein docking methods ( Chen et al. , 2003 ; Venkatraman et al. , 2009 ; De Vries et al. , 2010 ; Biesiada et al. , 2011 ; Torchala et al. , 2013 ; Schindler et al. , 2017 ; Weng et al. , 2019 ; Sunny and Jayaraj , 2021 ; Christoffer et al. , 2021 ; Yan et al. , 2020 ) typically run several steps : first , they sample thousands or millions of complex candidates ; second , they use a scoring function for ranking ( Moal et al. , 2013 ; Basu and Wallner , 2016 ; Launay et al. , 2020 ; Eismann et al. , 2020 ) ; finally , top-ranked candidates undergo a structure refinement process using energy or geometric models ( Verburgt and Kihara , 2021 ) . Relevant to protein-protein interaction ( PPI ) is the task of protein interface prediction where GNNs have showed promise ( Fout et al. , 2017 ; Townshend et al. , 2019 ; Liu et al. , 2020 ; Xie and Xu , 2021 ; Dai and Bailey-Kellogg , 2021 ) . Recently , ALPHAFOLD 2 and ROSETTAFOLD have been utilized as subroutines to improve PPIs from different aspects ( Humphreys et al. , 2021 ; Pei et al. , 2021 ; Jovine ) , e.g. , combining physics-based docking method CLUSPRO ( Kozakov et al. , 2017 ; Ghani et al. , 2021 ) , or using extended multiple-sequence alignments to predict the structure of heterodimeric protein complexes from the sequence information ( Bryant et al. , 2021 ) . Concurrently to our work , Evans et al . ( 2021 ) extend ALPHAFOLD 2 to multiple chains during both training and inference . Drug-Target Interaction ( DTI ) . DTI aims to compute drug-target binding poses and affinity , playing an essential role in understanding drugs ’ mechanism of action . Prior methods ( Wallach et al. , 2015 ; Li et al. , 2021 ) predict binding affinity from protein-ligand co-crystal structures , but such data is expensive to obtain experimentally . These models are typically based on heavy candidate sampling and ranking ( Trott and Olson , 2010 ; Koes et al. , 2013 ; McNutt et al. , 2021 ; Bao et al. , 2021 ) , being tailored for small drug-like ligands and often assuming known binding pocket . Thus , they are not immediately applicable to our use case . In contrast , our rigid docking approach is generic and could be extended to accelerate DTI research as part of future work . 3 MATHEMATICAL CONSTRAINTS FOR RIGID BODY DOCKING . We start by introducing the rigid body docking problem and derive the geometric constraints for enforcing same output complex prediction regardless of the initial unbound positions or roles ( Fig . 2 ) . Rigid Protein-Protein Docking – Problem Setup . We are given as input a pair of proteins forming a complex . They are ( arbitrarily ) denoted as the ligand and receptor , consisting of n and m residues , respectively . These proteins are represented in their bound ( docked ) state as 3D point clouds X∗1 ∈ R3×n , X∗2 ∈ R3×m , where each residue ’ s location is given by the coordinates of its corresponding α-carbon atom . In the unbound state , the docked ligand is randomly rotated and translated in space , resulting in a modified point cloud X1 ∈ R3×n . For simplicity and w.l.o.g. , the receptor remains in its bound location X2 = X∗2 . The task is to predict a rotation R ∈ SO ( 3 ) and a translation t ∈ R3 such that RX1 + t = X∗1 , using as input the proteins and their unbound positions X1 and X2 . Here , R = R ( X1|X2 ) and t = t ( X1|X2 ) are functions of the two proteins , where we omit residue identity or other protein information in this notation , for brevity . Note that we assume rigid backbone and side-chains for both proteins . We therefore do not tackle the more challenging problem of flexible docking , but our approach offers an important step towards it . We desire that the predicted complex structure is independent of the initial locations and orientations of the two proteins , as well as of their roles – see Fig . 2 . Formally , we wish to guarantee that : ( R ( Z1|Z2 ) Z1 + t ( Z1|Z2 ) ) ⊕ Z2 ≡ ( R ( X1|X2 ) X1 + t ( X1|X2 ) ) ⊕X2 , ( SE ( 3 ) -invariance ) ( R ( X1|X2 ) X1 + t ( X1|X2 ) ) ⊕X2 ≡ X1 ⊕ ( R ( X2|X1 ) X2 + t ( X2|X1 ) ) , ( commutativity ) ∀Q1 , Q2 ∈ SO ( 3 ) , ∀g1 , g2 ∈ R3 , ∀X1 ∈ R3×n , X2 ∈ R3×m , and Zl = QlXl + gl , l ∈ { 1 , 2 } . ( 1 ) KÉÏ ïËÏÊ PIRtbÉLÉÏ r.tt Ï HÉ ï ï PFRibÉLÉÏITE for any rotations Q1 , Q2 and translations g1 , g2 , where ⊕ is concatenation along columns , and ≡ denotes identity after superimposition , i.e . zero Root-Mean-Square Deviation ( RMSD ) between the two 3D point sets after applying the Kabsch algorithm ( Kabsch , 1976 ) . An immediate question arises : How do the constraints in Eq . ( 1 ) translate into constraints for R ( ·|· ) and t ( ·|· ) ? The rotation R and translation t change in a systematic way when we apply SE ( 3 ) transformations or swap proteins ’ roles . These properties restrict our class of functions as derived below . SE ( 3 ) -equivariance Constraints . If we apply any distinct SE ( 3 ) transformations on the unbound ligand X1 and receptor X2 , i.e . we now dock Q1X1 + g1 onto Q2X2 + g2 , then the rotation matrix R ( Q1X1 +g1|Q2X2 +g2 ) and translation vector t ( Q1X1 +g1|Q2X2 +g2 ) can be derived from the original R ( X1|X2 ) and t ( X1|X2 ) assuming that we always do rotations first . In this case , R ( Q1X1 + g1|Q2X2 + g2 ) can be decomposed into three rotations : i . ) apply Q > 1 to undo the rotation Q1 applied on X1 , ii . ) apply R ( X1|X2 ) , iii . ) apply Q2 to rotate the docked ligand together with the receptor . This gives R ( Q1X1 + g1|Q2X2 + g2 ) = Q2R ( X1|X2 ) Q > 1 , which in turn constraints the translation vector . We provide a formal statement and prove it in Appendix B.1 : Proposition 1 . For any Q1 , Q2 ∈ SO ( 3 ) , g1 , g2 ∈ R3 , SE ( 3 ) -invariance of the predicted docked complex defined by Eq . ( 1 ) is guaranteed iff R ( Q1X1 + g1|Q2X2 + g2 ) = Q2R ( X1|X2 ) Q > 1 t ( Q1X1 + g1|Q2X2 + g2 ) = Q2t ( X1|X2 ) −Q2R ( X1|X2 ) Q > 1 g1 + g2 . ( 2 ) As a direct consequence of this proposition , we have the following statement . Proposition 2 . Any model satisfying Proposition 1 guarantees invariance of the predicted complex w.r.t . any SE ( 3 ) transformation on X1 , and equivariance w.r.t . any SE ( 3 ) transformation on X2 : R ( Z1|X2 ) Z1 + t ( Z1|X2 ) = R ( X1|X2 ) X1 + t ( X1|X2 ) , where Z1 = Q1X1 + g1 R ( X1|Z2 ) X1 + t ( X1|Z2 ) = Q2 [ R ( X1|X2 ) X1 + t ( X1|X2 ) ] + g2 , where Z2 = Q2X2 + g2 ∀Q1 , Q2 ∈ SO ( 3 ) , ∀g1 , g2 ∈ R3 , ∀X1 ∈ R3×n , ∀X2 ∈ R3×m . Commutativity . Instead of docking X1 with respect to X2 , we can also dock X2 with respect to X1 . In this case , we require the final complex structures to be identical after superimposition , i.e. , zero RMSD . This property is named commutativity and it is satisfied as follows ( proof in Appendix B.2 ) . Proposition 3 . Commutativity as defined by Eq . ( 1 ) is guaranteed iff R ( X2|X1 ) = R > ( X1|X2 ) ; t ( X2|X1 ) = −R > ( X1|X2 ) t ( X1|X2 ) , ( 3 ) Point Permutation Invariance . We also enforce residue permutation invariance . Formally , both R ( X1|X2 ) and t ( X1|X2 ) should not depend on the order or columns of X1 and , resp. , of X2 . | In this paper, the authors propose a method for the “rigid body” docking of protein-protein complexes, i.e., a complex in which conformational changes in protein structures are not allowed. This method, called independent E(3)-equivariant graph matching networks (IEGMNs), finds the optimal rotation and translation to place proteins in a manner that the distances between residues in the binding site is minimized. A core feature of this method is SE(3) invariance, which means the optimal solution is invariant to the rotations and translations of the two proteins. This is achieved in an elaborate manner employing several ideas and technics: - A k-NN graph is built for each protein using its CA coordinates and a set of additional features are also extracted - Message-passing neural network (MPNN) is used for graph-matching - Binding pocket residues or “keypoints” are identified - A differentiable Kabsch model is used for superimposing is the “keypoints” - Optimal transport is used for the alignment of residues in the binding pocket This method, as reported by the authors, runs very fast and can identify the protein complex efficiently. | SP:d5bdd82960013ea8c01a0bac94ed6d293dc48cff |
Independent SE(3)-Equivariant Models for End-to-End Rigid Protein Docking | Protein complex formation is a central problem in biology , being involved in most of the cell ’ s processes , and essential for applications , e.g . drug design or protein engineering . We tackle rigid body protein-protein docking , i.e. , computationally predicting the 3D structure of a protein-protein complex from the individual unbound structures , assuming no conformational change within the proteins happens during binding . We design a novel pairwise-independent SE ( 3 ) -equivariant graph matching network to predict the rotation and translation to place one of the proteins at the right docked position relative to the second protein . We mathematically guarantee a basic principle : the predicted complex is always identical regardless of the initial locations and orientations of the two structures . Our model , named EQUIDOCK , approximates the binding pockets and predicts the docking poses using keypoint matching and alignment , achieved through optimal transport and a differentiable Kabsch algorithm . Empirically , we achieve significant running time improvements and often outperform existing docking software despite not relying on heavy candidate sampling , structure refinement , or templates . 1 INTRODUCTION protein Z protein Z protein Z-dependent inhibitor protein Z-dependent inhibitor a. b. PDB ID : 3F1S Figure 1 : Different views of the 3D structure of a protein complex . a . Surface and b. cartoon view of protein Z and its inhibitor . In a recent breakthrough , ALPHAFOLD 2 ( Jumper et al. , 2021 ; Senior et al. , 2020 ) provides a solution to a grand challenge in biology—inferring a protein ’ s three-dimensional structure from its amino acid sequence ( Baek et al. , 2021 ) , following the dogma sequence determines structure . Besides their complex three-dimensional nature , proteins dynamically alter their function and structure in response to cellular signals , changes in the environment , or upon molecular docking . In par- ticular , protein interactions are involved in various biological processes including signal transduction , protein synthesis , DNA replication and repair . Molecular docking is key to understanding protein interactions ’ mechanisms and effects , and , subsequently , to developing therapeutic interventions . We here address the problem of rigid body protein-protein docking which refers to computationally predicting the 3D structure of a protein-protein complex given the 3D structures of the two proteins in unbound state . Rigid body means no deformations occur within any protein during binding , which is a realistic assumption in many biological settings . Popular docking software ( Chen et al. , 2003 ; Venkatraman et al. , 2009 ; De Vries et al. , 2010 ; Torchala et al. , 2013 ; Schindler et al. , 2017 ; Sunny and Jayaraj , 2021 ) are typically computationally expensive , taking between minutes and hours to solve a single example pair , while not being guaranteed to find accurate complex structures . These methods largely follow the steps : i . ) randomly sample a large number ( e.g. , millions ) of candidate initial complex structures , ii . ) employ a scoring function to rank the candidates , iii . ) adjust and refine the top complex structures based on an energy model ( e.g. , force field ) . We here take a first step towards tackling these issues by using deep learning models for direct prediction of protein complex structures . Contributions . We design EQUIDOCK , a fast , end-to-end method for rigid body docking that directly predicts the SE ( 3 ) transformation to place one of the proteins ( ligand ) at the right location and orientation with respect to the second protein ( receptor ) . Our method is based on the principle that the exact same complex structure should be predicted irrespectively of the initial 3D placements and roles of both constituents ( see Fig . 2 ) . We achieve this desideratum by incorporating the inductive biases of pairwise SE ( 3 ) –equivariance and commutativity , and deriving novel theoretical results for necessary and sufficient model constraints ( see Section 3 ) . Next , we create EQUIDOCK to satisfy these properties by design , being a combination of : i ) a novel type of pairwise independent SE ( 3 ) -equivariant graph matching networks , ii ) an attention-based keypoint selection algorithm that discovers representative points and aligns them with the binding pocket residues using optimal transport , and iii ) a differentiable superimposition model to recover the optimal global rigid transformation . Unlike prior work , our method does not use heavy candidate sampling or ranking , templates , task-specific geometric or chemical hand-crafted features , or pre-computed meshes . This enables us to achieve plausible structures with a speed-up of 80-500x compared to popular docking software , offering a promising competitive alternative to current solutions for this problem . 2 RELATED WORK . Geometric Deep Learning . Graph Neural Networks ( GNNs ) are becoming the de facto choice for learning with graph data ( Bruna et al. , 2013 ; Defferrard et al. , 2016 ; Kipf and Welling , 2016 ; Gilmer et al. , 2017 ; Xu et al. , 2018 ; Li et al. , 2019 ) . Motivated by symmetries naturally occurring in different data types , architectures are tailored to explicitly incorporate such properties ( Cohen and Welling , 2016a ; b ; Thomas et al. , 2018 ; Fuchs et al. , 2020 ; Finzi et al. , 2020 ; Eismann et al. , 2020 ; Satorras et al. , 2021 ) . GNNs are validated in a variety of tasks such as particle system dynamics or conformation-based energy estimation ( Weiler and Cesa , 2019 ; Rezende et al. , 2019 ) . Euclidean Neural Networks ( E ( 3 ) -NNs ) . However , plain GNNs and other deep learning methods do not understand data naturally lying in the 3D Euclidean space . For example , how should the output deterministically change with the input , e.g . when it is rotated ? The recent Euclidean neural networks address this problem , being designed from geometric first-principles . They make use of SE ( 3 ) - equivariant and invariant neural layers , thus avoiding expensive data augmentation strategies . Such constrained models ease optimization and have shown important improvements in biology or chemistry – e.g . for molecular structures ( Fuchs et al. , 2020 ; Hutchinson et al. , 2020 ; Wu et al. , 2021 ; Jumper et al. , 2021 ; Ganea et al. , 2021 ) and different types of 3D point clouds ( Thomas et al. , 2018 ) . Different from prior work , we here derive constraints for pairs of 3D objects via pairwise independent SE ( 3 ) -equivariances , and design a principled approach for modeling rigid body docking . Protein Folding . Deep neural networks have been used to predict inter-residue contacts , distance and/or orientations ( Adhikari and Cheng , 2018 ; Yang et al. , 2020 ; Senior et al. , 2020 ; Ju et al. , 2021 ) , that are subsequently transformed into additional constraints or differentiable energy terms for protein structure optimization . ALPHAFOLD 2 ( Jumper et al. , 2021 ) and Rosetta Fold ( Baek et al. , 2021 ) are state-of-the-art approaches , and directly predict protein structures from co-evolution information embedded in homologous sequences , using geometric deep learning and E ( 3 ) -NNs . Protein-Protein Docking and Interaction . Experimentally determining structures of protein complexes is often expensive and time-consuming , rendering a premium on computational methods ( Vakser , 2014 ) . Protein docking methods ( Chen et al. , 2003 ; Venkatraman et al. , 2009 ; De Vries et al. , 2010 ; Biesiada et al. , 2011 ; Torchala et al. , 2013 ; Schindler et al. , 2017 ; Weng et al. , 2019 ; Sunny and Jayaraj , 2021 ; Christoffer et al. , 2021 ; Yan et al. , 2020 ) typically run several steps : first , they sample thousands or millions of complex candidates ; second , they use a scoring function for ranking ( Moal et al. , 2013 ; Basu and Wallner , 2016 ; Launay et al. , 2020 ; Eismann et al. , 2020 ) ; finally , top-ranked candidates undergo a structure refinement process using energy or geometric models ( Verburgt and Kihara , 2021 ) . Relevant to protein-protein interaction ( PPI ) is the task of protein interface prediction where GNNs have showed promise ( Fout et al. , 2017 ; Townshend et al. , 2019 ; Liu et al. , 2020 ; Xie and Xu , 2021 ; Dai and Bailey-Kellogg , 2021 ) . Recently , ALPHAFOLD 2 and ROSETTAFOLD have been utilized as subroutines to improve PPIs from different aspects ( Humphreys et al. , 2021 ; Pei et al. , 2021 ; Jovine ) , e.g. , combining physics-based docking method CLUSPRO ( Kozakov et al. , 2017 ; Ghani et al. , 2021 ) , or using extended multiple-sequence alignments to predict the structure of heterodimeric protein complexes from the sequence information ( Bryant et al. , 2021 ) . Concurrently to our work , Evans et al . ( 2021 ) extend ALPHAFOLD 2 to multiple chains during both training and inference . Drug-Target Interaction ( DTI ) . DTI aims to compute drug-target binding poses and affinity , playing an essential role in understanding drugs ’ mechanism of action . Prior methods ( Wallach et al. , 2015 ; Li et al. , 2021 ) predict binding affinity from protein-ligand co-crystal structures , but such data is expensive to obtain experimentally . These models are typically based on heavy candidate sampling and ranking ( Trott and Olson , 2010 ; Koes et al. , 2013 ; McNutt et al. , 2021 ; Bao et al. , 2021 ) , being tailored for small drug-like ligands and often assuming known binding pocket . Thus , they are not immediately applicable to our use case . In contrast , our rigid docking approach is generic and could be extended to accelerate DTI research as part of future work . 3 MATHEMATICAL CONSTRAINTS FOR RIGID BODY DOCKING . We start by introducing the rigid body docking problem and derive the geometric constraints for enforcing same output complex prediction regardless of the initial unbound positions or roles ( Fig . 2 ) . Rigid Protein-Protein Docking – Problem Setup . We are given as input a pair of proteins forming a complex . They are ( arbitrarily ) denoted as the ligand and receptor , consisting of n and m residues , respectively . These proteins are represented in their bound ( docked ) state as 3D point clouds X∗1 ∈ R3×n , X∗2 ∈ R3×m , where each residue ’ s location is given by the coordinates of its corresponding α-carbon atom . In the unbound state , the docked ligand is randomly rotated and translated in space , resulting in a modified point cloud X1 ∈ R3×n . For simplicity and w.l.o.g. , the receptor remains in its bound location X2 = X∗2 . The task is to predict a rotation R ∈ SO ( 3 ) and a translation t ∈ R3 such that RX1 + t = X∗1 , using as input the proteins and their unbound positions X1 and X2 . Here , R = R ( X1|X2 ) and t = t ( X1|X2 ) are functions of the two proteins , where we omit residue identity or other protein information in this notation , for brevity . Note that we assume rigid backbone and side-chains for both proteins . We therefore do not tackle the more challenging problem of flexible docking , but our approach offers an important step towards it . We desire that the predicted complex structure is independent of the initial locations and orientations of the two proteins , as well as of their roles – see Fig . 2 . Formally , we wish to guarantee that : ( R ( Z1|Z2 ) Z1 + t ( Z1|Z2 ) ) ⊕ Z2 ≡ ( R ( X1|X2 ) X1 + t ( X1|X2 ) ) ⊕X2 , ( SE ( 3 ) -invariance ) ( R ( X1|X2 ) X1 + t ( X1|X2 ) ) ⊕X2 ≡ X1 ⊕ ( R ( X2|X1 ) X2 + t ( X2|X1 ) ) , ( commutativity ) ∀Q1 , Q2 ∈ SO ( 3 ) , ∀g1 , g2 ∈ R3 , ∀X1 ∈ R3×n , X2 ∈ R3×m , and Zl = QlXl + gl , l ∈ { 1 , 2 } . ( 1 ) KÉÏ ïËÏÊ PIRtbÉLÉÏ r.tt Ï HÉ ï ï PFRibÉLÉÏITE for any rotations Q1 , Q2 and translations g1 , g2 , where ⊕ is concatenation along columns , and ≡ denotes identity after superimposition , i.e . zero Root-Mean-Square Deviation ( RMSD ) between the two 3D point sets after applying the Kabsch algorithm ( Kabsch , 1976 ) . An immediate question arises : How do the constraints in Eq . ( 1 ) translate into constraints for R ( ·|· ) and t ( ·|· ) ? The rotation R and translation t change in a systematic way when we apply SE ( 3 ) transformations or swap proteins ’ roles . These properties restrict our class of functions as derived below . SE ( 3 ) -equivariance Constraints . If we apply any distinct SE ( 3 ) transformations on the unbound ligand X1 and receptor X2 , i.e . we now dock Q1X1 + g1 onto Q2X2 + g2 , then the rotation matrix R ( Q1X1 +g1|Q2X2 +g2 ) and translation vector t ( Q1X1 +g1|Q2X2 +g2 ) can be derived from the original R ( X1|X2 ) and t ( X1|X2 ) assuming that we always do rotations first . In this case , R ( Q1X1 + g1|Q2X2 + g2 ) can be decomposed into three rotations : i . ) apply Q > 1 to undo the rotation Q1 applied on X1 , ii . ) apply R ( X1|X2 ) , iii . ) apply Q2 to rotate the docked ligand together with the receptor . This gives R ( Q1X1 + g1|Q2X2 + g2 ) = Q2R ( X1|X2 ) Q > 1 , which in turn constraints the translation vector . We provide a formal statement and prove it in Appendix B.1 : Proposition 1 . For any Q1 , Q2 ∈ SO ( 3 ) , g1 , g2 ∈ R3 , SE ( 3 ) -invariance of the predicted docked complex defined by Eq . ( 1 ) is guaranteed iff R ( Q1X1 + g1|Q2X2 + g2 ) = Q2R ( X1|X2 ) Q > 1 t ( Q1X1 + g1|Q2X2 + g2 ) = Q2t ( X1|X2 ) −Q2R ( X1|X2 ) Q > 1 g1 + g2 . ( 2 ) As a direct consequence of this proposition , we have the following statement . Proposition 2 . Any model satisfying Proposition 1 guarantees invariance of the predicted complex w.r.t . any SE ( 3 ) transformation on X1 , and equivariance w.r.t . any SE ( 3 ) transformation on X2 : R ( Z1|X2 ) Z1 + t ( Z1|X2 ) = R ( X1|X2 ) X1 + t ( X1|X2 ) , where Z1 = Q1X1 + g1 R ( X1|Z2 ) X1 + t ( X1|Z2 ) = Q2 [ R ( X1|X2 ) X1 + t ( X1|X2 ) ] + g2 , where Z2 = Q2X2 + g2 ∀Q1 , Q2 ∈ SO ( 3 ) , ∀g1 , g2 ∈ R3 , ∀X1 ∈ R3×n , ∀X2 ∈ R3×m . Commutativity . Instead of docking X1 with respect to X2 , we can also dock X2 with respect to X1 . In this case , we require the final complex structures to be identical after superimposition , i.e. , zero RMSD . This property is named commutativity and it is satisfied as follows ( proof in Appendix B.2 ) . Proposition 3 . Commutativity as defined by Eq . ( 1 ) is guaranteed iff R ( X2|X1 ) = R > ( X1|X2 ) ; t ( X2|X1 ) = −R > ( X1|X2 ) t ( X1|X2 ) , ( 3 ) Point Permutation Invariance . We also enforce residue permutation invariance . Formally , both R ( X1|X2 ) and t ( X1|X2 ) should not depend on the order or columns of X1 and , resp. , of X2 . | This paper proposes an end-to-end deep learning architecture to model the rigid body protein docking problem. By incorporating the inductive biases of SE(3)-invariance of the final docking position and commutativity, the proposed method avoids the millions of sampling and achieves a competitive performance with much faster speed. In addition, they discover and align keypoints by the attention-based selection algorithm and use optimal transport to predict the binding pocket location based on those selected points. The main contribution of this paper is the combination of the novel graph matching networks and keypoint selection algorithm to predict the 3D position of the docking model. Results are shown on the task of 1) Protein docking complex prediction 2) Runtime | SP:d5bdd82960013ea8c01a0bac94ed6d293dc48cff |
Independent SE(3)-Equivariant Models for End-to-End Rigid Protein Docking | Protein complex formation is a central problem in biology , being involved in most of the cell ’ s processes , and essential for applications , e.g . drug design or protein engineering . We tackle rigid body protein-protein docking , i.e. , computationally predicting the 3D structure of a protein-protein complex from the individual unbound structures , assuming no conformational change within the proteins happens during binding . We design a novel pairwise-independent SE ( 3 ) -equivariant graph matching network to predict the rotation and translation to place one of the proteins at the right docked position relative to the second protein . We mathematically guarantee a basic principle : the predicted complex is always identical regardless of the initial locations and orientations of the two structures . Our model , named EQUIDOCK , approximates the binding pockets and predicts the docking poses using keypoint matching and alignment , achieved through optimal transport and a differentiable Kabsch algorithm . Empirically , we achieve significant running time improvements and often outperform existing docking software despite not relying on heavy candidate sampling , structure refinement , or templates . 1 INTRODUCTION protein Z protein Z protein Z-dependent inhibitor protein Z-dependent inhibitor a. b. PDB ID : 3F1S Figure 1 : Different views of the 3D structure of a protein complex . a . Surface and b. cartoon view of protein Z and its inhibitor . In a recent breakthrough , ALPHAFOLD 2 ( Jumper et al. , 2021 ; Senior et al. , 2020 ) provides a solution to a grand challenge in biology—inferring a protein ’ s three-dimensional structure from its amino acid sequence ( Baek et al. , 2021 ) , following the dogma sequence determines structure . Besides their complex three-dimensional nature , proteins dynamically alter their function and structure in response to cellular signals , changes in the environment , or upon molecular docking . In par- ticular , protein interactions are involved in various biological processes including signal transduction , protein synthesis , DNA replication and repair . Molecular docking is key to understanding protein interactions ’ mechanisms and effects , and , subsequently , to developing therapeutic interventions . We here address the problem of rigid body protein-protein docking which refers to computationally predicting the 3D structure of a protein-protein complex given the 3D structures of the two proteins in unbound state . Rigid body means no deformations occur within any protein during binding , which is a realistic assumption in many biological settings . Popular docking software ( Chen et al. , 2003 ; Venkatraman et al. , 2009 ; De Vries et al. , 2010 ; Torchala et al. , 2013 ; Schindler et al. , 2017 ; Sunny and Jayaraj , 2021 ) are typically computationally expensive , taking between minutes and hours to solve a single example pair , while not being guaranteed to find accurate complex structures . These methods largely follow the steps : i . ) randomly sample a large number ( e.g. , millions ) of candidate initial complex structures , ii . ) employ a scoring function to rank the candidates , iii . ) adjust and refine the top complex structures based on an energy model ( e.g. , force field ) . We here take a first step towards tackling these issues by using deep learning models for direct prediction of protein complex structures . Contributions . We design EQUIDOCK , a fast , end-to-end method for rigid body docking that directly predicts the SE ( 3 ) transformation to place one of the proteins ( ligand ) at the right location and orientation with respect to the second protein ( receptor ) . Our method is based on the principle that the exact same complex structure should be predicted irrespectively of the initial 3D placements and roles of both constituents ( see Fig . 2 ) . We achieve this desideratum by incorporating the inductive biases of pairwise SE ( 3 ) –equivariance and commutativity , and deriving novel theoretical results for necessary and sufficient model constraints ( see Section 3 ) . Next , we create EQUIDOCK to satisfy these properties by design , being a combination of : i ) a novel type of pairwise independent SE ( 3 ) -equivariant graph matching networks , ii ) an attention-based keypoint selection algorithm that discovers representative points and aligns them with the binding pocket residues using optimal transport , and iii ) a differentiable superimposition model to recover the optimal global rigid transformation . Unlike prior work , our method does not use heavy candidate sampling or ranking , templates , task-specific geometric or chemical hand-crafted features , or pre-computed meshes . This enables us to achieve plausible structures with a speed-up of 80-500x compared to popular docking software , offering a promising competitive alternative to current solutions for this problem . 2 RELATED WORK . Geometric Deep Learning . Graph Neural Networks ( GNNs ) are becoming the de facto choice for learning with graph data ( Bruna et al. , 2013 ; Defferrard et al. , 2016 ; Kipf and Welling , 2016 ; Gilmer et al. , 2017 ; Xu et al. , 2018 ; Li et al. , 2019 ) . Motivated by symmetries naturally occurring in different data types , architectures are tailored to explicitly incorporate such properties ( Cohen and Welling , 2016a ; b ; Thomas et al. , 2018 ; Fuchs et al. , 2020 ; Finzi et al. , 2020 ; Eismann et al. , 2020 ; Satorras et al. , 2021 ) . GNNs are validated in a variety of tasks such as particle system dynamics or conformation-based energy estimation ( Weiler and Cesa , 2019 ; Rezende et al. , 2019 ) . Euclidean Neural Networks ( E ( 3 ) -NNs ) . However , plain GNNs and other deep learning methods do not understand data naturally lying in the 3D Euclidean space . For example , how should the output deterministically change with the input , e.g . when it is rotated ? The recent Euclidean neural networks address this problem , being designed from geometric first-principles . They make use of SE ( 3 ) - equivariant and invariant neural layers , thus avoiding expensive data augmentation strategies . Such constrained models ease optimization and have shown important improvements in biology or chemistry – e.g . for molecular structures ( Fuchs et al. , 2020 ; Hutchinson et al. , 2020 ; Wu et al. , 2021 ; Jumper et al. , 2021 ; Ganea et al. , 2021 ) and different types of 3D point clouds ( Thomas et al. , 2018 ) . Different from prior work , we here derive constraints for pairs of 3D objects via pairwise independent SE ( 3 ) -equivariances , and design a principled approach for modeling rigid body docking . Protein Folding . Deep neural networks have been used to predict inter-residue contacts , distance and/or orientations ( Adhikari and Cheng , 2018 ; Yang et al. , 2020 ; Senior et al. , 2020 ; Ju et al. , 2021 ) , that are subsequently transformed into additional constraints or differentiable energy terms for protein structure optimization . ALPHAFOLD 2 ( Jumper et al. , 2021 ) and Rosetta Fold ( Baek et al. , 2021 ) are state-of-the-art approaches , and directly predict protein structures from co-evolution information embedded in homologous sequences , using geometric deep learning and E ( 3 ) -NNs . Protein-Protein Docking and Interaction . Experimentally determining structures of protein complexes is often expensive and time-consuming , rendering a premium on computational methods ( Vakser , 2014 ) . Protein docking methods ( Chen et al. , 2003 ; Venkatraman et al. , 2009 ; De Vries et al. , 2010 ; Biesiada et al. , 2011 ; Torchala et al. , 2013 ; Schindler et al. , 2017 ; Weng et al. , 2019 ; Sunny and Jayaraj , 2021 ; Christoffer et al. , 2021 ; Yan et al. , 2020 ) typically run several steps : first , they sample thousands or millions of complex candidates ; second , they use a scoring function for ranking ( Moal et al. , 2013 ; Basu and Wallner , 2016 ; Launay et al. , 2020 ; Eismann et al. , 2020 ) ; finally , top-ranked candidates undergo a structure refinement process using energy or geometric models ( Verburgt and Kihara , 2021 ) . Relevant to protein-protein interaction ( PPI ) is the task of protein interface prediction where GNNs have showed promise ( Fout et al. , 2017 ; Townshend et al. , 2019 ; Liu et al. , 2020 ; Xie and Xu , 2021 ; Dai and Bailey-Kellogg , 2021 ) . Recently , ALPHAFOLD 2 and ROSETTAFOLD have been utilized as subroutines to improve PPIs from different aspects ( Humphreys et al. , 2021 ; Pei et al. , 2021 ; Jovine ) , e.g. , combining physics-based docking method CLUSPRO ( Kozakov et al. , 2017 ; Ghani et al. , 2021 ) , or using extended multiple-sequence alignments to predict the structure of heterodimeric protein complexes from the sequence information ( Bryant et al. , 2021 ) . Concurrently to our work , Evans et al . ( 2021 ) extend ALPHAFOLD 2 to multiple chains during both training and inference . Drug-Target Interaction ( DTI ) . DTI aims to compute drug-target binding poses and affinity , playing an essential role in understanding drugs ’ mechanism of action . Prior methods ( Wallach et al. , 2015 ; Li et al. , 2021 ) predict binding affinity from protein-ligand co-crystal structures , but such data is expensive to obtain experimentally . These models are typically based on heavy candidate sampling and ranking ( Trott and Olson , 2010 ; Koes et al. , 2013 ; McNutt et al. , 2021 ; Bao et al. , 2021 ) , being tailored for small drug-like ligands and often assuming known binding pocket . Thus , they are not immediately applicable to our use case . In contrast , our rigid docking approach is generic and could be extended to accelerate DTI research as part of future work . 3 MATHEMATICAL CONSTRAINTS FOR RIGID BODY DOCKING . We start by introducing the rigid body docking problem and derive the geometric constraints for enforcing same output complex prediction regardless of the initial unbound positions or roles ( Fig . 2 ) . Rigid Protein-Protein Docking – Problem Setup . We are given as input a pair of proteins forming a complex . They are ( arbitrarily ) denoted as the ligand and receptor , consisting of n and m residues , respectively . These proteins are represented in their bound ( docked ) state as 3D point clouds X∗1 ∈ R3×n , X∗2 ∈ R3×m , where each residue ’ s location is given by the coordinates of its corresponding α-carbon atom . In the unbound state , the docked ligand is randomly rotated and translated in space , resulting in a modified point cloud X1 ∈ R3×n . For simplicity and w.l.o.g. , the receptor remains in its bound location X2 = X∗2 . The task is to predict a rotation R ∈ SO ( 3 ) and a translation t ∈ R3 such that RX1 + t = X∗1 , using as input the proteins and their unbound positions X1 and X2 . Here , R = R ( X1|X2 ) and t = t ( X1|X2 ) are functions of the two proteins , where we omit residue identity or other protein information in this notation , for brevity . Note that we assume rigid backbone and side-chains for both proteins . We therefore do not tackle the more challenging problem of flexible docking , but our approach offers an important step towards it . We desire that the predicted complex structure is independent of the initial locations and orientations of the two proteins , as well as of their roles – see Fig . 2 . Formally , we wish to guarantee that : ( R ( Z1|Z2 ) Z1 + t ( Z1|Z2 ) ) ⊕ Z2 ≡ ( R ( X1|X2 ) X1 + t ( X1|X2 ) ) ⊕X2 , ( SE ( 3 ) -invariance ) ( R ( X1|X2 ) X1 + t ( X1|X2 ) ) ⊕X2 ≡ X1 ⊕ ( R ( X2|X1 ) X2 + t ( X2|X1 ) ) , ( commutativity ) ∀Q1 , Q2 ∈ SO ( 3 ) , ∀g1 , g2 ∈ R3 , ∀X1 ∈ R3×n , X2 ∈ R3×m , and Zl = QlXl + gl , l ∈ { 1 , 2 } . ( 1 ) KÉÏ ïËÏÊ PIRtbÉLÉÏ r.tt Ï HÉ ï ï PFRibÉLÉÏITE for any rotations Q1 , Q2 and translations g1 , g2 , where ⊕ is concatenation along columns , and ≡ denotes identity after superimposition , i.e . zero Root-Mean-Square Deviation ( RMSD ) between the two 3D point sets after applying the Kabsch algorithm ( Kabsch , 1976 ) . An immediate question arises : How do the constraints in Eq . ( 1 ) translate into constraints for R ( ·|· ) and t ( ·|· ) ? The rotation R and translation t change in a systematic way when we apply SE ( 3 ) transformations or swap proteins ’ roles . These properties restrict our class of functions as derived below . SE ( 3 ) -equivariance Constraints . If we apply any distinct SE ( 3 ) transformations on the unbound ligand X1 and receptor X2 , i.e . we now dock Q1X1 + g1 onto Q2X2 + g2 , then the rotation matrix R ( Q1X1 +g1|Q2X2 +g2 ) and translation vector t ( Q1X1 +g1|Q2X2 +g2 ) can be derived from the original R ( X1|X2 ) and t ( X1|X2 ) assuming that we always do rotations first . In this case , R ( Q1X1 + g1|Q2X2 + g2 ) can be decomposed into three rotations : i . ) apply Q > 1 to undo the rotation Q1 applied on X1 , ii . ) apply R ( X1|X2 ) , iii . ) apply Q2 to rotate the docked ligand together with the receptor . This gives R ( Q1X1 + g1|Q2X2 + g2 ) = Q2R ( X1|X2 ) Q > 1 , which in turn constraints the translation vector . We provide a formal statement and prove it in Appendix B.1 : Proposition 1 . For any Q1 , Q2 ∈ SO ( 3 ) , g1 , g2 ∈ R3 , SE ( 3 ) -invariance of the predicted docked complex defined by Eq . ( 1 ) is guaranteed iff R ( Q1X1 + g1|Q2X2 + g2 ) = Q2R ( X1|X2 ) Q > 1 t ( Q1X1 + g1|Q2X2 + g2 ) = Q2t ( X1|X2 ) −Q2R ( X1|X2 ) Q > 1 g1 + g2 . ( 2 ) As a direct consequence of this proposition , we have the following statement . Proposition 2 . Any model satisfying Proposition 1 guarantees invariance of the predicted complex w.r.t . any SE ( 3 ) transformation on X1 , and equivariance w.r.t . any SE ( 3 ) transformation on X2 : R ( Z1|X2 ) Z1 + t ( Z1|X2 ) = R ( X1|X2 ) X1 + t ( X1|X2 ) , where Z1 = Q1X1 + g1 R ( X1|Z2 ) X1 + t ( X1|Z2 ) = Q2 [ R ( X1|X2 ) X1 + t ( X1|X2 ) ] + g2 , where Z2 = Q2X2 + g2 ∀Q1 , Q2 ∈ SO ( 3 ) , ∀g1 , g2 ∈ R3 , ∀X1 ∈ R3×n , ∀X2 ∈ R3×m . Commutativity . Instead of docking X1 with respect to X2 , we can also dock X2 with respect to X1 . In this case , we require the final complex structures to be identical after superimposition , i.e. , zero RMSD . This property is named commutativity and it is satisfied as follows ( proof in Appendix B.2 ) . Proposition 3 . Commutativity as defined by Eq . ( 1 ) is guaranteed iff R ( X2|X1 ) = R > ( X1|X2 ) ; t ( X2|X1 ) = −R > ( X1|X2 ) t ( X1|X2 ) , ( 3 ) Point Permutation Invariance . We also enforce residue permutation invariance . Formally , both R ( X1|X2 ) and t ( X1|X2 ) should not depend on the order or columns of X1 and , resp. , of X2 . | The paper proposes a SE(3) equivariant graph matching network for end-to-end rigid protein docking. They propose a novel optimal transport loss to approximate binding pocket and a differentiable Kabsch algorithm to predict the docking pose. They achieve significant running time improvements over existing protein docking software with competitive results, and do not rely on heavy sampling, structure refinement, or templates | SP:d5bdd82960013ea8c01a0bac94ed6d293dc48cff |
Bi-linear Value Networks for Multi-goal Reinforcement Learning | 1 INTRODUCTION ( a ) Move towards goals ( b ) Bilinear Decomposition Figure 1 : ( a ) The value towards a goal depends on both the current state s and the goal g which is far away . ( b ) we can capture this relationship by decomposing the value function into a bi-linear product between a local vector field ~f ( s , a ) and a global vector field , ~φ ( s , g ) . Gray arrows indicate the vector field ~φ ( s , g ) evaluated at all states . The black arrow indicates the best alignment with ~f ( s , a ) . Constructing agents capable of accomplishing a diverse set of goals is a long standing challenge in reinforcement learning ( Kaelbling , 1993 ) . A major issue is the high sample complexity resulting from interference caused by learning a single policy or value function for a multitude of goals . This issue can be partially mitigated by making efficient reuse of past interaction data , such as employing off-policy learning algorithms , along with hindsight experience re-labeling ( HER , see Andrychowicz et al . 2017 ) . A complementary approach improves data efficiency by encoding inductive biases in the neural network , such as the graph structure ( Li et al. , 2019 ) . Such a structure enables sharing information across goals and thereby mitigates interference and results in better generalization . In multi-goal reinforcement learning , a single , goal-conditioned universal value function ( UVFA Schaul et al . 2015 ) approximates the long-term return for a variety of goals . One possibility is to model the UVFA as a monolithic neural network , Qθ ( s , a , g ) , where state s , action a and goal g ( or the embedding of which ) are simply concatenated together as input . In such form , there is no explicit inductive bias for the network to discover shared structures between goals that could otherwise greatly improve the performance when the agent is tasked with a new goal ( Sutton et al. , 2011 ) . This ability to transfer to new goals when learning online , as the ability for the policy to perform given limited data has a significant compounding effect through the active collection of interactive data . Separating the local knowledge of the dynamics , and the global topology of the domain is a natural way to disentangle the problem . Inspired by this dichotomy , we decompose goal-conditioned value approximation into two disentangled concerns “ where to go ” and “ what happens next ” . “ Where to go ” models how should the state be changed to get closer to the goal , while “ what I can do ” captures where the agent can move at the current state . The knowledge of “ what I can do ” is independent of “ where to go ” and thus can be re-used across new goals . We illustrate this intuition in figure 1a . As an analogy to “ what I can do ” , the red arrow denotes the succeeding state after taking an action at state s , which is goal-agnostic . Independent of action , the blue arrow represents “ where to go ” that can be viewed as a direction to the goal g from the current state s. Adhering to this intuition , we thus treat value predictions as the interactions between two vectors . Consider “ what I can do ” and “ where to go ” as two vector fields ~f ( s , a ) and ~ϕ ( s , g ) in figure 1b . It is natural to define the value predictions as the level of alignment between two vector field ~f and ~ϕ . The maximum value implicitly emerges when “ what I can do ” ( ~f ( s , a ) ) corresponding to taking an action a aligns “ where to go ” ( ~ϕ ( s , g ) ) . In fact , our intuition resembles bilinear mapping in vector analysis , that parametrizes a scalar function by two vector spaces . Our principal contribution is bi-linear value network ( BVN ) , a parameterization scheme that decomposes the goal-conditioned value function into a bilinear map between two distinct vector representations . The first component φ ( s , g ) captures the long-range topology between the current state and a distant goal , whereas the second component f ( s , a ) is akin to a local model that represents taking an immediate action at the current state . To understand how this parameterization affects learning dynamics , we evaluate the agent on goals that never appeared during training . Surprisingly , we found that the bi-linear decomposition allows the critic to generalize to unseen goals ( see section 4.3 ) , which in turn improves the overall sample complexity and policy performance . We evaluate our approach on the challenging task of dexterous manipulation with a simulated shadow hand and other object manipulation tasks . Our method , BVN , achieves state-of-the-art sample efficiency and asymptotic performance on the majority of tasks . Apart from comparing with prior works , we also produce detailed analysis on the influence of the dimensionality of the two latent spaces , and how different constructions of the binary mapping affects performance . 2 PRELIMINARIES . 2.1 MULTI-GOAL REINFORCEMENT LEARNING . We consider a special case of the Markov decision process ( MDP ) , the multi-goal reinforcement learning ( RL ) problem ( Kaelbling , 1993 ) . At the beginning of an episode , an initial state s0 and a behavior goal gb is sampled according to the distribution ρS and ρG . The behavior goal gb is fixed throughout the episode during roll-out by the policy π . For each time step t , the agent takes action at = π ( st , gb ) , receives reward rt , gb = R ( st , at , gb ) , and moves to the next state st+1 . We consider an infinite horizon MDP problem with the discount factor γ . The goal of multi-goal RL is to produce a policy π∗ that maximizes the expected return J π∗ = argmax π J ( π ) where J ( π ) = E [ ∞∑ τ=t γτ−trτ , gb |st = s , g = gb ] , ( 1 ) where the discount factor γ is set as 0.98 in common multi-goal RL benchmarks ( Plappert et al. , 2018 ) , and the reward rτ , gb is typically defined as R ( sτ , aτ , gb ) : = { 0 , goal reached −1 , otherwise ( 2 ) Note that our method , BVN , is not dependent on this reward structure . 2.2 OFF-POLICY RL WITH ACTOR-CRITIC METHODS . As we consider multi-goal continuous control tasks , we follow Andrychowicz et al . ( 2017 ) and Plappert et al . ( 2018 ) and use deterministic policy gradient algorithm ( DDPG ) ( Silver et al. , 2014 ) to learn a π∗ . DDPG is an actor-critic method . Note that a more advanced actor-critic method ( Fujimoto et al. , 2018 ) can be used , but we empirically found that DDPG is better than that in the tasks we consider . In actor-critic methods the value function , referred to as the critic , is responsible for generating the learning signal of π . The critic is trained by minimizing the loss function L ( Q ) = E ( st , at ) ∼Uniform ( Z ) ( rt , g + γQ ( st+1 , π ( st+1 , g ) , g ) −Q ( st , at , g ) ) 2 , ( 3 ) where Z denotes a replay buffer ( Mnih et al. , 2015 ) that stores multiple state transitions tuples ( st , at , rt , st+1 , gb ) . The actor π is trained to maximize the critic outputs by the gradient ∇πJ ( π ) = E [ ∇aQπ ( s , a , g ) |a=π ( s , g ) ] . ( 4 ) In multi-goal RL settings , the value function Q is often referred as universal value function approximator ( Schaul et al. , 2015 ) since Q encompasses the values of all goals in the MDP . As we are particularly interested in sample efficiency of policy learning , we highlight the importance of the critic for the sample efficiency of training the actor . A critic that provides better estimate of values for previously unseen states ( i.e. , better generalization of the critic ) will lead to faster policy improvement via optimization in Equation 4 . 3 BI-LINEAR VALUE DECOMPOSITION FOR MULTI-GOAL RL . The key insight behind the bilinear value network architecture , as illustrated in figure 2 , is that we can often decompose value estimate into the alignment between the concern of “ what I can do ” and “ where I want to go. ” When these two concerns are implicitly aligned , we consider the action to be good for reaching that goal . Whereas if these two are misaligned , the action is considered bad . These two concerns interact with each other when we try to find the solution to what I can do , but they are also disentangled because they take in different inputs . “ What I can do , ” for example , only concerns the current state of affair and the possible set of actions . When a new goal appears the agent would not have to reconsider the relationship between its current state and the available actions , therefore lowers the burden to learn . It does however need to update what it knows about getting to that goal from where it is , which is inescapable . To bring this insight into reality , we design a drop-in replacement of the standard universal value function approximator , as illustrated in figure 3 , which we refer to as the bilinear value network . For context we present the standard architecture of a universal value function approximator ( UVFA ) on the left ( see figure 3a ) . The UVFA is a single , monolithic neural network which is entangled in the way it processes the inputs . It first concatenates the state , action and the goal together into a single vector , and does not impose any inductive bias into the way these inputs interact . With bilinear value networks ( see figure 3b ) , we partition the three input vectors into two overlapping groups . In the first group that we consider to be local , the neural network ~f ( s , a ) is only concerned with the current state and the immediate actions the agent can take . This is the component that is relatively easier to learn , because it does not have to integrate over long horizons . The second group is more global . The neural network ~φ ( s , g ) captures the long-horizon relationship between the current state and the goal which can be quite far apart . To bring the information that are processed separately by these two components , we borrow the concept of bilinear map from vector analysis , and define the Q function as a dot product between the two distinct vector representations Q : Zf × Zφ 7→ R. ( 5 ) A consequence of this treatment is that the value becomes the result of an alignment between the two vector fields : Q ( s , a , g ) = ~f ( s , a ) > ~φ ( s , g ) . ( 6 ) In figure 2 , we show that passing the current state s into the global stream φ ( s , g ) is important , because to find the solution to the optimal action , the global field needs to vary depending on the current state . Figure 2a shows a goal stream that does not take into the current state – the vector field becomes a constant ∀s ∈ S , making it impossible to accommodate the complex behavior needed to succeed from the entire state space . An important issue to keep in mind is that Equation 6 is unidentifiable in the statistical sense because we can insert an arbitrary vector λ into the vector space and produce the same value estimate , as long as λ contains no zeros . In statistics , identifiability is the condition under which we can recover the true parameter of the model given infinite samples . Q ( s , a , g ) = f ( s , a ) > φ ( g ) ⇐⇒ Q ( s , a , g ) = ( λf ) > ( λ−1φ ) ∀ λ ∈ Rn . ( 7 ) What this means is that under end-to-end training , the particular semantics of the two vector fields becomes particularly irrelevant . It is the grouping of the input variables and the bilinear structure that is critical . It is also important to note that the bilinear value networks is implemented as a drop-in replacement of the universal value function approximator , as opposed to any additional algorithmic step . The training procedure we adopt in this paper follows those of deep deterministic policy gradient and hindsight experience replay , but the bilinear value networks is equally applicable to other off-policy learning algorithms under goal-conditioned scenario that uses either a value function , or a critic . | The paper proposes a modification to goal-oriented universal value functions that split the neural network into two parts. One network accepts states and actions and outputs a vector representation, while the other outputs a vector given a state and goal. Part of the contribution of the paper is the interpretation of these two vectors --- the first captures the notion of what actions can be taken at a given state, while the second represents the direction the agent should move towards to achieve the goal from its current state. Empirical results on several simulated robotic domains demonstrate that the method outperforms other UVFA architectures, while ablations are provided to capture the most important aspects of the method. | SP:7d20e7d43a75402fa1baa3f9ab6e2311a749fcc6 |
Bi-linear Value Networks for Multi-goal Reinforcement Learning | 1 INTRODUCTION ( a ) Move towards goals ( b ) Bilinear Decomposition Figure 1 : ( a ) The value towards a goal depends on both the current state s and the goal g which is far away . ( b ) we can capture this relationship by decomposing the value function into a bi-linear product between a local vector field ~f ( s , a ) and a global vector field , ~φ ( s , g ) . Gray arrows indicate the vector field ~φ ( s , g ) evaluated at all states . The black arrow indicates the best alignment with ~f ( s , a ) . Constructing agents capable of accomplishing a diverse set of goals is a long standing challenge in reinforcement learning ( Kaelbling , 1993 ) . A major issue is the high sample complexity resulting from interference caused by learning a single policy or value function for a multitude of goals . This issue can be partially mitigated by making efficient reuse of past interaction data , such as employing off-policy learning algorithms , along with hindsight experience re-labeling ( HER , see Andrychowicz et al . 2017 ) . A complementary approach improves data efficiency by encoding inductive biases in the neural network , such as the graph structure ( Li et al. , 2019 ) . Such a structure enables sharing information across goals and thereby mitigates interference and results in better generalization . In multi-goal reinforcement learning , a single , goal-conditioned universal value function ( UVFA Schaul et al . 2015 ) approximates the long-term return for a variety of goals . One possibility is to model the UVFA as a monolithic neural network , Qθ ( s , a , g ) , where state s , action a and goal g ( or the embedding of which ) are simply concatenated together as input . In such form , there is no explicit inductive bias for the network to discover shared structures between goals that could otherwise greatly improve the performance when the agent is tasked with a new goal ( Sutton et al. , 2011 ) . This ability to transfer to new goals when learning online , as the ability for the policy to perform given limited data has a significant compounding effect through the active collection of interactive data . Separating the local knowledge of the dynamics , and the global topology of the domain is a natural way to disentangle the problem . Inspired by this dichotomy , we decompose goal-conditioned value approximation into two disentangled concerns “ where to go ” and “ what happens next ” . “ Where to go ” models how should the state be changed to get closer to the goal , while “ what I can do ” captures where the agent can move at the current state . The knowledge of “ what I can do ” is independent of “ where to go ” and thus can be re-used across new goals . We illustrate this intuition in figure 1a . As an analogy to “ what I can do ” , the red arrow denotes the succeeding state after taking an action at state s , which is goal-agnostic . Independent of action , the blue arrow represents “ where to go ” that can be viewed as a direction to the goal g from the current state s. Adhering to this intuition , we thus treat value predictions as the interactions between two vectors . Consider “ what I can do ” and “ where to go ” as two vector fields ~f ( s , a ) and ~ϕ ( s , g ) in figure 1b . It is natural to define the value predictions as the level of alignment between two vector field ~f and ~ϕ . The maximum value implicitly emerges when “ what I can do ” ( ~f ( s , a ) ) corresponding to taking an action a aligns “ where to go ” ( ~ϕ ( s , g ) ) . In fact , our intuition resembles bilinear mapping in vector analysis , that parametrizes a scalar function by two vector spaces . Our principal contribution is bi-linear value network ( BVN ) , a parameterization scheme that decomposes the goal-conditioned value function into a bilinear map between two distinct vector representations . The first component φ ( s , g ) captures the long-range topology between the current state and a distant goal , whereas the second component f ( s , a ) is akin to a local model that represents taking an immediate action at the current state . To understand how this parameterization affects learning dynamics , we evaluate the agent on goals that never appeared during training . Surprisingly , we found that the bi-linear decomposition allows the critic to generalize to unseen goals ( see section 4.3 ) , which in turn improves the overall sample complexity and policy performance . We evaluate our approach on the challenging task of dexterous manipulation with a simulated shadow hand and other object manipulation tasks . Our method , BVN , achieves state-of-the-art sample efficiency and asymptotic performance on the majority of tasks . Apart from comparing with prior works , we also produce detailed analysis on the influence of the dimensionality of the two latent spaces , and how different constructions of the binary mapping affects performance . 2 PRELIMINARIES . 2.1 MULTI-GOAL REINFORCEMENT LEARNING . We consider a special case of the Markov decision process ( MDP ) , the multi-goal reinforcement learning ( RL ) problem ( Kaelbling , 1993 ) . At the beginning of an episode , an initial state s0 and a behavior goal gb is sampled according to the distribution ρS and ρG . The behavior goal gb is fixed throughout the episode during roll-out by the policy π . For each time step t , the agent takes action at = π ( st , gb ) , receives reward rt , gb = R ( st , at , gb ) , and moves to the next state st+1 . We consider an infinite horizon MDP problem with the discount factor γ . The goal of multi-goal RL is to produce a policy π∗ that maximizes the expected return J π∗ = argmax π J ( π ) where J ( π ) = E [ ∞∑ τ=t γτ−trτ , gb |st = s , g = gb ] , ( 1 ) where the discount factor γ is set as 0.98 in common multi-goal RL benchmarks ( Plappert et al. , 2018 ) , and the reward rτ , gb is typically defined as R ( sτ , aτ , gb ) : = { 0 , goal reached −1 , otherwise ( 2 ) Note that our method , BVN , is not dependent on this reward structure . 2.2 OFF-POLICY RL WITH ACTOR-CRITIC METHODS . As we consider multi-goal continuous control tasks , we follow Andrychowicz et al . ( 2017 ) and Plappert et al . ( 2018 ) and use deterministic policy gradient algorithm ( DDPG ) ( Silver et al. , 2014 ) to learn a π∗ . DDPG is an actor-critic method . Note that a more advanced actor-critic method ( Fujimoto et al. , 2018 ) can be used , but we empirically found that DDPG is better than that in the tasks we consider . In actor-critic methods the value function , referred to as the critic , is responsible for generating the learning signal of π . The critic is trained by minimizing the loss function L ( Q ) = E ( st , at ) ∼Uniform ( Z ) ( rt , g + γQ ( st+1 , π ( st+1 , g ) , g ) −Q ( st , at , g ) ) 2 , ( 3 ) where Z denotes a replay buffer ( Mnih et al. , 2015 ) that stores multiple state transitions tuples ( st , at , rt , st+1 , gb ) . The actor π is trained to maximize the critic outputs by the gradient ∇πJ ( π ) = E [ ∇aQπ ( s , a , g ) |a=π ( s , g ) ] . ( 4 ) In multi-goal RL settings , the value function Q is often referred as universal value function approximator ( Schaul et al. , 2015 ) since Q encompasses the values of all goals in the MDP . As we are particularly interested in sample efficiency of policy learning , we highlight the importance of the critic for the sample efficiency of training the actor . A critic that provides better estimate of values for previously unseen states ( i.e. , better generalization of the critic ) will lead to faster policy improvement via optimization in Equation 4 . 3 BI-LINEAR VALUE DECOMPOSITION FOR MULTI-GOAL RL . The key insight behind the bilinear value network architecture , as illustrated in figure 2 , is that we can often decompose value estimate into the alignment between the concern of “ what I can do ” and “ where I want to go. ” When these two concerns are implicitly aligned , we consider the action to be good for reaching that goal . Whereas if these two are misaligned , the action is considered bad . These two concerns interact with each other when we try to find the solution to what I can do , but they are also disentangled because they take in different inputs . “ What I can do , ” for example , only concerns the current state of affair and the possible set of actions . When a new goal appears the agent would not have to reconsider the relationship between its current state and the available actions , therefore lowers the burden to learn . It does however need to update what it knows about getting to that goal from where it is , which is inescapable . To bring this insight into reality , we design a drop-in replacement of the standard universal value function approximator , as illustrated in figure 3 , which we refer to as the bilinear value network . For context we present the standard architecture of a universal value function approximator ( UVFA ) on the left ( see figure 3a ) . The UVFA is a single , monolithic neural network which is entangled in the way it processes the inputs . It first concatenates the state , action and the goal together into a single vector , and does not impose any inductive bias into the way these inputs interact . With bilinear value networks ( see figure 3b ) , we partition the three input vectors into two overlapping groups . In the first group that we consider to be local , the neural network ~f ( s , a ) is only concerned with the current state and the immediate actions the agent can take . This is the component that is relatively easier to learn , because it does not have to integrate over long horizons . The second group is more global . The neural network ~φ ( s , g ) captures the long-horizon relationship between the current state and the goal which can be quite far apart . To bring the information that are processed separately by these two components , we borrow the concept of bilinear map from vector analysis , and define the Q function as a dot product between the two distinct vector representations Q : Zf × Zφ 7→ R. ( 5 ) A consequence of this treatment is that the value becomes the result of an alignment between the two vector fields : Q ( s , a , g ) = ~f ( s , a ) > ~φ ( s , g ) . ( 6 ) In figure 2 , we show that passing the current state s into the global stream φ ( s , g ) is important , because to find the solution to the optimal action , the global field needs to vary depending on the current state . Figure 2a shows a goal stream that does not take into the current state – the vector field becomes a constant ∀s ∈ S , making it impossible to accommodate the complex behavior needed to succeed from the entire state space . An important issue to keep in mind is that Equation 6 is unidentifiable in the statistical sense because we can insert an arbitrary vector λ into the vector space and produce the same value estimate , as long as λ contains no zeros . In statistics , identifiability is the condition under which we can recover the true parameter of the model given infinite samples . Q ( s , a , g ) = f ( s , a ) > φ ( g ) ⇐⇒ Q ( s , a , g ) = ( λf ) > ( λ−1φ ) ∀ λ ∈ Rn . ( 7 ) What this means is that under end-to-end training , the particular semantics of the two vector fields becomes particularly irrelevant . It is the grouping of the input variables and the bilinear structure that is critical . It is also important to note that the bilinear value networks is implemented as a drop-in replacement of the universal value function approximator , as opposed to any additional algorithmic step . The training procedure we adopt in this paper follows those of deep deterministic policy gradient and hindsight experience replay , but the bilinear value networks is equally applicable to other off-policy learning algorithms under goal-conditioned scenario that uses either a value function , or a critic . | This paper proposes a new decomposition for the universal value function that disentangles local and global components. The global component depends on the goal and state and tells the agent “where to go” and the local component depends on the state and action and tells the agent “what to do”. The authors conduct a set of experiments on a number of environments to demonstrate that this decomposition results in more data efficiency and helps to generalise to the new goals. | SP:7d20e7d43a75402fa1baa3f9ab6e2311a749fcc6 |
Bi-linear Value Networks for Multi-goal Reinforcement Learning | 1 INTRODUCTION ( a ) Move towards goals ( b ) Bilinear Decomposition Figure 1 : ( a ) The value towards a goal depends on both the current state s and the goal g which is far away . ( b ) we can capture this relationship by decomposing the value function into a bi-linear product between a local vector field ~f ( s , a ) and a global vector field , ~φ ( s , g ) . Gray arrows indicate the vector field ~φ ( s , g ) evaluated at all states . The black arrow indicates the best alignment with ~f ( s , a ) . Constructing agents capable of accomplishing a diverse set of goals is a long standing challenge in reinforcement learning ( Kaelbling , 1993 ) . A major issue is the high sample complexity resulting from interference caused by learning a single policy or value function for a multitude of goals . This issue can be partially mitigated by making efficient reuse of past interaction data , such as employing off-policy learning algorithms , along with hindsight experience re-labeling ( HER , see Andrychowicz et al . 2017 ) . A complementary approach improves data efficiency by encoding inductive biases in the neural network , such as the graph structure ( Li et al. , 2019 ) . Such a structure enables sharing information across goals and thereby mitigates interference and results in better generalization . In multi-goal reinforcement learning , a single , goal-conditioned universal value function ( UVFA Schaul et al . 2015 ) approximates the long-term return for a variety of goals . One possibility is to model the UVFA as a monolithic neural network , Qθ ( s , a , g ) , where state s , action a and goal g ( or the embedding of which ) are simply concatenated together as input . In such form , there is no explicit inductive bias for the network to discover shared structures between goals that could otherwise greatly improve the performance when the agent is tasked with a new goal ( Sutton et al. , 2011 ) . This ability to transfer to new goals when learning online , as the ability for the policy to perform given limited data has a significant compounding effect through the active collection of interactive data . Separating the local knowledge of the dynamics , and the global topology of the domain is a natural way to disentangle the problem . Inspired by this dichotomy , we decompose goal-conditioned value approximation into two disentangled concerns “ where to go ” and “ what happens next ” . “ Where to go ” models how should the state be changed to get closer to the goal , while “ what I can do ” captures where the agent can move at the current state . The knowledge of “ what I can do ” is independent of “ where to go ” and thus can be re-used across new goals . We illustrate this intuition in figure 1a . As an analogy to “ what I can do ” , the red arrow denotes the succeeding state after taking an action at state s , which is goal-agnostic . Independent of action , the blue arrow represents “ where to go ” that can be viewed as a direction to the goal g from the current state s. Adhering to this intuition , we thus treat value predictions as the interactions between two vectors . Consider “ what I can do ” and “ where to go ” as two vector fields ~f ( s , a ) and ~ϕ ( s , g ) in figure 1b . It is natural to define the value predictions as the level of alignment between two vector field ~f and ~ϕ . The maximum value implicitly emerges when “ what I can do ” ( ~f ( s , a ) ) corresponding to taking an action a aligns “ where to go ” ( ~ϕ ( s , g ) ) . In fact , our intuition resembles bilinear mapping in vector analysis , that parametrizes a scalar function by two vector spaces . Our principal contribution is bi-linear value network ( BVN ) , a parameterization scheme that decomposes the goal-conditioned value function into a bilinear map between two distinct vector representations . The first component φ ( s , g ) captures the long-range topology between the current state and a distant goal , whereas the second component f ( s , a ) is akin to a local model that represents taking an immediate action at the current state . To understand how this parameterization affects learning dynamics , we evaluate the agent on goals that never appeared during training . Surprisingly , we found that the bi-linear decomposition allows the critic to generalize to unseen goals ( see section 4.3 ) , which in turn improves the overall sample complexity and policy performance . We evaluate our approach on the challenging task of dexterous manipulation with a simulated shadow hand and other object manipulation tasks . Our method , BVN , achieves state-of-the-art sample efficiency and asymptotic performance on the majority of tasks . Apart from comparing with prior works , we also produce detailed analysis on the influence of the dimensionality of the two latent spaces , and how different constructions of the binary mapping affects performance . 2 PRELIMINARIES . 2.1 MULTI-GOAL REINFORCEMENT LEARNING . We consider a special case of the Markov decision process ( MDP ) , the multi-goal reinforcement learning ( RL ) problem ( Kaelbling , 1993 ) . At the beginning of an episode , an initial state s0 and a behavior goal gb is sampled according to the distribution ρS and ρG . The behavior goal gb is fixed throughout the episode during roll-out by the policy π . For each time step t , the agent takes action at = π ( st , gb ) , receives reward rt , gb = R ( st , at , gb ) , and moves to the next state st+1 . We consider an infinite horizon MDP problem with the discount factor γ . The goal of multi-goal RL is to produce a policy π∗ that maximizes the expected return J π∗ = argmax π J ( π ) where J ( π ) = E [ ∞∑ τ=t γτ−trτ , gb |st = s , g = gb ] , ( 1 ) where the discount factor γ is set as 0.98 in common multi-goal RL benchmarks ( Plappert et al. , 2018 ) , and the reward rτ , gb is typically defined as R ( sτ , aτ , gb ) : = { 0 , goal reached −1 , otherwise ( 2 ) Note that our method , BVN , is not dependent on this reward structure . 2.2 OFF-POLICY RL WITH ACTOR-CRITIC METHODS . As we consider multi-goal continuous control tasks , we follow Andrychowicz et al . ( 2017 ) and Plappert et al . ( 2018 ) and use deterministic policy gradient algorithm ( DDPG ) ( Silver et al. , 2014 ) to learn a π∗ . DDPG is an actor-critic method . Note that a more advanced actor-critic method ( Fujimoto et al. , 2018 ) can be used , but we empirically found that DDPG is better than that in the tasks we consider . In actor-critic methods the value function , referred to as the critic , is responsible for generating the learning signal of π . The critic is trained by minimizing the loss function L ( Q ) = E ( st , at ) ∼Uniform ( Z ) ( rt , g + γQ ( st+1 , π ( st+1 , g ) , g ) −Q ( st , at , g ) ) 2 , ( 3 ) where Z denotes a replay buffer ( Mnih et al. , 2015 ) that stores multiple state transitions tuples ( st , at , rt , st+1 , gb ) . The actor π is trained to maximize the critic outputs by the gradient ∇πJ ( π ) = E [ ∇aQπ ( s , a , g ) |a=π ( s , g ) ] . ( 4 ) In multi-goal RL settings , the value function Q is often referred as universal value function approximator ( Schaul et al. , 2015 ) since Q encompasses the values of all goals in the MDP . As we are particularly interested in sample efficiency of policy learning , we highlight the importance of the critic for the sample efficiency of training the actor . A critic that provides better estimate of values for previously unseen states ( i.e. , better generalization of the critic ) will lead to faster policy improvement via optimization in Equation 4 . 3 BI-LINEAR VALUE DECOMPOSITION FOR MULTI-GOAL RL . The key insight behind the bilinear value network architecture , as illustrated in figure 2 , is that we can often decompose value estimate into the alignment between the concern of “ what I can do ” and “ where I want to go. ” When these two concerns are implicitly aligned , we consider the action to be good for reaching that goal . Whereas if these two are misaligned , the action is considered bad . These two concerns interact with each other when we try to find the solution to what I can do , but they are also disentangled because they take in different inputs . “ What I can do , ” for example , only concerns the current state of affair and the possible set of actions . When a new goal appears the agent would not have to reconsider the relationship between its current state and the available actions , therefore lowers the burden to learn . It does however need to update what it knows about getting to that goal from where it is , which is inescapable . To bring this insight into reality , we design a drop-in replacement of the standard universal value function approximator , as illustrated in figure 3 , which we refer to as the bilinear value network . For context we present the standard architecture of a universal value function approximator ( UVFA ) on the left ( see figure 3a ) . The UVFA is a single , monolithic neural network which is entangled in the way it processes the inputs . It first concatenates the state , action and the goal together into a single vector , and does not impose any inductive bias into the way these inputs interact . With bilinear value networks ( see figure 3b ) , we partition the three input vectors into two overlapping groups . In the first group that we consider to be local , the neural network ~f ( s , a ) is only concerned with the current state and the immediate actions the agent can take . This is the component that is relatively easier to learn , because it does not have to integrate over long horizons . The second group is more global . The neural network ~φ ( s , g ) captures the long-horizon relationship between the current state and the goal which can be quite far apart . To bring the information that are processed separately by these two components , we borrow the concept of bilinear map from vector analysis , and define the Q function as a dot product between the two distinct vector representations Q : Zf × Zφ 7→ R. ( 5 ) A consequence of this treatment is that the value becomes the result of an alignment between the two vector fields : Q ( s , a , g ) = ~f ( s , a ) > ~φ ( s , g ) . ( 6 ) In figure 2 , we show that passing the current state s into the global stream φ ( s , g ) is important , because to find the solution to the optimal action , the global field needs to vary depending on the current state . Figure 2a shows a goal stream that does not take into the current state – the vector field becomes a constant ∀s ∈ S , making it impossible to accommodate the complex behavior needed to succeed from the entire state space . An important issue to keep in mind is that Equation 6 is unidentifiable in the statistical sense because we can insert an arbitrary vector λ into the vector space and produce the same value estimate , as long as λ contains no zeros . In statistics , identifiability is the condition under which we can recover the true parameter of the model given infinite samples . Q ( s , a , g ) = f ( s , a ) > φ ( g ) ⇐⇒ Q ( s , a , g ) = ( λf ) > ( λ−1φ ) ∀ λ ∈ Rn . ( 7 ) What this means is that under end-to-end training , the particular semantics of the two vector fields becomes particularly irrelevant . It is the grouping of the input variables and the bilinear structure that is critical . It is also important to note that the bilinear value networks is implemented as a drop-in replacement of the universal value function approximator , as opposed to any additional algorithmic step . The training procedure we adopt in this paper follows those of deep deterministic policy gradient and hindsight experience replay , but the bilinear value networks is equally applicable to other off-policy learning algorithms under goal-conditioned scenario that uses either a value function , or a critic . | This paper considers the problem of learning a goal-conditioned policy effectively. Particularly, it looks at the architecture of the value network used to learn this goal-conditioned policy if using a deterministic policy gradient algorithm. It studies whether separating the goal-conditioned value network into two components, a state-action embedding network and a state-goal embedding network, might lead to faster learning and better generalization of the policy. The hypothesis such a study tests is whether the separation can tease apart what an agent's actions in a particular state accomplish and what the agent needs to accomplish to get to a goal from a given state. This hypothesis is evaluated by conducting experiments on the Fetch and Hand domains and evaluating how quickly the goal-conditioned policy is learned and whether it generalizes to goals in parts of the state space that it was not trained on. | SP:7d20e7d43a75402fa1baa3f9ab6e2311a749fcc6 |
On the benefits of maximum likelihood estimation for Regression and Forecasting | 1 INTRODUCTION . The task of fitting a regression model for a response variable y against a covariate vector x ∈ Rd is ubiquitous in supervised learning in both linear and non-linear settings ( Lathuilière et al. , 2020 ; Mohri et al. , 2018 ) as well as non-i.i.d settings like multi-variate forecasting ( Salinas et al. , 2020 ; Wang et al. , 2019 ) . The end goal in regression and forecasting problems is often to use the resulting model to obtain good performance in terms of some target metric of interest on the population level ( usually measured on a previously unseen test set ) . The mean-squared error or the mean absolute deviation are examples of common target metrics . In this paper , our focus is on the choice of loss function that is used to train such models , which is an important question that is often overlooked , especially in the deep neural networks context where the emphasis is more on the choice of network architecture ( Lathuilière et al. , 2020 ) . Perhaps the most common method used by practitioners for choosing the loss function for a particular regression model is to directly use the target metric of interest as the loss function for empirical risk minimization ( ERM ) over a function class on the training set . We denote this approach for choosing a loss function as Target Metric Optimization ( TMO ) . This is especially more common with the advent of powerful general purpose function optimizers like deep networks and has also been rigorously analyzed for simpler function classes ( Mohri et al. , 2018 ) . Target Metric Optimization seems like a reasonable approach - if the practitioner knows about the target metric of interest for prediction using the model , it seems intuitive to optimize for the same objective on the training data . Prior work ( both theoretical and applied ) has both advocated for and argued against TMO for regression problems . Many prominent works on regression ( Goldberger et al. , 1964 ; Lecue & Mendelson , 2016 ) use the TMO approach , though most of them assume that the data is well behaved ( e.g . sub-Gaussian noise ) . In terms of applications , many recent works on time-series forecasting ( Wu et al. , 2020 ; Oreshkin et al. , 2019 ; Sen et al. , 2019 ) also use the TMO approach directly on the target metric . On the other hand , the robust regression literature has long advocated for not using the target metric directly for ERM in the case of contamination or heavy tailed response/covariate behaviour ( Huber , 1992 ; Hsu & Sabato , 2016 ; Zhu & Zhou , 2021 ; Lugosi & Mendelson , 2019a ; Audibert et al. , 2011 ; Brownlees et al. , 2015 ) on account of its suboptimal high-probability risk bounds . However , as noted in ( Prasad et al. , 2020 ) , many of these methods are either not practical ( Lugosi & Mendelson , 2019a ; Brownlees et al. , 2015 ) or have sub-optimal empirical performance ( Hsu & Sabato , 2016 ) . Even more practical methods such as ( Prasad et al. , 2020 ) would lead to sufficiently more computational overhead over standard TMO . Another well known approach for designing a loss function is Maximum Likelihood Estimation ( MLE ) . Here one assumes that the conditional distribution of y given x belongs to a family of distributions p ( y|x ; θ ) parameterized by θ ∈ Θ ( McCullagh & Nelder , 2019 ) . Then one can choose the negative log likelihood as the loss function to optimize using the training set , to obtain an estimate θ̂mle . This approach is sometimes used in the forecasting literature ( Salinas et al. , 2020 ; Davis & Wu , 2009 ) where the choice of a likelihood can encode prior knowledge about the data . For instance a negative binomial distribution can be used to model count data . During inference , given a new instance x′ , one can output the statistic from p ( y|x′ ; θ̂mle ) that optimizes the target metric , as the prediction value ( Gneiting , 2011 ) . MLE also seems like a reasonable approach for loss function design - it is folklore that the MLE is asymptotically optimal for parameter estimation , in terms of having the smallest asymptotic variance among all estimators ( Heyde , 1978 ; Rao , 1963 ) , when the likelihood is well-specified . However , much less is known about finite-sample , fixed-dimension analysis of MLE , which is the typical regime of interest for the regression problems we consider in this paper . An important practical advantage for MLE is that model training is agnostic to the choice of the target metric - the same trained model can output estimators for different target metrics at inference time . Perhaps the biggest argument against the MLE approach is the requirement of knowing the likelihood distribution family . We address both these topics in Section 5 . Both TMO and MLE can be viewed as offering different approaches to selecting the loss function for a given regression model . In this paper , we argue that in several settings , both from a practical and theoretical perspective , MLE might be a better approach than TMO . This result might not be immediately obvious apriori - while MLE does benefit from prior knowledge of the distribution , TMO also benefits from prior knowledge of the target metric at training time . Our main contributions are as follows : Competitiveness of MLE : In Section 3 , we prove that under some general conditions on the family of distributions and a property of interest , the MLE approach is competitive with any estimator for the property . We show that this result can be applied to fixed design regression problems in order to prove that MLE can be competitive ( up to logarithmic terms ) with any estimator in terms of excess square loss risk , under some assumptions . Example Applications : In Section 4.1 , we apply our general theorem to prove an excess square loss bound for the the MLE estimator for Poisson regression with the identity link ( Nelder & Wedderburn , 1972 ; Lawless , 1987 ) . We show that these bounds can be better than those of the TMO estimator , which in this case is least-squares regression . Then in Section 4.2 , we show a similar application in the context of Pareto regression i.e y|x follows a Pareto distribution . We show that MLE can be competitive with robust estimators like the one in ( Hsu & Sabato , 2016 ) and therefore can be better than TMO ( least-squares ) . Empirical Results : We propose the use of a general purpose mixture likelihood family ( see Section 5 ) that can capture a wide variety of prior knowledge across datasets , including zero-inflated or bursty data , count data , sub-Gaussian continuous data as well as heavy tailed data , through different choices of ( learnt ) mixture weights . Then we empirically show that the MLE approach with this likelihood can outperform ERM for many different commonly used target metrics like WAPE , MAPE and RMSE ( Hyndman & Koehler , 2006 ) for two popular forecasting and two regression datasets . Moreover the MLE approach is also shown to have better probabilistic forecasts ( measured by quantile losses ( Wen et al. , 2017 ) ) than quantile regression ( Koenker & Bassett Jr , 1978 ; Gasthaus et al. , 2019 ; Wen et al. , 2017 ) which is the TMO approach in this case . 2 PRIOR WORK ON MLE . Maximum likelihood estimators ( MLE ) have been studied extensively in statistics starting with the work of Wald ( 1949 ) ; Redner ( 1981 ) , who showed the maximum likelihood estimates are asymptotically consistent for parametric families . Fahrmeir & Kaufmann ( 1985 ) showed asymptotic normality for MLE for generalized linear models . It is also known that under some regularity assumptions , MLE achieves the Cramer-Rao lower bound asymptotically ( Lehmann & Casella , 2006 ) . However , we note that none of these asymptotic results directly yield finite sample guarantees . Finite sample guarantees have been shown for certain problem scenarios . Geer & van de Geer ( 2000 ) ; Zhang ( 2006 ) provided uniform convergence bounds in Hellinger distance for maximum likelihood estimation . These ideas were recently used by Foster & Krishnamurthy ( 2021 ) to provide algorithms for contextual bandits . There are other works which study MLE for non-parametric distributions e.g. , Dümbgen & Rufibach ( 2009 ) showed convergence rates for log-concave distributions . There has been some works ( Sur & Candès , 2019 ; Bean et al. , 2013 ; Donoho & Montanari , 2016 ; El Karoui , 2018 ) that show that MLE can be sub-optimal for high dimensional regression i.e when the dimension grows with the number of samples . In this work we focus on the setting where the dimension does not scale with the number of samples . Our MLE results differ from the above work as we provide finite sample competitiveness guarantees . Instead of showing that the maximum likelihood estimator converges in some distance metric , we show that under some mild assumptions it can work as well as other estimators . Hence , our methods are orthogonal to known well established results in statistics . Perhaps the closest to our work is the competitiveness result of Acharya et al . ( 2017 ) , who showed that MLE is competitive when the size of the output alphabet is bounded and applied to profile maximum likelihood estimation . In contrast , our work applies for unbounded output alphabets and can provide stronger guarantees in many scenarios . 3 COMPETITIVENESS OF MLE . In this section , we will show that under some reasonable assumptions on the likelihood family , the MLE is competitive with any estimator in terms of estimating any property of a distribution from the family . We will then show that this result can be applied to derive bounds on the MLE in some fixed design regression settings that can be better than that of TMO . We will first setup some notation . Notation : Given a positive semi-definite symmetric matrix M , ‖x‖M : = xTMx is the matrix norm of the vector x. λ ( M ) denotes an eigenvalue of a symmetric square matrix M ; specifically λmax ( M ) and λmin ( M ) denote the maximum and minimum eigenvalues respectively . The letter f is used to denote general probability densities . We use p to denote the conditional probability density of the response given the covariate . ‖·‖1 will be overloaded to denote the ` 1 norm between two probability distributions i.e ‖p− p′‖1 : = ∫ |p ( z ) − p′ ( z ) |dz . DKL ( p1 ; p2 ) will be used to denote the KL-divergence between the two distributions . If Z is a set equipped with a norm ‖·‖ , then N ( , Z ) will denote an -net i.e any point z ∈ Z has a corresponding point z′ ∈ N ( , Z ) s.t ‖z − z′‖ ≤ . Bdr denotes the ball centered at the origin with radius r and Sd−1r denotes its surface . We define [ n ] : = { 1 , 2 , · · · , n } . | · | denotes the size of the enclosed set . General Competitiveness : We first consider a general family of distributions F over the space Z . For a sample z ∼ f ( for z ∈ Z and f ∈ F ) , the MLE distribution is defined as fz = argmaxf∈F f ( z ) . We are interested in estimating a property π : F → W of these distributions from an observed sample . The following definition will be required to impose some joint conditions on the distribution family and the property being estimated , that are needed for our result . Definition 1 . The tuple ( F , π ) , where F is a set of distributions and π : F → W a property of those distributions , is said to be ( T , , δ1 , δ2 ) -approximable , if there exists a set of distributions F̃ ⊆ F s.t |F̃ | ≤ T and for every f ∈ F , there exists a f̃ such that ‖f − f̃‖1 ≤ δ1 and Prz∼f ( ∥∥∥π ( fz ) − π ( f̃z ) ∥∥∥ ≥ ) ≤ δ2 , where f̃z = argmaxf̃∈F̃ f̃ ( z ) andW has a norm ‖·‖ . The above definition states that the set of distributions F has a finite δ-cover , F̃ in terms of the ` 1 distance . Moreover the cover is such that solving MLE on the cover and applying the property π on the result of the MLE is not too far from π applied on the MLE over the whole set F . This property is satisfied trivially if F is finite . We note that it is also satisfied by some commonly used set of distributions and corresponding properties . Now we state our main result . Theorem 1 . Let π̂ be an estimator such that for any f ∈ F and z ∼ f , Pr ( ‖π ( f ) − π̂ ( z ) ‖ ≥ ) ≤ δ . Let Ff be a subset of F that contains f such that with probability at least 1− δ , fz ∈ Ff and ( Ff , π ) is ( T , , δ1 , δ2 ) -approximable . Then the MLE satisfies the following bound , Pr ( ‖π ( f ) − π ( fz ) ‖ ≥ 3 ) ≤ ( T + 3 ) δ + δ1 + δ2 . We provide the proof of Theorem 1 in Appendix A . We also provide a simpler version of this result for finite distribution families as Theorem 3 in Appendix A for the benefit of the reader . Competitiveness in Fixed Design Regression : Theorem 1 can be used to show that MLE is competitive with respect to any estimator for square loss minimization in fixed design regression . We will first formally introduce the setting . Consider a fixed design matrix X ∈ Rn×d where n is the number of samples and d the feature dimension . We will work in a setting where n d. The target vector is a random vector given by yn ∈ Rn . Let yi be the i-th coordinate of yn and xi denote the i-th row of the design matrix . We assume that the target is generated from the conditional distribution given xi such that , yi ∼ p ( ·|xi ; θ∗ ) , θ∗ ∈ Θ . We are interested in optimizing a target metric ` ( · , · ) given an instance of the random vector yn . The final objective is to optimize , min h∈H Eyi∼p ( ·|xi ; θ∗ ) [ 1 n n∑ i=1 ` ( yi , h ( xi ) ) ] , whereH is a class of functions . In this context , we are interested in comparing two approaches . TMO ( see ( Mohri et al. , 2018 ) ) . This is standard empirical risk minimization on the target metric where given an instance of the random vector yn one outputs the estimator ĥ = minh∈H 1 n ∑n i=1 ` ( yi , h ( xi ) ) . MLE and post-hoc inference ( see ( Gneiting , 2011 ) ) . In this method one first solves for the parameter in the distribution family that best explains the empirical data by MLE i.e. , θ̂mle : = argmin θ∈Θ L ( yn ; θ ) , where L ( yn ; θ ) : = n∑ i=1 − log p ( yi|xi ; θ ) Then during inference given a sample xi the predictor is defined as , h̃ ( xi ) : = argminŷ Ey∈p ( ·|xi ; θ̂mle ) [ ` ( y , ŷ ) ] or in other words we output the statistic from the MLE distribution that optimizes the loss function of interest . For instance if ` is the square loss , then h̃ ( xi ) will be the mean of the conditional distribution p ( y|xi ; θ̂mle ) . We will prove a general result using Theorem 1 when the target metric ` is the square loss andH is a linear function class . Moreover , the true distribution p ( ·|xi ; θ∗ ) is such that E [ yi ] = 〈θ∗ , xi〉 for all i ∈ [ n ] i.e we are in the linear realizable setting . In this case the quantity of interest is the excess square loss risk given by , E ( θ ) : = 1 n n∑ i=1 Eyn‖yn −Xθ‖22 − 1 n n∑ i=1 Eyn‖yn −Xθ∗‖22 = ‖θ − θ ∗‖2Σ , ( 1 ) where Σ : = ( ∑ i xix T i ) /n is the normalized covariance matrix , and θ ∗ is the population minimizer of the target metric over the linear function class . Now we are ready to state the main result . Theorem 2 . Consider a fixed design regression setting where the likelihood family is parameterized by θ ∈ Θ ⊆ Bdw and |N ( , Θ ∩ Bdw ) | ≤ |N ( , Bdw ) | for a small enough . Further the following conditions hold , 1 . DKL ( p ( yi ; θ ) ; p ( yi ; θ′ ) ) ≤ L‖θ − θ′‖2 . 2 . The negative log-likelihood L ( yn ; θ ) as a function of θ is α-strongly convex and β-smooth , w.p . at least 1− δ . Further suppose there exists an estimator θest such that E ( θest ) ≤ ( c1 + c2 log ( 1/δ ) ) η/n , where c1 , c2 are problem dependent quantities and η > 0 . Then the MLE estimator also satisfies , E ( θ̂mle ) = O ( ( c1 + c2d ( log n+ log ( wLλmax ( Σ ) ) + log ( β/α ) + log 1 δ ) ) η n ) w.p at least 1− δ . We provide the proof in Appendix C. The proof involves proving the conditions in Theorem 1 and bounding the size of the cover T . In order to better understand Theorem 2 , let us consider a typical case where there exists a possibly complicated estimator such that E ( θest ) = O ( ( d + log ( 1/δ ) ) /n ) . In this case the above theorem implies that MLE will be competitive with this estimator up to a log n factor . In many cases the MLE might be much simpler to implement than the original estimator but would essentially match the same error bound . We now provide specific examples in subsequent sections . | This paper compares two inferential methods for regression models, the maximum likelihood estimation and the estimation based on loss functions. For that purpose, a quantity is proposed to measure the correctness of an estimator of a regression model. Then it is shown that, under certain conditions on the quantity of an estimator, the proposed quantity of the maximum likelihood estimator can be evaluated. This result is applied to two regression models based on the Poisson distribution and Pareto distribution. Choices of the probability distributions and target metrics are discussed for the maximum likelihood estimation. Experiments are given to compare the performance of the maximum likelihood estimator and the estimators based on some loss functions. | SP:44cd641c68a070c99d9ba5703abb49b12de10c3e |
On the benefits of maximum likelihood estimation for Regression and Forecasting | 1 INTRODUCTION . The task of fitting a regression model for a response variable y against a covariate vector x ∈ Rd is ubiquitous in supervised learning in both linear and non-linear settings ( Lathuilière et al. , 2020 ; Mohri et al. , 2018 ) as well as non-i.i.d settings like multi-variate forecasting ( Salinas et al. , 2020 ; Wang et al. , 2019 ) . The end goal in regression and forecasting problems is often to use the resulting model to obtain good performance in terms of some target metric of interest on the population level ( usually measured on a previously unseen test set ) . The mean-squared error or the mean absolute deviation are examples of common target metrics . In this paper , our focus is on the choice of loss function that is used to train such models , which is an important question that is often overlooked , especially in the deep neural networks context where the emphasis is more on the choice of network architecture ( Lathuilière et al. , 2020 ) . Perhaps the most common method used by practitioners for choosing the loss function for a particular regression model is to directly use the target metric of interest as the loss function for empirical risk minimization ( ERM ) over a function class on the training set . We denote this approach for choosing a loss function as Target Metric Optimization ( TMO ) . This is especially more common with the advent of powerful general purpose function optimizers like deep networks and has also been rigorously analyzed for simpler function classes ( Mohri et al. , 2018 ) . Target Metric Optimization seems like a reasonable approach - if the practitioner knows about the target metric of interest for prediction using the model , it seems intuitive to optimize for the same objective on the training data . Prior work ( both theoretical and applied ) has both advocated for and argued against TMO for regression problems . Many prominent works on regression ( Goldberger et al. , 1964 ; Lecue & Mendelson , 2016 ) use the TMO approach , though most of them assume that the data is well behaved ( e.g . sub-Gaussian noise ) . In terms of applications , many recent works on time-series forecasting ( Wu et al. , 2020 ; Oreshkin et al. , 2019 ; Sen et al. , 2019 ) also use the TMO approach directly on the target metric . On the other hand , the robust regression literature has long advocated for not using the target metric directly for ERM in the case of contamination or heavy tailed response/covariate behaviour ( Huber , 1992 ; Hsu & Sabato , 2016 ; Zhu & Zhou , 2021 ; Lugosi & Mendelson , 2019a ; Audibert et al. , 2011 ; Brownlees et al. , 2015 ) on account of its suboptimal high-probability risk bounds . However , as noted in ( Prasad et al. , 2020 ) , many of these methods are either not practical ( Lugosi & Mendelson , 2019a ; Brownlees et al. , 2015 ) or have sub-optimal empirical performance ( Hsu & Sabato , 2016 ) . Even more practical methods such as ( Prasad et al. , 2020 ) would lead to sufficiently more computational overhead over standard TMO . Another well known approach for designing a loss function is Maximum Likelihood Estimation ( MLE ) . Here one assumes that the conditional distribution of y given x belongs to a family of distributions p ( y|x ; θ ) parameterized by θ ∈ Θ ( McCullagh & Nelder , 2019 ) . Then one can choose the negative log likelihood as the loss function to optimize using the training set , to obtain an estimate θ̂mle . This approach is sometimes used in the forecasting literature ( Salinas et al. , 2020 ; Davis & Wu , 2009 ) where the choice of a likelihood can encode prior knowledge about the data . For instance a negative binomial distribution can be used to model count data . During inference , given a new instance x′ , one can output the statistic from p ( y|x′ ; θ̂mle ) that optimizes the target metric , as the prediction value ( Gneiting , 2011 ) . MLE also seems like a reasonable approach for loss function design - it is folklore that the MLE is asymptotically optimal for parameter estimation , in terms of having the smallest asymptotic variance among all estimators ( Heyde , 1978 ; Rao , 1963 ) , when the likelihood is well-specified . However , much less is known about finite-sample , fixed-dimension analysis of MLE , which is the typical regime of interest for the regression problems we consider in this paper . An important practical advantage for MLE is that model training is agnostic to the choice of the target metric - the same trained model can output estimators for different target metrics at inference time . Perhaps the biggest argument against the MLE approach is the requirement of knowing the likelihood distribution family . We address both these topics in Section 5 . Both TMO and MLE can be viewed as offering different approaches to selecting the loss function for a given regression model . In this paper , we argue that in several settings , both from a practical and theoretical perspective , MLE might be a better approach than TMO . This result might not be immediately obvious apriori - while MLE does benefit from prior knowledge of the distribution , TMO also benefits from prior knowledge of the target metric at training time . Our main contributions are as follows : Competitiveness of MLE : In Section 3 , we prove that under some general conditions on the family of distributions and a property of interest , the MLE approach is competitive with any estimator for the property . We show that this result can be applied to fixed design regression problems in order to prove that MLE can be competitive ( up to logarithmic terms ) with any estimator in terms of excess square loss risk , under some assumptions . Example Applications : In Section 4.1 , we apply our general theorem to prove an excess square loss bound for the the MLE estimator for Poisson regression with the identity link ( Nelder & Wedderburn , 1972 ; Lawless , 1987 ) . We show that these bounds can be better than those of the TMO estimator , which in this case is least-squares regression . Then in Section 4.2 , we show a similar application in the context of Pareto regression i.e y|x follows a Pareto distribution . We show that MLE can be competitive with robust estimators like the one in ( Hsu & Sabato , 2016 ) and therefore can be better than TMO ( least-squares ) . Empirical Results : We propose the use of a general purpose mixture likelihood family ( see Section 5 ) that can capture a wide variety of prior knowledge across datasets , including zero-inflated or bursty data , count data , sub-Gaussian continuous data as well as heavy tailed data , through different choices of ( learnt ) mixture weights . Then we empirically show that the MLE approach with this likelihood can outperform ERM for many different commonly used target metrics like WAPE , MAPE and RMSE ( Hyndman & Koehler , 2006 ) for two popular forecasting and two regression datasets . Moreover the MLE approach is also shown to have better probabilistic forecasts ( measured by quantile losses ( Wen et al. , 2017 ) ) than quantile regression ( Koenker & Bassett Jr , 1978 ; Gasthaus et al. , 2019 ; Wen et al. , 2017 ) which is the TMO approach in this case . 2 PRIOR WORK ON MLE . Maximum likelihood estimators ( MLE ) have been studied extensively in statistics starting with the work of Wald ( 1949 ) ; Redner ( 1981 ) , who showed the maximum likelihood estimates are asymptotically consistent for parametric families . Fahrmeir & Kaufmann ( 1985 ) showed asymptotic normality for MLE for generalized linear models . It is also known that under some regularity assumptions , MLE achieves the Cramer-Rao lower bound asymptotically ( Lehmann & Casella , 2006 ) . However , we note that none of these asymptotic results directly yield finite sample guarantees . Finite sample guarantees have been shown for certain problem scenarios . Geer & van de Geer ( 2000 ) ; Zhang ( 2006 ) provided uniform convergence bounds in Hellinger distance for maximum likelihood estimation . These ideas were recently used by Foster & Krishnamurthy ( 2021 ) to provide algorithms for contextual bandits . There are other works which study MLE for non-parametric distributions e.g. , Dümbgen & Rufibach ( 2009 ) showed convergence rates for log-concave distributions . There has been some works ( Sur & Candès , 2019 ; Bean et al. , 2013 ; Donoho & Montanari , 2016 ; El Karoui , 2018 ) that show that MLE can be sub-optimal for high dimensional regression i.e when the dimension grows with the number of samples . In this work we focus on the setting where the dimension does not scale with the number of samples . Our MLE results differ from the above work as we provide finite sample competitiveness guarantees . Instead of showing that the maximum likelihood estimator converges in some distance metric , we show that under some mild assumptions it can work as well as other estimators . Hence , our methods are orthogonal to known well established results in statistics . Perhaps the closest to our work is the competitiveness result of Acharya et al . ( 2017 ) , who showed that MLE is competitive when the size of the output alphabet is bounded and applied to profile maximum likelihood estimation . In contrast , our work applies for unbounded output alphabets and can provide stronger guarantees in many scenarios . 3 COMPETITIVENESS OF MLE . In this section , we will show that under some reasonable assumptions on the likelihood family , the MLE is competitive with any estimator in terms of estimating any property of a distribution from the family . We will then show that this result can be applied to derive bounds on the MLE in some fixed design regression settings that can be better than that of TMO . We will first setup some notation . Notation : Given a positive semi-definite symmetric matrix M , ‖x‖M : = xTMx is the matrix norm of the vector x. λ ( M ) denotes an eigenvalue of a symmetric square matrix M ; specifically λmax ( M ) and λmin ( M ) denote the maximum and minimum eigenvalues respectively . The letter f is used to denote general probability densities . We use p to denote the conditional probability density of the response given the covariate . ‖·‖1 will be overloaded to denote the ` 1 norm between two probability distributions i.e ‖p− p′‖1 : = ∫ |p ( z ) − p′ ( z ) |dz . DKL ( p1 ; p2 ) will be used to denote the KL-divergence between the two distributions . If Z is a set equipped with a norm ‖·‖ , then N ( , Z ) will denote an -net i.e any point z ∈ Z has a corresponding point z′ ∈ N ( , Z ) s.t ‖z − z′‖ ≤ . Bdr denotes the ball centered at the origin with radius r and Sd−1r denotes its surface . We define [ n ] : = { 1 , 2 , · · · , n } . | · | denotes the size of the enclosed set . General Competitiveness : We first consider a general family of distributions F over the space Z . For a sample z ∼ f ( for z ∈ Z and f ∈ F ) , the MLE distribution is defined as fz = argmaxf∈F f ( z ) . We are interested in estimating a property π : F → W of these distributions from an observed sample . The following definition will be required to impose some joint conditions on the distribution family and the property being estimated , that are needed for our result . Definition 1 . The tuple ( F , π ) , where F is a set of distributions and π : F → W a property of those distributions , is said to be ( T , , δ1 , δ2 ) -approximable , if there exists a set of distributions F̃ ⊆ F s.t |F̃ | ≤ T and for every f ∈ F , there exists a f̃ such that ‖f − f̃‖1 ≤ δ1 and Prz∼f ( ∥∥∥π ( fz ) − π ( f̃z ) ∥∥∥ ≥ ) ≤ δ2 , where f̃z = argmaxf̃∈F̃ f̃ ( z ) andW has a norm ‖·‖ . The above definition states that the set of distributions F has a finite δ-cover , F̃ in terms of the ` 1 distance . Moreover the cover is such that solving MLE on the cover and applying the property π on the result of the MLE is not too far from π applied on the MLE over the whole set F . This property is satisfied trivially if F is finite . We note that it is also satisfied by some commonly used set of distributions and corresponding properties . Now we state our main result . Theorem 1 . Let π̂ be an estimator such that for any f ∈ F and z ∼ f , Pr ( ‖π ( f ) − π̂ ( z ) ‖ ≥ ) ≤ δ . Let Ff be a subset of F that contains f such that with probability at least 1− δ , fz ∈ Ff and ( Ff , π ) is ( T , , δ1 , δ2 ) -approximable . Then the MLE satisfies the following bound , Pr ( ‖π ( f ) − π ( fz ) ‖ ≥ 3 ) ≤ ( T + 3 ) δ + δ1 + δ2 . We provide the proof of Theorem 1 in Appendix A . We also provide a simpler version of this result for finite distribution families as Theorem 3 in Appendix A for the benefit of the reader . Competitiveness in Fixed Design Regression : Theorem 1 can be used to show that MLE is competitive with respect to any estimator for square loss minimization in fixed design regression . We will first formally introduce the setting . Consider a fixed design matrix X ∈ Rn×d where n is the number of samples and d the feature dimension . We will work in a setting where n d. The target vector is a random vector given by yn ∈ Rn . Let yi be the i-th coordinate of yn and xi denote the i-th row of the design matrix . We assume that the target is generated from the conditional distribution given xi such that , yi ∼ p ( ·|xi ; θ∗ ) , θ∗ ∈ Θ . We are interested in optimizing a target metric ` ( · , · ) given an instance of the random vector yn . The final objective is to optimize , min h∈H Eyi∼p ( ·|xi ; θ∗ ) [ 1 n n∑ i=1 ` ( yi , h ( xi ) ) ] , whereH is a class of functions . In this context , we are interested in comparing two approaches . TMO ( see ( Mohri et al. , 2018 ) ) . This is standard empirical risk minimization on the target metric where given an instance of the random vector yn one outputs the estimator ĥ = minh∈H 1 n ∑n i=1 ` ( yi , h ( xi ) ) . MLE and post-hoc inference ( see ( Gneiting , 2011 ) ) . In this method one first solves for the parameter in the distribution family that best explains the empirical data by MLE i.e. , θ̂mle : = argmin θ∈Θ L ( yn ; θ ) , where L ( yn ; θ ) : = n∑ i=1 − log p ( yi|xi ; θ ) Then during inference given a sample xi the predictor is defined as , h̃ ( xi ) : = argminŷ Ey∈p ( ·|xi ; θ̂mle ) [ ` ( y , ŷ ) ] or in other words we output the statistic from the MLE distribution that optimizes the loss function of interest . For instance if ` is the square loss , then h̃ ( xi ) will be the mean of the conditional distribution p ( y|xi ; θ̂mle ) . We will prove a general result using Theorem 1 when the target metric ` is the square loss andH is a linear function class . Moreover , the true distribution p ( ·|xi ; θ∗ ) is such that E [ yi ] = 〈θ∗ , xi〉 for all i ∈ [ n ] i.e we are in the linear realizable setting . In this case the quantity of interest is the excess square loss risk given by , E ( θ ) : = 1 n n∑ i=1 Eyn‖yn −Xθ‖22 − 1 n n∑ i=1 Eyn‖yn −Xθ∗‖22 = ‖θ − θ ∗‖2Σ , ( 1 ) where Σ : = ( ∑ i xix T i ) /n is the normalized covariance matrix , and θ ∗ is the population minimizer of the target metric over the linear function class . Now we are ready to state the main result . Theorem 2 . Consider a fixed design regression setting where the likelihood family is parameterized by θ ∈ Θ ⊆ Bdw and |N ( , Θ ∩ Bdw ) | ≤ |N ( , Bdw ) | for a small enough . Further the following conditions hold , 1 . DKL ( p ( yi ; θ ) ; p ( yi ; θ′ ) ) ≤ L‖θ − θ′‖2 . 2 . The negative log-likelihood L ( yn ; θ ) as a function of θ is α-strongly convex and β-smooth , w.p . at least 1− δ . Further suppose there exists an estimator θest such that E ( θest ) ≤ ( c1 + c2 log ( 1/δ ) ) η/n , where c1 , c2 are problem dependent quantities and η > 0 . Then the MLE estimator also satisfies , E ( θ̂mle ) = O ( ( c1 + c2d ( log n+ log ( wLλmax ( Σ ) ) + log ( β/α ) + log 1 δ ) ) η n ) w.p at least 1− δ . We provide the proof in Appendix C. The proof involves proving the conditions in Theorem 1 and bounding the size of the cover T . In order to better understand Theorem 2 , let us consider a typical case where there exists a possibly complicated estimator such that E ( θest ) = O ( ( d + log ( 1/δ ) ) /n ) . In this case the above theorem implies that MLE will be competitive with this estimator up to a log n factor . In many cases the MLE might be much simpler to implement than the original estimator but would essentially match the same error bound . We now provide specific examples in subsequent sections . | The paper provides theoretical results that favor MLE estimators, in terms of the excess square loss risk, compared to empirical risk estimators under mild assumption. In particular, the paper devises an estimator for Poisson regression and employs an existing estimator for heavy-tail Pareto regression, and subsequently derives upper bounds on the excess square loss risk that are tighter compared to the least squares estimator. Finally, a mixture of distributions (with each component coming from a different distribution class) is proposed. The MLE for the proposed mixture outperforms empirical risk estimators under different objective losses. | SP:44cd641c68a070c99d9ba5703abb49b12de10c3e |
On the benefits of maximum likelihood estimation for Regression and Forecasting | 1 INTRODUCTION . The task of fitting a regression model for a response variable y against a covariate vector x ∈ Rd is ubiquitous in supervised learning in both linear and non-linear settings ( Lathuilière et al. , 2020 ; Mohri et al. , 2018 ) as well as non-i.i.d settings like multi-variate forecasting ( Salinas et al. , 2020 ; Wang et al. , 2019 ) . The end goal in regression and forecasting problems is often to use the resulting model to obtain good performance in terms of some target metric of interest on the population level ( usually measured on a previously unseen test set ) . The mean-squared error or the mean absolute deviation are examples of common target metrics . In this paper , our focus is on the choice of loss function that is used to train such models , which is an important question that is often overlooked , especially in the deep neural networks context where the emphasis is more on the choice of network architecture ( Lathuilière et al. , 2020 ) . Perhaps the most common method used by practitioners for choosing the loss function for a particular regression model is to directly use the target metric of interest as the loss function for empirical risk minimization ( ERM ) over a function class on the training set . We denote this approach for choosing a loss function as Target Metric Optimization ( TMO ) . This is especially more common with the advent of powerful general purpose function optimizers like deep networks and has also been rigorously analyzed for simpler function classes ( Mohri et al. , 2018 ) . Target Metric Optimization seems like a reasonable approach - if the practitioner knows about the target metric of interest for prediction using the model , it seems intuitive to optimize for the same objective on the training data . Prior work ( both theoretical and applied ) has both advocated for and argued against TMO for regression problems . Many prominent works on regression ( Goldberger et al. , 1964 ; Lecue & Mendelson , 2016 ) use the TMO approach , though most of them assume that the data is well behaved ( e.g . sub-Gaussian noise ) . In terms of applications , many recent works on time-series forecasting ( Wu et al. , 2020 ; Oreshkin et al. , 2019 ; Sen et al. , 2019 ) also use the TMO approach directly on the target metric . On the other hand , the robust regression literature has long advocated for not using the target metric directly for ERM in the case of contamination or heavy tailed response/covariate behaviour ( Huber , 1992 ; Hsu & Sabato , 2016 ; Zhu & Zhou , 2021 ; Lugosi & Mendelson , 2019a ; Audibert et al. , 2011 ; Brownlees et al. , 2015 ) on account of its suboptimal high-probability risk bounds . However , as noted in ( Prasad et al. , 2020 ) , many of these methods are either not practical ( Lugosi & Mendelson , 2019a ; Brownlees et al. , 2015 ) or have sub-optimal empirical performance ( Hsu & Sabato , 2016 ) . Even more practical methods such as ( Prasad et al. , 2020 ) would lead to sufficiently more computational overhead over standard TMO . Another well known approach for designing a loss function is Maximum Likelihood Estimation ( MLE ) . Here one assumes that the conditional distribution of y given x belongs to a family of distributions p ( y|x ; θ ) parameterized by θ ∈ Θ ( McCullagh & Nelder , 2019 ) . Then one can choose the negative log likelihood as the loss function to optimize using the training set , to obtain an estimate θ̂mle . This approach is sometimes used in the forecasting literature ( Salinas et al. , 2020 ; Davis & Wu , 2009 ) where the choice of a likelihood can encode prior knowledge about the data . For instance a negative binomial distribution can be used to model count data . During inference , given a new instance x′ , one can output the statistic from p ( y|x′ ; θ̂mle ) that optimizes the target metric , as the prediction value ( Gneiting , 2011 ) . MLE also seems like a reasonable approach for loss function design - it is folklore that the MLE is asymptotically optimal for parameter estimation , in terms of having the smallest asymptotic variance among all estimators ( Heyde , 1978 ; Rao , 1963 ) , when the likelihood is well-specified . However , much less is known about finite-sample , fixed-dimension analysis of MLE , which is the typical regime of interest for the regression problems we consider in this paper . An important practical advantage for MLE is that model training is agnostic to the choice of the target metric - the same trained model can output estimators for different target metrics at inference time . Perhaps the biggest argument against the MLE approach is the requirement of knowing the likelihood distribution family . We address both these topics in Section 5 . Both TMO and MLE can be viewed as offering different approaches to selecting the loss function for a given regression model . In this paper , we argue that in several settings , both from a practical and theoretical perspective , MLE might be a better approach than TMO . This result might not be immediately obvious apriori - while MLE does benefit from prior knowledge of the distribution , TMO also benefits from prior knowledge of the target metric at training time . Our main contributions are as follows : Competitiveness of MLE : In Section 3 , we prove that under some general conditions on the family of distributions and a property of interest , the MLE approach is competitive with any estimator for the property . We show that this result can be applied to fixed design regression problems in order to prove that MLE can be competitive ( up to logarithmic terms ) with any estimator in terms of excess square loss risk , under some assumptions . Example Applications : In Section 4.1 , we apply our general theorem to prove an excess square loss bound for the the MLE estimator for Poisson regression with the identity link ( Nelder & Wedderburn , 1972 ; Lawless , 1987 ) . We show that these bounds can be better than those of the TMO estimator , which in this case is least-squares regression . Then in Section 4.2 , we show a similar application in the context of Pareto regression i.e y|x follows a Pareto distribution . We show that MLE can be competitive with robust estimators like the one in ( Hsu & Sabato , 2016 ) and therefore can be better than TMO ( least-squares ) . Empirical Results : We propose the use of a general purpose mixture likelihood family ( see Section 5 ) that can capture a wide variety of prior knowledge across datasets , including zero-inflated or bursty data , count data , sub-Gaussian continuous data as well as heavy tailed data , through different choices of ( learnt ) mixture weights . Then we empirically show that the MLE approach with this likelihood can outperform ERM for many different commonly used target metrics like WAPE , MAPE and RMSE ( Hyndman & Koehler , 2006 ) for two popular forecasting and two regression datasets . Moreover the MLE approach is also shown to have better probabilistic forecasts ( measured by quantile losses ( Wen et al. , 2017 ) ) than quantile regression ( Koenker & Bassett Jr , 1978 ; Gasthaus et al. , 2019 ; Wen et al. , 2017 ) which is the TMO approach in this case . 2 PRIOR WORK ON MLE . Maximum likelihood estimators ( MLE ) have been studied extensively in statistics starting with the work of Wald ( 1949 ) ; Redner ( 1981 ) , who showed the maximum likelihood estimates are asymptotically consistent for parametric families . Fahrmeir & Kaufmann ( 1985 ) showed asymptotic normality for MLE for generalized linear models . It is also known that under some regularity assumptions , MLE achieves the Cramer-Rao lower bound asymptotically ( Lehmann & Casella , 2006 ) . However , we note that none of these asymptotic results directly yield finite sample guarantees . Finite sample guarantees have been shown for certain problem scenarios . Geer & van de Geer ( 2000 ) ; Zhang ( 2006 ) provided uniform convergence bounds in Hellinger distance for maximum likelihood estimation . These ideas were recently used by Foster & Krishnamurthy ( 2021 ) to provide algorithms for contextual bandits . There are other works which study MLE for non-parametric distributions e.g. , Dümbgen & Rufibach ( 2009 ) showed convergence rates for log-concave distributions . There has been some works ( Sur & Candès , 2019 ; Bean et al. , 2013 ; Donoho & Montanari , 2016 ; El Karoui , 2018 ) that show that MLE can be sub-optimal for high dimensional regression i.e when the dimension grows with the number of samples . In this work we focus on the setting where the dimension does not scale with the number of samples . Our MLE results differ from the above work as we provide finite sample competitiveness guarantees . Instead of showing that the maximum likelihood estimator converges in some distance metric , we show that under some mild assumptions it can work as well as other estimators . Hence , our methods are orthogonal to known well established results in statistics . Perhaps the closest to our work is the competitiveness result of Acharya et al . ( 2017 ) , who showed that MLE is competitive when the size of the output alphabet is bounded and applied to profile maximum likelihood estimation . In contrast , our work applies for unbounded output alphabets and can provide stronger guarantees in many scenarios . 3 COMPETITIVENESS OF MLE . In this section , we will show that under some reasonable assumptions on the likelihood family , the MLE is competitive with any estimator in terms of estimating any property of a distribution from the family . We will then show that this result can be applied to derive bounds on the MLE in some fixed design regression settings that can be better than that of TMO . We will first setup some notation . Notation : Given a positive semi-definite symmetric matrix M , ‖x‖M : = xTMx is the matrix norm of the vector x. λ ( M ) denotes an eigenvalue of a symmetric square matrix M ; specifically λmax ( M ) and λmin ( M ) denote the maximum and minimum eigenvalues respectively . The letter f is used to denote general probability densities . We use p to denote the conditional probability density of the response given the covariate . ‖·‖1 will be overloaded to denote the ` 1 norm between two probability distributions i.e ‖p− p′‖1 : = ∫ |p ( z ) − p′ ( z ) |dz . DKL ( p1 ; p2 ) will be used to denote the KL-divergence between the two distributions . If Z is a set equipped with a norm ‖·‖ , then N ( , Z ) will denote an -net i.e any point z ∈ Z has a corresponding point z′ ∈ N ( , Z ) s.t ‖z − z′‖ ≤ . Bdr denotes the ball centered at the origin with radius r and Sd−1r denotes its surface . We define [ n ] : = { 1 , 2 , · · · , n } . | · | denotes the size of the enclosed set . General Competitiveness : We first consider a general family of distributions F over the space Z . For a sample z ∼ f ( for z ∈ Z and f ∈ F ) , the MLE distribution is defined as fz = argmaxf∈F f ( z ) . We are interested in estimating a property π : F → W of these distributions from an observed sample . The following definition will be required to impose some joint conditions on the distribution family and the property being estimated , that are needed for our result . Definition 1 . The tuple ( F , π ) , where F is a set of distributions and π : F → W a property of those distributions , is said to be ( T , , δ1 , δ2 ) -approximable , if there exists a set of distributions F̃ ⊆ F s.t |F̃ | ≤ T and for every f ∈ F , there exists a f̃ such that ‖f − f̃‖1 ≤ δ1 and Prz∼f ( ∥∥∥π ( fz ) − π ( f̃z ) ∥∥∥ ≥ ) ≤ δ2 , where f̃z = argmaxf̃∈F̃ f̃ ( z ) andW has a norm ‖·‖ . The above definition states that the set of distributions F has a finite δ-cover , F̃ in terms of the ` 1 distance . Moreover the cover is such that solving MLE on the cover and applying the property π on the result of the MLE is not too far from π applied on the MLE over the whole set F . This property is satisfied trivially if F is finite . We note that it is also satisfied by some commonly used set of distributions and corresponding properties . Now we state our main result . Theorem 1 . Let π̂ be an estimator such that for any f ∈ F and z ∼ f , Pr ( ‖π ( f ) − π̂ ( z ) ‖ ≥ ) ≤ δ . Let Ff be a subset of F that contains f such that with probability at least 1− δ , fz ∈ Ff and ( Ff , π ) is ( T , , δ1 , δ2 ) -approximable . Then the MLE satisfies the following bound , Pr ( ‖π ( f ) − π ( fz ) ‖ ≥ 3 ) ≤ ( T + 3 ) δ + δ1 + δ2 . We provide the proof of Theorem 1 in Appendix A . We also provide a simpler version of this result for finite distribution families as Theorem 3 in Appendix A for the benefit of the reader . Competitiveness in Fixed Design Regression : Theorem 1 can be used to show that MLE is competitive with respect to any estimator for square loss minimization in fixed design regression . We will first formally introduce the setting . Consider a fixed design matrix X ∈ Rn×d where n is the number of samples and d the feature dimension . We will work in a setting where n d. The target vector is a random vector given by yn ∈ Rn . Let yi be the i-th coordinate of yn and xi denote the i-th row of the design matrix . We assume that the target is generated from the conditional distribution given xi such that , yi ∼ p ( ·|xi ; θ∗ ) , θ∗ ∈ Θ . We are interested in optimizing a target metric ` ( · , · ) given an instance of the random vector yn . The final objective is to optimize , min h∈H Eyi∼p ( ·|xi ; θ∗ ) [ 1 n n∑ i=1 ` ( yi , h ( xi ) ) ] , whereH is a class of functions . In this context , we are interested in comparing two approaches . TMO ( see ( Mohri et al. , 2018 ) ) . This is standard empirical risk minimization on the target metric where given an instance of the random vector yn one outputs the estimator ĥ = minh∈H 1 n ∑n i=1 ` ( yi , h ( xi ) ) . MLE and post-hoc inference ( see ( Gneiting , 2011 ) ) . In this method one first solves for the parameter in the distribution family that best explains the empirical data by MLE i.e. , θ̂mle : = argmin θ∈Θ L ( yn ; θ ) , where L ( yn ; θ ) : = n∑ i=1 − log p ( yi|xi ; θ ) Then during inference given a sample xi the predictor is defined as , h̃ ( xi ) : = argminŷ Ey∈p ( ·|xi ; θ̂mle ) [ ` ( y , ŷ ) ] or in other words we output the statistic from the MLE distribution that optimizes the loss function of interest . For instance if ` is the square loss , then h̃ ( xi ) will be the mean of the conditional distribution p ( y|xi ; θ̂mle ) . We will prove a general result using Theorem 1 when the target metric ` is the square loss andH is a linear function class . Moreover , the true distribution p ( ·|xi ; θ∗ ) is such that E [ yi ] = 〈θ∗ , xi〉 for all i ∈ [ n ] i.e we are in the linear realizable setting . In this case the quantity of interest is the excess square loss risk given by , E ( θ ) : = 1 n n∑ i=1 Eyn‖yn −Xθ‖22 − 1 n n∑ i=1 Eyn‖yn −Xθ∗‖22 = ‖θ − θ ∗‖2Σ , ( 1 ) where Σ : = ( ∑ i xix T i ) /n is the normalized covariance matrix , and θ ∗ is the population minimizer of the target metric over the linear function class . Now we are ready to state the main result . Theorem 2 . Consider a fixed design regression setting where the likelihood family is parameterized by θ ∈ Θ ⊆ Bdw and |N ( , Θ ∩ Bdw ) | ≤ |N ( , Bdw ) | for a small enough . Further the following conditions hold , 1 . DKL ( p ( yi ; θ ) ; p ( yi ; θ′ ) ) ≤ L‖θ − θ′‖2 . 2 . The negative log-likelihood L ( yn ; θ ) as a function of θ is α-strongly convex and β-smooth , w.p . at least 1− δ . Further suppose there exists an estimator θest such that E ( θest ) ≤ ( c1 + c2 log ( 1/δ ) ) η/n , where c1 , c2 are problem dependent quantities and η > 0 . Then the MLE estimator also satisfies , E ( θ̂mle ) = O ( ( c1 + c2d ( log n+ log ( wLλmax ( Σ ) ) + log ( β/α ) + log 1 δ ) ) η n ) w.p at least 1− δ . We provide the proof in Appendix C. The proof involves proving the conditions in Theorem 1 and bounding the size of the cover T . In order to better understand Theorem 2 , let us consider a typical case where there exists a possibly complicated estimator such that E ( θest ) = O ( ( d + log ( 1/δ ) ) /n ) . In this case the above theorem implies that MLE will be competitive with this estimator up to a log n factor . In many cases the MLE might be much simpler to implement than the original estimator but would essentially match the same error bound . We now provide specific examples in subsequent sections . | This paper promotes the maximum likelihood estimation over target metric optimization. The main theoretical results is a finite sample error bound. Specific examples and numerical results are provide to further illustrate the investigation. | SP:44cd641c68a070c99d9ba5703abb49b12de10c3e |
Spherical Message Passing for 3D Molecular Graphs | 1 INTRODUCTION . In many real-world studies , structured objects such as molecules are naturally modeled as graphs ( Gori et al. , 2005 ; Wu et al. , 2018 ; Shervashidze et al. , 2011 ; Fout et al. , 2017 ; Liu et al. , 2020 ; Wang et al. , 2020 ) . With the advances of deep learning , graph neural networks ( GNNs ) have been developed for learning from graph data ( Kipf & Welling , 2017 ; Defferrard et al. , 2016 ; Veličković et al. , 2018 ; Zhang et al. , 2018 ; Xu et al. , 2019 ; Gao & Ji , 2019 ; Gao et al. , 2018 ; 2020 ) . Currently , the message passing scheme ( Gilmer et al. , 2017 ; Sanchez-Gonzalez et al. , 2020 ; Vignac et al. , 2020 ; Battaglia et al. , 2018 ) is one of the commonly used architectures for realizing GNNs . In this work , we aim at developing a novel message passing method for 3D graphs . Generally , a 3D molecular graph contains 3D coordinates for each atom given in the Cartesian system along with the graph structure ( Liu et al. , 2019 ; Townshend et al. , 2019 ; Axelrod & Gomez-Bombarelli , 2020 ) . Different types of relative 3D information can be derived from 3D molecular graphs , and they can be important in molecular learning , such as bond lengths , angles between bonds ( Schütt et al. , 2017 ; Klicpera et al. , 2020b ) . We first investigate complete representations of 3D molecules . This requires the graph structure to be uniquely defined by relative 3D information . To this end , we conduct formal analyses in the spherical coordinate system ( SCS ) , and show that relative location of each atom in a 3D graph is uniquely determined by three geometries , including distance , angle , and torsion . However , such completeness needs to involve edge-based 2-hop information , leading to excessively high computational complexity . To circumvent the computational cost , we propose a novel message passing scheme , known as the spherical message passing ( SMP ) , for fast and accurate 3D molecular learning . Our SMP is efficient and approximately complete in representing 3D molecules . First , we design a novel strategy to compute torsion , which only considers edge-based 1-hop information , thus substantially reducing training complexity . This enables the generalization of SMP to large-scale molecules . In addition , we show that our SMP can distinguish almost all 3D graph structures . The uncovered cases are clearly stated and they seem rarely appear in practice . By naturally using relative 3D information and a novel torsion , SMP yields predictions that are invariant to translation and rotation of input graphs . We apply the SMP to real-world molecular learning , where meaningful physical representations are needed . Geometries ( d , θ , φ ) specified by SMP are then physically represented by Ψ ( d , θ , φ ) , which can be a solution to the Schrödinger equation , as described in Sec . 4 . Based on this , we develop the spherical message passing neural networks , known as the SphereNet , for 3D molecular learning . We conduct experiments on various types of datasets including OC20 , QM9 , and MD17 . Results show that , compared with baseline methods , SphereNet achieves the best performance without increasing the computing budget . Ablation study reveals contributions and necessity of different types of 3D information , including distance , angle , and torsion . Particularly , we compare with a complete message passing scheme that can distinguish all 3D graph structures but involves edge-based 2-hop information . Experimental results show that SphereNet achieves comparable performance but reduces running time by 4 times . This suggests the use of SphereNet in practice rather than the complete message passing scheme , whose computational complexity prevents its use on large molecules . 2 COMPLETE REPRESENTATIONS OF MOLECULES . Equivariant graph neural networks ( EGNNs ) represent one research area for 3D molecular graphs , as introduced in Sec . 5.1 . These methods usually take coordinates in the Cartesian coordinate system ( CCS ) for all atoms as the raw input . Hence , all the network layers need to be carefully designed to be equivariant . The computing of some equivariant components is expensive , like spherical harmonics and Clebsh-Gordan coefficients ( Thomas et al. , 2018 ; Fuchs et al. , 2020 ) . In addition , the complicated SE ( 3 ) group representations may not be necessary for molecular learning where final representations are generally required to be invariant . In this work , we focus on the other category of methods that take relative position information purely as input to graph learning models . Relative 3D information could be distance or angle , which is inherently invariant to translation and rotation of input molecules . It is natural to consider such information in the spherical coordinate system ( SCS ) . We start by investigating the structure identification of 3D molecules in the SCS . For any point in the SCS , its location is specified by a 3-tuple ( d , θ , φ ) , where d , θ , and φ denote the radial distance , polar angle , and the azimuthal angle , respectively . When modeling 3D molecular graphs in the SCS , any atom i can be the origin of a local SCS , and d , θ , and φ naturally become the bond length , the angle between bonds , and the torsion angle , respectively . Thus , the relative location of each neighboring atom of atom i can be specified by the corresponding tuple ( d , θ , φ ) . Similarly , the relative location of each atom in the 3D molecular graph can be determined , leading to the identified structure , which is naturally invariant to translation and rotation of the input graph . The SCS can be easily converted from the Cartesian coordinate system , thus , the tuple ( d , θ , φ ) can be easily obtained . As in Fig . 1 , we use the chemical structure of the hydrogen peroxide ( H2O2 ) to show how d , θ , and φ are vital for the molecular structure identification . It is obvious that the structure is uniquely defined by the three bond lengths d1 , d2 , d3 , the two bond angles θ1 , θ2 , and the torsion angle φ . Note that the input may not contain all pairwise distances ( all possible bond lengths ) . This is because the atomic connectivity is usually based on real chemical bonds and cut-off distances . The cut-off distance is usually set as a hyperparameter . It is hard to guarantee that the cut-off is larger than any pairwise distance in a molecule . Hence , in this example , H-H bond length may not be considered as input if the cut-off is small . Setting a proper cut-off is even harder for other complicated and large molecules where a distance between two atoms could be large . In addition , considering all pairwise distances will cause severe redundancies , dramatically increasing the computational complexity . The model also easily gets confused by excessive noise , leading to unsatisfactory performance . From the perspective of completeness , using all pairwise distance is not capable of recognizing the chirality property . The chiral H2O2 molecules can not be distinguished even though the H-H bond is taken into account . To overcome the above challenges , we use a combination of distance , angle , and torsion for rigorous design and accurate learning . Apparently , the two O-H bonds can rotate around the O-O bond without changing any of the bond lengths and bond angles . In this situation , however , the torsion angle φ changes and the structure of the H2O2 varies accordingly . The importance of torsion angle has also been demonstrated in related research domains . Garg et al . ( 2020 ) formally shows that the torsion along with the port numbering can improve the expressive power of GNNs in distinguishing geometric graph properties , such as girth and circumference , etc . Other studies ( Ingraham et al. , 2019 ; Simm et al. , 2020 ) reveal that protein sequences and molecules can be accurately generated by considering the torsion in the given 3D structures . In this work , we propose SMP to systematically consider distance , angle , and torsion for approximately complete representation learning of 3D molecular graphs . Note that by using angle and torsion , SMP can easily recognize the chirality property . 3 SPHERICAL MESSAGE PASSING . 3.1 MESSAGE PASSING SCHEME . Currently , the class of message passing neural networks ( MPNNs ) ( Gilmer et al. , 2017 ) are one of the most widely used architectures for GNNs . Based upon the completeness analyses in Sec . 2 , we propose to perform message passing in the spherical coordinate system ( SCS ) , resulting in a novel and efficient scheme known as spherical message passing ( SMP ) . We show that message passing schemes used in existing methods , such as SchNet and DimeNet , are special cases of SMP . We first formally define a 3D molecular graph , which is usually represented as a 4-tuple G = ( u , V , E , P ) . The u ∈ Rdu is a global feature vector for the molecular graph G. V = { vi } i=1 : n is the set of atom features , where each vi ∈ Rdv is the feature vector for the atom i. E = { ( ek , rk , sk ) } k=1 : m is the set of edges , where each ek ∈ Rde is the feature vector , rk is the index of the receiver atom , and sk is the index of the sender atom for the edge k. P = { rh } h=1 : n is the set of 3D Cartesian coordinates that contains 3D spatial information for each atom . In addition , we let Ei = { ( ek , rk , sk ) } rk=i , k=1 : m denote the set of edges that point to the atom i , and Ni denote the indices of incoming nodes of atom i . The outputs after a message passing process include the updated global feature vector u′ ∈ Rdu , the updated atom features V ′ = { v′i } i=1 : n , and the updated edges E′ = { ( e′k , rk , sk ) } k=1 : m. An illustration of the message aggregation scheme for SMP is provided in Fig . 2 ( a ) . Apparently , the embedding of the atom rk is obtained by aggregating each incoming message ek . The message ek is updated based on Esk , the set of incoming messages pointing to the atom sk . Let q denote the sender atom of any message in Esk . Hence , we can define a local SCS , where sk serves as the origin , and the direction of the message ek naturally serves as the z-axis . We define a neighboring atom o of sk as the reference atom . Thus , the reference plane is formed by three atoms sk , rk , and o . For atom q , its location is uniquely defined by the tuple ( d , θ , φ ) , as shown in Fig . 4 ( a ) . Specifically , d determines its distance to the atom sk , θ specifies its direction to update the message ek . The torsion angle φ is formed by the defined reference plane and the plane spanned by sk , rk , and q . Intuitively , as an advanced message passing architecture in spherical coordinates for 3D graphs , SMP specifies relative location for any neighboring atom q by considering all the distance , angle , and torsion information , leading to more comprehensive representations for 3D molecular graphs . Generally , the atom sk may have several neighboring atoms , which we denote as q1 , ... , qt . It is easy to compute the corresponding bond lengths and bond angles for these t atoms . The SMP computes torsion angles by projecting all the t atoms to the plane that is perpendicular to ek and intersect with sk . Then on this plane , the torsion angles are formed in a predefined direction , such as the anticlockwise direction . By doing this , any atom naturally becomes the reference atom for its next atom in the anticlockwise direction . Notably , the sum of these t torsion angles is 2π . A simplified case is illustrated in Fig . 2 ( b ) . The atom sk has three neighboring atoms q1 , q2 , and q3 ; q3 is the reference atom for q1 , and they form φ1 ; q1 is the reference atom for q2 , and they form φ2 ; similarly , q2 is the reference atom for q3 , and they form φ3 . It is obvious that the sum of φ1 , φ2 , and φ3 is 2π . As the torsion is defined relatively , q1 can be picked arbitrarily , which will not affect the output of the message passing scheme , as we perform summation when aggregating information to sk from its neighbors q1 , q2 , and q3 . Notably , by designing each atom to be the reference atom of the next one in the predefined direction , invariance is effectively achieved because reference atom is naturally relative . In addition , our method computes torsion within edge-based 1-hop neighborhood . Even though a torsion angle involves four atoms , our design avoids the number of torsion angles to be exponential , but makes it the same as the number of neighboring atoms . Hence , it is efficient and will not cause time or memory issues . Formally , the proposed SMP can be defined in the SCS as e′k = ϕ e ( ek , vrk , vsk , Esk , ρ p→e ( { rh } h=rk∪sk∪Nsk ) ) , v′i = ϕ v ( vi , ρ e→v ( E′i ) ) , u ′ = ϕu ( u , ρv→u ( V ′ ) ) , ( 1 ) where ϕe , ϕv , and ϕu are three information update functions on edges , atoms , and the whole graph , respectively . ρe→v and ρv→u aggregate information between different types of geometries . Especially , in SMP , the 3D information in P is converted and incorporated to update each message ek . Hence , SMP employs another position aggregation function ρp→e for message update . Notably , the main difference between our SMP scheme defined in Eq . 1 and the GN framework in Battaglia et al . ( 2018 ) is the inclusion of 3D information P . In line with the research area described in Sec . 5.1.2 , we focus on such 3D information and develop a systematic solution to incorporate it completely and efficiently . Detailed description of these functions is given in Appendix A . | The paper proposes a message passing scheme using spherical coordinates. It is tested on three datasets of 3D moleclular graphs. The paper offer an in depth analysis of different aspects, with an extensive experimentation of the method. | SP:8c58be104175e6410fa919e99333ff8d023c90f2 |
Spherical Message Passing for 3D Molecular Graphs | 1 INTRODUCTION . In many real-world studies , structured objects such as molecules are naturally modeled as graphs ( Gori et al. , 2005 ; Wu et al. , 2018 ; Shervashidze et al. , 2011 ; Fout et al. , 2017 ; Liu et al. , 2020 ; Wang et al. , 2020 ) . With the advances of deep learning , graph neural networks ( GNNs ) have been developed for learning from graph data ( Kipf & Welling , 2017 ; Defferrard et al. , 2016 ; Veličković et al. , 2018 ; Zhang et al. , 2018 ; Xu et al. , 2019 ; Gao & Ji , 2019 ; Gao et al. , 2018 ; 2020 ) . Currently , the message passing scheme ( Gilmer et al. , 2017 ; Sanchez-Gonzalez et al. , 2020 ; Vignac et al. , 2020 ; Battaglia et al. , 2018 ) is one of the commonly used architectures for realizing GNNs . In this work , we aim at developing a novel message passing method for 3D graphs . Generally , a 3D molecular graph contains 3D coordinates for each atom given in the Cartesian system along with the graph structure ( Liu et al. , 2019 ; Townshend et al. , 2019 ; Axelrod & Gomez-Bombarelli , 2020 ) . Different types of relative 3D information can be derived from 3D molecular graphs , and they can be important in molecular learning , such as bond lengths , angles between bonds ( Schütt et al. , 2017 ; Klicpera et al. , 2020b ) . We first investigate complete representations of 3D molecules . This requires the graph structure to be uniquely defined by relative 3D information . To this end , we conduct formal analyses in the spherical coordinate system ( SCS ) , and show that relative location of each atom in a 3D graph is uniquely determined by three geometries , including distance , angle , and torsion . However , such completeness needs to involve edge-based 2-hop information , leading to excessively high computational complexity . To circumvent the computational cost , we propose a novel message passing scheme , known as the spherical message passing ( SMP ) , for fast and accurate 3D molecular learning . Our SMP is efficient and approximately complete in representing 3D molecules . First , we design a novel strategy to compute torsion , which only considers edge-based 1-hop information , thus substantially reducing training complexity . This enables the generalization of SMP to large-scale molecules . In addition , we show that our SMP can distinguish almost all 3D graph structures . The uncovered cases are clearly stated and they seem rarely appear in practice . By naturally using relative 3D information and a novel torsion , SMP yields predictions that are invariant to translation and rotation of input graphs . We apply the SMP to real-world molecular learning , where meaningful physical representations are needed . Geometries ( d , θ , φ ) specified by SMP are then physically represented by Ψ ( d , θ , φ ) , which can be a solution to the Schrödinger equation , as described in Sec . 4 . Based on this , we develop the spherical message passing neural networks , known as the SphereNet , for 3D molecular learning . We conduct experiments on various types of datasets including OC20 , QM9 , and MD17 . Results show that , compared with baseline methods , SphereNet achieves the best performance without increasing the computing budget . Ablation study reveals contributions and necessity of different types of 3D information , including distance , angle , and torsion . Particularly , we compare with a complete message passing scheme that can distinguish all 3D graph structures but involves edge-based 2-hop information . Experimental results show that SphereNet achieves comparable performance but reduces running time by 4 times . This suggests the use of SphereNet in practice rather than the complete message passing scheme , whose computational complexity prevents its use on large molecules . 2 COMPLETE REPRESENTATIONS OF MOLECULES . Equivariant graph neural networks ( EGNNs ) represent one research area for 3D molecular graphs , as introduced in Sec . 5.1 . These methods usually take coordinates in the Cartesian coordinate system ( CCS ) for all atoms as the raw input . Hence , all the network layers need to be carefully designed to be equivariant . The computing of some equivariant components is expensive , like spherical harmonics and Clebsh-Gordan coefficients ( Thomas et al. , 2018 ; Fuchs et al. , 2020 ) . In addition , the complicated SE ( 3 ) group representations may not be necessary for molecular learning where final representations are generally required to be invariant . In this work , we focus on the other category of methods that take relative position information purely as input to graph learning models . Relative 3D information could be distance or angle , which is inherently invariant to translation and rotation of input molecules . It is natural to consider such information in the spherical coordinate system ( SCS ) . We start by investigating the structure identification of 3D molecules in the SCS . For any point in the SCS , its location is specified by a 3-tuple ( d , θ , φ ) , where d , θ , and φ denote the radial distance , polar angle , and the azimuthal angle , respectively . When modeling 3D molecular graphs in the SCS , any atom i can be the origin of a local SCS , and d , θ , and φ naturally become the bond length , the angle between bonds , and the torsion angle , respectively . Thus , the relative location of each neighboring atom of atom i can be specified by the corresponding tuple ( d , θ , φ ) . Similarly , the relative location of each atom in the 3D molecular graph can be determined , leading to the identified structure , which is naturally invariant to translation and rotation of the input graph . The SCS can be easily converted from the Cartesian coordinate system , thus , the tuple ( d , θ , φ ) can be easily obtained . As in Fig . 1 , we use the chemical structure of the hydrogen peroxide ( H2O2 ) to show how d , θ , and φ are vital for the molecular structure identification . It is obvious that the structure is uniquely defined by the three bond lengths d1 , d2 , d3 , the two bond angles θ1 , θ2 , and the torsion angle φ . Note that the input may not contain all pairwise distances ( all possible bond lengths ) . This is because the atomic connectivity is usually based on real chemical bonds and cut-off distances . The cut-off distance is usually set as a hyperparameter . It is hard to guarantee that the cut-off is larger than any pairwise distance in a molecule . Hence , in this example , H-H bond length may not be considered as input if the cut-off is small . Setting a proper cut-off is even harder for other complicated and large molecules where a distance between two atoms could be large . In addition , considering all pairwise distances will cause severe redundancies , dramatically increasing the computational complexity . The model also easily gets confused by excessive noise , leading to unsatisfactory performance . From the perspective of completeness , using all pairwise distance is not capable of recognizing the chirality property . The chiral H2O2 molecules can not be distinguished even though the H-H bond is taken into account . To overcome the above challenges , we use a combination of distance , angle , and torsion for rigorous design and accurate learning . Apparently , the two O-H bonds can rotate around the O-O bond without changing any of the bond lengths and bond angles . In this situation , however , the torsion angle φ changes and the structure of the H2O2 varies accordingly . The importance of torsion angle has also been demonstrated in related research domains . Garg et al . ( 2020 ) formally shows that the torsion along with the port numbering can improve the expressive power of GNNs in distinguishing geometric graph properties , such as girth and circumference , etc . Other studies ( Ingraham et al. , 2019 ; Simm et al. , 2020 ) reveal that protein sequences and molecules can be accurately generated by considering the torsion in the given 3D structures . In this work , we propose SMP to systematically consider distance , angle , and torsion for approximately complete representation learning of 3D molecular graphs . Note that by using angle and torsion , SMP can easily recognize the chirality property . 3 SPHERICAL MESSAGE PASSING . 3.1 MESSAGE PASSING SCHEME . Currently , the class of message passing neural networks ( MPNNs ) ( Gilmer et al. , 2017 ) are one of the most widely used architectures for GNNs . Based upon the completeness analyses in Sec . 2 , we propose to perform message passing in the spherical coordinate system ( SCS ) , resulting in a novel and efficient scheme known as spherical message passing ( SMP ) . We show that message passing schemes used in existing methods , such as SchNet and DimeNet , are special cases of SMP . We first formally define a 3D molecular graph , which is usually represented as a 4-tuple G = ( u , V , E , P ) . The u ∈ Rdu is a global feature vector for the molecular graph G. V = { vi } i=1 : n is the set of atom features , where each vi ∈ Rdv is the feature vector for the atom i. E = { ( ek , rk , sk ) } k=1 : m is the set of edges , where each ek ∈ Rde is the feature vector , rk is the index of the receiver atom , and sk is the index of the sender atom for the edge k. P = { rh } h=1 : n is the set of 3D Cartesian coordinates that contains 3D spatial information for each atom . In addition , we let Ei = { ( ek , rk , sk ) } rk=i , k=1 : m denote the set of edges that point to the atom i , and Ni denote the indices of incoming nodes of atom i . The outputs after a message passing process include the updated global feature vector u′ ∈ Rdu , the updated atom features V ′ = { v′i } i=1 : n , and the updated edges E′ = { ( e′k , rk , sk ) } k=1 : m. An illustration of the message aggregation scheme for SMP is provided in Fig . 2 ( a ) . Apparently , the embedding of the atom rk is obtained by aggregating each incoming message ek . The message ek is updated based on Esk , the set of incoming messages pointing to the atom sk . Let q denote the sender atom of any message in Esk . Hence , we can define a local SCS , where sk serves as the origin , and the direction of the message ek naturally serves as the z-axis . We define a neighboring atom o of sk as the reference atom . Thus , the reference plane is formed by three atoms sk , rk , and o . For atom q , its location is uniquely defined by the tuple ( d , θ , φ ) , as shown in Fig . 4 ( a ) . Specifically , d determines its distance to the atom sk , θ specifies its direction to update the message ek . The torsion angle φ is formed by the defined reference plane and the plane spanned by sk , rk , and q . Intuitively , as an advanced message passing architecture in spherical coordinates for 3D graphs , SMP specifies relative location for any neighboring atom q by considering all the distance , angle , and torsion information , leading to more comprehensive representations for 3D molecular graphs . Generally , the atom sk may have several neighboring atoms , which we denote as q1 , ... , qt . It is easy to compute the corresponding bond lengths and bond angles for these t atoms . The SMP computes torsion angles by projecting all the t atoms to the plane that is perpendicular to ek and intersect with sk . Then on this plane , the torsion angles are formed in a predefined direction , such as the anticlockwise direction . By doing this , any atom naturally becomes the reference atom for its next atom in the anticlockwise direction . Notably , the sum of these t torsion angles is 2π . A simplified case is illustrated in Fig . 2 ( b ) . The atom sk has three neighboring atoms q1 , q2 , and q3 ; q3 is the reference atom for q1 , and they form φ1 ; q1 is the reference atom for q2 , and they form φ2 ; similarly , q2 is the reference atom for q3 , and they form φ3 . It is obvious that the sum of φ1 , φ2 , and φ3 is 2π . As the torsion is defined relatively , q1 can be picked arbitrarily , which will not affect the output of the message passing scheme , as we perform summation when aggregating information to sk from its neighbors q1 , q2 , and q3 . Notably , by designing each atom to be the reference atom of the next one in the predefined direction , invariance is effectively achieved because reference atom is naturally relative . In addition , our method computes torsion within edge-based 1-hop neighborhood . Even though a torsion angle involves four atoms , our design avoids the number of torsion angles to be exponential , but makes it the same as the number of neighboring atoms . Hence , it is efficient and will not cause time or memory issues . Formally , the proposed SMP can be defined in the SCS as e′k = ϕ e ( ek , vrk , vsk , Esk , ρ p→e ( { rh } h=rk∪sk∪Nsk ) ) , v′i = ϕ v ( vi , ρ e→v ( E′i ) ) , u ′ = ϕu ( u , ρv→u ( V ′ ) ) , ( 1 ) where ϕe , ϕv , and ϕu are three information update functions on edges , atoms , and the whole graph , respectively . ρe→v and ρv→u aggregate information between different types of geometries . Especially , in SMP , the 3D information in P is converted and incorporated to update each message ek . Hence , SMP employs another position aggregation function ρp→e for message update . Notably , the main difference between our SMP scheme defined in Eq . 1 and the GN framework in Battaglia et al . ( 2018 ) is the inclusion of 3D information P . In line with the research area described in Sec . 5.1.2 , we focus on such 3D information and develop a systematic solution to incorporate it completely and efficiently . Detailed description of these functions is given in Appendix A . | This paper provides a novel geometric GNN: SMP. SMP is based on the SCS, and can reduce the complexity by an order of magnitude. Besides, it is a unified framework that can cover some mainstream geometric GNN methods. The empirical results support the effectiveness of SMP. | SP:8c58be104175e6410fa919e99333ff8d023c90f2 |
Spherical Message Passing for 3D Molecular Graphs | 1 INTRODUCTION . In many real-world studies , structured objects such as molecules are naturally modeled as graphs ( Gori et al. , 2005 ; Wu et al. , 2018 ; Shervashidze et al. , 2011 ; Fout et al. , 2017 ; Liu et al. , 2020 ; Wang et al. , 2020 ) . With the advances of deep learning , graph neural networks ( GNNs ) have been developed for learning from graph data ( Kipf & Welling , 2017 ; Defferrard et al. , 2016 ; Veličković et al. , 2018 ; Zhang et al. , 2018 ; Xu et al. , 2019 ; Gao & Ji , 2019 ; Gao et al. , 2018 ; 2020 ) . Currently , the message passing scheme ( Gilmer et al. , 2017 ; Sanchez-Gonzalez et al. , 2020 ; Vignac et al. , 2020 ; Battaglia et al. , 2018 ) is one of the commonly used architectures for realizing GNNs . In this work , we aim at developing a novel message passing method for 3D graphs . Generally , a 3D molecular graph contains 3D coordinates for each atom given in the Cartesian system along with the graph structure ( Liu et al. , 2019 ; Townshend et al. , 2019 ; Axelrod & Gomez-Bombarelli , 2020 ) . Different types of relative 3D information can be derived from 3D molecular graphs , and they can be important in molecular learning , such as bond lengths , angles between bonds ( Schütt et al. , 2017 ; Klicpera et al. , 2020b ) . We first investigate complete representations of 3D molecules . This requires the graph structure to be uniquely defined by relative 3D information . To this end , we conduct formal analyses in the spherical coordinate system ( SCS ) , and show that relative location of each atom in a 3D graph is uniquely determined by three geometries , including distance , angle , and torsion . However , such completeness needs to involve edge-based 2-hop information , leading to excessively high computational complexity . To circumvent the computational cost , we propose a novel message passing scheme , known as the spherical message passing ( SMP ) , for fast and accurate 3D molecular learning . Our SMP is efficient and approximately complete in representing 3D molecules . First , we design a novel strategy to compute torsion , which only considers edge-based 1-hop information , thus substantially reducing training complexity . This enables the generalization of SMP to large-scale molecules . In addition , we show that our SMP can distinguish almost all 3D graph structures . The uncovered cases are clearly stated and they seem rarely appear in practice . By naturally using relative 3D information and a novel torsion , SMP yields predictions that are invariant to translation and rotation of input graphs . We apply the SMP to real-world molecular learning , where meaningful physical representations are needed . Geometries ( d , θ , φ ) specified by SMP are then physically represented by Ψ ( d , θ , φ ) , which can be a solution to the Schrödinger equation , as described in Sec . 4 . Based on this , we develop the spherical message passing neural networks , known as the SphereNet , for 3D molecular learning . We conduct experiments on various types of datasets including OC20 , QM9 , and MD17 . Results show that , compared with baseline methods , SphereNet achieves the best performance without increasing the computing budget . Ablation study reveals contributions and necessity of different types of 3D information , including distance , angle , and torsion . Particularly , we compare with a complete message passing scheme that can distinguish all 3D graph structures but involves edge-based 2-hop information . Experimental results show that SphereNet achieves comparable performance but reduces running time by 4 times . This suggests the use of SphereNet in practice rather than the complete message passing scheme , whose computational complexity prevents its use on large molecules . 2 COMPLETE REPRESENTATIONS OF MOLECULES . Equivariant graph neural networks ( EGNNs ) represent one research area for 3D molecular graphs , as introduced in Sec . 5.1 . These methods usually take coordinates in the Cartesian coordinate system ( CCS ) for all atoms as the raw input . Hence , all the network layers need to be carefully designed to be equivariant . The computing of some equivariant components is expensive , like spherical harmonics and Clebsh-Gordan coefficients ( Thomas et al. , 2018 ; Fuchs et al. , 2020 ) . In addition , the complicated SE ( 3 ) group representations may not be necessary for molecular learning where final representations are generally required to be invariant . In this work , we focus on the other category of methods that take relative position information purely as input to graph learning models . Relative 3D information could be distance or angle , which is inherently invariant to translation and rotation of input molecules . It is natural to consider such information in the spherical coordinate system ( SCS ) . We start by investigating the structure identification of 3D molecules in the SCS . For any point in the SCS , its location is specified by a 3-tuple ( d , θ , φ ) , where d , θ , and φ denote the radial distance , polar angle , and the azimuthal angle , respectively . When modeling 3D molecular graphs in the SCS , any atom i can be the origin of a local SCS , and d , θ , and φ naturally become the bond length , the angle between bonds , and the torsion angle , respectively . Thus , the relative location of each neighboring atom of atom i can be specified by the corresponding tuple ( d , θ , φ ) . Similarly , the relative location of each atom in the 3D molecular graph can be determined , leading to the identified structure , which is naturally invariant to translation and rotation of the input graph . The SCS can be easily converted from the Cartesian coordinate system , thus , the tuple ( d , θ , φ ) can be easily obtained . As in Fig . 1 , we use the chemical structure of the hydrogen peroxide ( H2O2 ) to show how d , θ , and φ are vital for the molecular structure identification . It is obvious that the structure is uniquely defined by the three bond lengths d1 , d2 , d3 , the two bond angles θ1 , θ2 , and the torsion angle φ . Note that the input may not contain all pairwise distances ( all possible bond lengths ) . This is because the atomic connectivity is usually based on real chemical bonds and cut-off distances . The cut-off distance is usually set as a hyperparameter . It is hard to guarantee that the cut-off is larger than any pairwise distance in a molecule . Hence , in this example , H-H bond length may not be considered as input if the cut-off is small . Setting a proper cut-off is even harder for other complicated and large molecules where a distance between two atoms could be large . In addition , considering all pairwise distances will cause severe redundancies , dramatically increasing the computational complexity . The model also easily gets confused by excessive noise , leading to unsatisfactory performance . From the perspective of completeness , using all pairwise distance is not capable of recognizing the chirality property . The chiral H2O2 molecules can not be distinguished even though the H-H bond is taken into account . To overcome the above challenges , we use a combination of distance , angle , and torsion for rigorous design and accurate learning . Apparently , the two O-H bonds can rotate around the O-O bond without changing any of the bond lengths and bond angles . In this situation , however , the torsion angle φ changes and the structure of the H2O2 varies accordingly . The importance of torsion angle has also been demonstrated in related research domains . Garg et al . ( 2020 ) formally shows that the torsion along with the port numbering can improve the expressive power of GNNs in distinguishing geometric graph properties , such as girth and circumference , etc . Other studies ( Ingraham et al. , 2019 ; Simm et al. , 2020 ) reveal that protein sequences and molecules can be accurately generated by considering the torsion in the given 3D structures . In this work , we propose SMP to systematically consider distance , angle , and torsion for approximately complete representation learning of 3D molecular graphs . Note that by using angle and torsion , SMP can easily recognize the chirality property . 3 SPHERICAL MESSAGE PASSING . 3.1 MESSAGE PASSING SCHEME . Currently , the class of message passing neural networks ( MPNNs ) ( Gilmer et al. , 2017 ) are one of the most widely used architectures for GNNs . Based upon the completeness analyses in Sec . 2 , we propose to perform message passing in the spherical coordinate system ( SCS ) , resulting in a novel and efficient scheme known as spherical message passing ( SMP ) . We show that message passing schemes used in existing methods , such as SchNet and DimeNet , are special cases of SMP . We first formally define a 3D molecular graph , which is usually represented as a 4-tuple G = ( u , V , E , P ) . The u ∈ Rdu is a global feature vector for the molecular graph G. V = { vi } i=1 : n is the set of atom features , where each vi ∈ Rdv is the feature vector for the atom i. E = { ( ek , rk , sk ) } k=1 : m is the set of edges , where each ek ∈ Rde is the feature vector , rk is the index of the receiver atom , and sk is the index of the sender atom for the edge k. P = { rh } h=1 : n is the set of 3D Cartesian coordinates that contains 3D spatial information for each atom . In addition , we let Ei = { ( ek , rk , sk ) } rk=i , k=1 : m denote the set of edges that point to the atom i , and Ni denote the indices of incoming nodes of atom i . The outputs after a message passing process include the updated global feature vector u′ ∈ Rdu , the updated atom features V ′ = { v′i } i=1 : n , and the updated edges E′ = { ( e′k , rk , sk ) } k=1 : m. An illustration of the message aggregation scheme for SMP is provided in Fig . 2 ( a ) . Apparently , the embedding of the atom rk is obtained by aggregating each incoming message ek . The message ek is updated based on Esk , the set of incoming messages pointing to the atom sk . Let q denote the sender atom of any message in Esk . Hence , we can define a local SCS , where sk serves as the origin , and the direction of the message ek naturally serves as the z-axis . We define a neighboring atom o of sk as the reference atom . Thus , the reference plane is formed by three atoms sk , rk , and o . For atom q , its location is uniquely defined by the tuple ( d , θ , φ ) , as shown in Fig . 4 ( a ) . Specifically , d determines its distance to the atom sk , θ specifies its direction to update the message ek . The torsion angle φ is formed by the defined reference plane and the plane spanned by sk , rk , and q . Intuitively , as an advanced message passing architecture in spherical coordinates for 3D graphs , SMP specifies relative location for any neighboring atom q by considering all the distance , angle , and torsion information , leading to more comprehensive representations for 3D molecular graphs . Generally , the atom sk may have several neighboring atoms , which we denote as q1 , ... , qt . It is easy to compute the corresponding bond lengths and bond angles for these t atoms . The SMP computes torsion angles by projecting all the t atoms to the plane that is perpendicular to ek and intersect with sk . Then on this plane , the torsion angles are formed in a predefined direction , such as the anticlockwise direction . By doing this , any atom naturally becomes the reference atom for its next atom in the anticlockwise direction . Notably , the sum of these t torsion angles is 2π . A simplified case is illustrated in Fig . 2 ( b ) . The atom sk has three neighboring atoms q1 , q2 , and q3 ; q3 is the reference atom for q1 , and they form φ1 ; q1 is the reference atom for q2 , and they form φ2 ; similarly , q2 is the reference atom for q3 , and they form φ3 . It is obvious that the sum of φ1 , φ2 , and φ3 is 2π . As the torsion is defined relatively , q1 can be picked arbitrarily , which will not affect the output of the message passing scheme , as we perform summation when aggregating information to sk from its neighbors q1 , q2 , and q3 . Notably , by designing each atom to be the reference atom of the next one in the predefined direction , invariance is effectively achieved because reference atom is naturally relative . In addition , our method computes torsion within edge-based 1-hop neighborhood . Even though a torsion angle involves four atoms , our design avoids the number of torsion angles to be exponential , but makes it the same as the number of neighboring atoms . Hence , it is efficient and will not cause time or memory issues . Formally , the proposed SMP can be defined in the SCS as e′k = ϕ e ( ek , vrk , vsk , Esk , ρ p→e ( { rh } h=rk∪sk∪Nsk ) ) , v′i = ϕ v ( vi , ρ e→v ( E′i ) ) , u ′ = ϕu ( u , ρv→u ( V ′ ) ) , ( 1 ) where ϕe , ϕv , and ϕu are three information update functions on edges , atoms , and the whole graph , respectively . ρe→v and ρv→u aggregate information between different types of geometries . Especially , in SMP , the 3D information in P is converted and incorporated to update each message ek . Hence , SMP employs another position aggregation function ρp→e for message update . Notably , the main difference between our SMP scheme defined in Eq . 1 and the GN framework in Battaglia et al . ( 2018 ) is the inclusion of 3D information P . In line with the research area described in Sec . 5.1.2 , we focus on such 3D information and develop a systematic solution to incorporate it completely and efficiently . Detailed description of these functions is given in Appendix A . | This work aims at the representation learning of 3D molecular graphs and proposes a principled message passing framework to unify existing works. Besides, a novel message passing approach is presented by incorporating 3D geometric information including distance, angle, and torsion. In experiments, the performance of the proposed model is validated on three benchmark datasets. | SP:8c58be104175e6410fa919e99333ff8d023c90f2 |
Zero-CL: Instance and Feature decorrelation for negative-free symmetric contrastive learning | 1 INTRODUCTION . One of the current main bottlenecks in deep network training is the dependence on heavy annotated training data , and this motivates the recent surge of interests in unsupervised ( Donahue & Simonyan , 2019 ) and self-supervised ( Chen & He , 2021 ; Chen et al. , 2020 ) methods . Specifically , in self-supervised representation learning ( SSL ) , a network is pre-trained without any form of manual annotation , thus providing a means to extract information from unlabeled data sources ( e.g. , text corpora , videos , images from the Internet , etc. ) . In self-supervision , label-based information is replaced by a prediction problem using a certain context or using a pretext task . Pretext task in SSL can mainly be divided into three categories : 1 ) Generative based approaches ( Donahue & Simonyan , 2019 ) learn to generate or otherwise model pixels in the input space . However , pixel-level generation is computationally expensive and may not be necessary for representation learning . 2 ) Contextual based methods ( Vincent et al. , 2008 ; Pathak et al. , 2016 ; Ye et al. , 2019 ) design pretext tasks ( denoising auto-encoders ( Vincent et al. , 2008 ) , context auto encoders ( Zhang et al. , 2016 ; 2017 ) , etc ) . 3 ) Contrastive based methods ( Chen et al. , 2020 ; Grill et al. , 2020 ; Caron et al. , 2020 ; Asano et al. , 2019 ) take augmented views of the same image as positive pair and others as negative pairs . Generally , one positive sample corresponds to lots of negative samples . In recent works , contrastive based methods have shown great promise , achieving state-of-the-art results in image classification ( Chen et al. , 2020 ) , video classification ( Han et al. , 2020 ) and other downstream tasks ( Chen & He , 2021 ) . However , trivial constant solutions ( different samples get the same representation ) is easily happening without the proper design of architecture and objective function . The well-known solutions to avoid this problem can be summarized into two parts : asymmetric model architecture and proper objective function . 1 ) Model architecture : MoCo ( He et al. , 2020 ) , BYOL ( Grill et al. , 2020 ) update encoders separately and stopping gradient operation is adopted to avoid such problem . Then , BYOL and SimSiam ( Chen & He , 2021 ) introduce a predictor module to avoid collapse , which is composed by MLP ( Goodfellow et al. , 2016 ) . Current mainstream interpretation is using the predic- tor to construct an asymmetric structure , which is useful to alleviate trivial solutions . 2 ) Objective function : SimCLR uses symmetric framework in contrastive learning . They prevent trivial solutions by using negative pairs and InfoNCE , where InfoNCE can be divided into an alignment term and a uniformity term ( Arora et al. , 2019 ) . The uniformity term pulls different samples to a hyper-sphere uniformly , forcing obtaining different representations and avoiding trivial solutions . Recently , Barlow Twins ( Zbontar et al. , 2021 ) designs a new objective function from the information redundancy perspective , which also has two terms ( an invariance term and a redundancy reduction term ) . The invariance term maximizes the correlation of the same feature across different views , and the redundancy term reduces information redundancy . However , for the symmetric framework , both SimCLR and Barlow Twins require square order complexity in objective functions , and the main complexity comes from the uniformity and redundancy term . In this paper , we propose two methods , named Zero-ICL and Zero-FCL , where Zero-ICL discards the uniformity term and only requires O ( N ) complexity by instance-wise whitening . Correspondingly , Zero-FCL discards the redundancy term by feature-wise whitening and only requires O ( d ) complexity . Our contributions are : 1 ) We propose a new contrastive learning framework to prevent trivial solutions , Zero-CL , which includes two parts , i.e. , Zero-ICL ( instance-wise ) and Zero-FCL ( feature-wise ) , either of which can work independently and only requires linear order complexity ( objective function ) . 2 ) To our best knowledge , Zero-ICL is the first attempt of instance-wise whitening , which is conceptually comprehensible for preventing collapses in contrastive learning . Note that most previous methods ( including other domains beyond vision ) e.g . ( Eldar & Oppenheim , 2003 ; Kessy et al. , 2018 ) only use whitening transformation to reduce the information redundancy on feature-wise . 3 ) We give empirical analysis on the relationship between previous methods and our Zero-CL , where previous negative sample consuming methods ( Zbontar et al. , 2021 ; Chen et al. , 2020 ) can be regarded as our method with Lagrangian transformation . Then , we theoretically introduce ZCA-based whitening from the maximal correlation ( Kessy et al. , 2018 ) perspective . 4 ) Experimental results on standard image benchmarks ( CIFAR-10/100 and ImageNet-100/1k ) show our method achieves new state-of-the-art results for symmetric contrastive learning compared with ( Chen et al. , 2020 ; Zbontar et al. , 2021 ) , especially for small hidden dimension and batch size . 2 RELATED WORK . We review recent contrastive learning works . We mainly divide the previous contrastive methods into feature-wise and instance-wise according to different contrastive dimensions . We particularly discuss the similarity and differences of some most related methods in Section 5 in detail . instance-wise contrastive learning . instance-wise contrastive learning aims to attract positive pairs and repulse negative pairs ( Chen et al. , 2020 ; He et al. , 2020 ) , where each pair is composed of two instance views . One of the widely used objective functions in instance-wise learning is InfoNCE , and extensive experiments in ( Oord et al. , 2018 ) show that InfoNCE requires negative pairs to avoid trivial solutions . SimCLR ( Chen et al. , 2020 ) regards views augmented from different images in a mini-batch as negative pairs . However , SimCLR requires a large batch size to improve the accuracy , which is GPU intensive . To address this issue , MoCo ( He et al. , 2020 ) proposes storing negative samples in the memory bank and updates the bank by the first-in-first-out principle . MoCo further proposes two operations to prevent trivial solutions , i.e. , momentum update key encoder and stop gradient . In recent works ( Chen et al. , 2020 ; Grill et al. , 2020 ) , the mainstream explanation of the two operations is they construct an asymmetric framework , which can avoid trivial solutions . Inspired by this , BYOL ( Grill et al. , 2020 ) adopts stop gradient operation and EMA algorithm to update target encoder . Further , BYOL introduces a predictor module to build a more asymmetric framework . Then , SimSiam ( Chen & He , 2021 ) empirically shows that stop gradient and the predictor is the key component to avoid trivial solutions . Another approach to preventing such solutions is introduced in W-MSE ( Ermolov et al. , 2021 ) . Different from previous works ( Chen et al. , 2020 ; Chen & He , 2021 ; He et al. , 2020 ) , W-MSE requires multiple augmented views to improve the accuracy . Besides , WMSE simply borrows Cholesky-based whitening transformation in SSL and the multi-view objective requires O ( NM2 ) complexity , where M is the number of views . feature-wise contrastive learning . Different from instance-wise learning , feature-wise methods contrast on feature dimension . Barlow Twins ( Zbontar et al. , 2021 ) is the first feature-wise method , which pushes the cross-correlation matrix to identity matrix I . Its objective includes both invariance term and redundancy reduction term , where the latter term can avoid trivial solutions . Inspired by Barlow Twins , VICReg ( Bardes et al. , 2021 ) proposes a new regularization term named invariancecovariance on feature dimension , and achieves similar results to Barlow Twins . However , both Barlow Twins and VICReg require large contrastive dimensions and the covariance regularization requires O ( d2 ) complexity , which could be also regarded as requiring negative pairs on feature dimension ( each negative pair is composed of features in different dimensions across images ) . Whitening transformation . Whitening , or sphering , is a common pre-processing step to transform random variables to orthogonality . However , due to rotational freedom , there are infinitely many possible whitening procedures . There is a diverse range of sphering methods , e.g . principal component analysis ( PCA ) ( Jégou & Chum , 2012 ) , Cholesky matrix decomposition ( Higham , 1990 ) and zero-phase component analysis ( ZCA ) ( Bell & Sejnowski , 1997 ) . Compared with other whitening methods , ZCA remains maximal correlation of original data , which we will clarify in Sec . 3.6 . 3 THE PROPOSED ZERO-CL . In this section , we present the framework of Zero-CL in detail , starting with the whitening transformation procedure , followed by the model ’ s framework as well as the objective function . At last , we provide theoretical analysis on whitening from maximal correlation perspective . 3.1 WHITENING TRANSFORMATION . Given a set of images { x } Ni=1 , we extract an embedding in contrastive space zi = g ( f ( xi , θ ) , γ ) using an encoder network ( He et al. , 2016 ) f ( · , θ ) and a MLP module g ( · , γ ) , where zi ∈ R1×d . Denote the set of embeddings as Z ∈ RN×d , whitening transformation can be formulated as : H = ( h1 , h2 , · · · , hN ) = WZ > ( 1 ) where H ∈ Rd×N is the whitened embedding matrix . The square matrix W ∈ Rd×d is the socalled whitening matrix . Since var ( H ) = I , it follows that WΣW = I and thus W ( ΣW > W ) = W , which is fulfilled if W satisfies W > W = Σ−1 . However , the constraint does not uniquely determine the whitening matrix W. Specifically , for any Wrot = RW with orthogonal matrix , R will also be a whitening transformation matrix . Here we present ZCA whitening matrix in detail . ZCA-based whitening takes E ( stacks together eigenvectors of the covariance matrix ) as the orthogonal matrix R. Then ZCA whitening matrix can be written as : WZCA = EΛ−1/2E > ( 2 ) By rotation matrix E , the whitened data will be as close as possible to original data ( see Theorem 1 ) . Note that in low-rank conditions , i.e. , some eigenvalues equal to 0 , a common approach is replacing Λ−1/2 with ( Λ + λI ) −1/2 to prevent zero division , where λ = 1e− 4 as default . 3.2 SYMMETRIC OBJECTIVE FUNCTION BACKGROUND . For instance-wise contrastive learning , to avoid trivial solutions in the symmetric framework , the objective function usually can be divided into alignment and uniformity terms ( Arora et al. , 2019 ) . We now review the loss formulated in SimCLR ( Chen et al. , 2020 ) as : Linfo = E ( x , x+ ) ∼ppos [ −f ( x ) > f ( x+ ) /τ ] ︸ ︷︷ ︸ alignment +E ( x , x+ ) ∼ppos { x− i } N i=1 ∼pdata [ log ( ef ( x ) > f ( x + ) /τ + ∑ i ef ( x ) > f ( x−i ) /τ ) ] ︸ ︷︷ ︸ uniformity ( 3 ) where τ is the temperature hyper-parameter . x+ and x− are positive and negative samples , respectively . The first term is the so-called alignment , which maximizes the similarity between positive pairs . The second term is the key to prevent trivial solution , pushing all the data points on a unit hyper-sphere uniformly . Then , we rewrite the feature-wise objective of Barlow Twins as : LBT = ∑ i ( 1−Cii ) 2︸ ︷︷ ︸ invariance +λ ∑ i ∑ j 6=i C2ij︸ ︷︷ ︸ redundancy reduction ( 4 ) where C ∈ Rd×d is the covariance matrix . The first term encourages correlation of the same feature across different views , while the second term minimizes correlation of different features . We can observe that the objective of both instance-wise and feature-wise methods requires square order calculation complexity , where the first term ( alignment , invariance ) requires linear order complexity and the second term ( uniformity , redundancy reduction ) requires square order complexity . We wonder if we can discard the second term , i.e. , completely discard negative pairs . | This paper presents a new self-supervised learning objective that aims to further adapt the previous decorrelation-based [1] contrastive learning method [Bardes, 2021], which largely alleviates the trivial solutions in SSL. Compared with prior arts, the proposed Zero-ICL/FCL are constructed from mainly the aspects of instance and feature-wise. In particular, Zero-CL requires no negative samples; feature-wise FCL discards the redundancy term by feature-wise whitening, and the proposed ICL prevents the collapse of contrastive learning effectively. Quantitative evaluations validate that Zero-CL leads to on-par performances with previous state-of-the-art results. | SP:4a2f4e8574d83dc747b286b888147b63cdea823e |
Zero-CL: Instance and Feature decorrelation for negative-free symmetric contrastive learning | 1 INTRODUCTION . One of the current main bottlenecks in deep network training is the dependence on heavy annotated training data , and this motivates the recent surge of interests in unsupervised ( Donahue & Simonyan , 2019 ) and self-supervised ( Chen & He , 2021 ; Chen et al. , 2020 ) methods . Specifically , in self-supervised representation learning ( SSL ) , a network is pre-trained without any form of manual annotation , thus providing a means to extract information from unlabeled data sources ( e.g. , text corpora , videos , images from the Internet , etc. ) . In self-supervision , label-based information is replaced by a prediction problem using a certain context or using a pretext task . Pretext task in SSL can mainly be divided into three categories : 1 ) Generative based approaches ( Donahue & Simonyan , 2019 ) learn to generate or otherwise model pixels in the input space . However , pixel-level generation is computationally expensive and may not be necessary for representation learning . 2 ) Contextual based methods ( Vincent et al. , 2008 ; Pathak et al. , 2016 ; Ye et al. , 2019 ) design pretext tasks ( denoising auto-encoders ( Vincent et al. , 2008 ) , context auto encoders ( Zhang et al. , 2016 ; 2017 ) , etc ) . 3 ) Contrastive based methods ( Chen et al. , 2020 ; Grill et al. , 2020 ; Caron et al. , 2020 ; Asano et al. , 2019 ) take augmented views of the same image as positive pair and others as negative pairs . Generally , one positive sample corresponds to lots of negative samples . In recent works , contrastive based methods have shown great promise , achieving state-of-the-art results in image classification ( Chen et al. , 2020 ) , video classification ( Han et al. , 2020 ) and other downstream tasks ( Chen & He , 2021 ) . However , trivial constant solutions ( different samples get the same representation ) is easily happening without the proper design of architecture and objective function . The well-known solutions to avoid this problem can be summarized into two parts : asymmetric model architecture and proper objective function . 1 ) Model architecture : MoCo ( He et al. , 2020 ) , BYOL ( Grill et al. , 2020 ) update encoders separately and stopping gradient operation is adopted to avoid such problem . Then , BYOL and SimSiam ( Chen & He , 2021 ) introduce a predictor module to avoid collapse , which is composed by MLP ( Goodfellow et al. , 2016 ) . Current mainstream interpretation is using the predic- tor to construct an asymmetric structure , which is useful to alleviate trivial solutions . 2 ) Objective function : SimCLR uses symmetric framework in contrastive learning . They prevent trivial solutions by using negative pairs and InfoNCE , where InfoNCE can be divided into an alignment term and a uniformity term ( Arora et al. , 2019 ) . The uniformity term pulls different samples to a hyper-sphere uniformly , forcing obtaining different representations and avoiding trivial solutions . Recently , Barlow Twins ( Zbontar et al. , 2021 ) designs a new objective function from the information redundancy perspective , which also has two terms ( an invariance term and a redundancy reduction term ) . The invariance term maximizes the correlation of the same feature across different views , and the redundancy term reduces information redundancy . However , for the symmetric framework , both SimCLR and Barlow Twins require square order complexity in objective functions , and the main complexity comes from the uniformity and redundancy term . In this paper , we propose two methods , named Zero-ICL and Zero-FCL , where Zero-ICL discards the uniformity term and only requires O ( N ) complexity by instance-wise whitening . Correspondingly , Zero-FCL discards the redundancy term by feature-wise whitening and only requires O ( d ) complexity . Our contributions are : 1 ) We propose a new contrastive learning framework to prevent trivial solutions , Zero-CL , which includes two parts , i.e. , Zero-ICL ( instance-wise ) and Zero-FCL ( feature-wise ) , either of which can work independently and only requires linear order complexity ( objective function ) . 2 ) To our best knowledge , Zero-ICL is the first attempt of instance-wise whitening , which is conceptually comprehensible for preventing collapses in contrastive learning . Note that most previous methods ( including other domains beyond vision ) e.g . ( Eldar & Oppenheim , 2003 ; Kessy et al. , 2018 ) only use whitening transformation to reduce the information redundancy on feature-wise . 3 ) We give empirical analysis on the relationship between previous methods and our Zero-CL , where previous negative sample consuming methods ( Zbontar et al. , 2021 ; Chen et al. , 2020 ) can be regarded as our method with Lagrangian transformation . Then , we theoretically introduce ZCA-based whitening from the maximal correlation ( Kessy et al. , 2018 ) perspective . 4 ) Experimental results on standard image benchmarks ( CIFAR-10/100 and ImageNet-100/1k ) show our method achieves new state-of-the-art results for symmetric contrastive learning compared with ( Chen et al. , 2020 ; Zbontar et al. , 2021 ) , especially for small hidden dimension and batch size . 2 RELATED WORK . We review recent contrastive learning works . We mainly divide the previous contrastive methods into feature-wise and instance-wise according to different contrastive dimensions . We particularly discuss the similarity and differences of some most related methods in Section 5 in detail . instance-wise contrastive learning . instance-wise contrastive learning aims to attract positive pairs and repulse negative pairs ( Chen et al. , 2020 ; He et al. , 2020 ) , where each pair is composed of two instance views . One of the widely used objective functions in instance-wise learning is InfoNCE , and extensive experiments in ( Oord et al. , 2018 ) show that InfoNCE requires negative pairs to avoid trivial solutions . SimCLR ( Chen et al. , 2020 ) regards views augmented from different images in a mini-batch as negative pairs . However , SimCLR requires a large batch size to improve the accuracy , which is GPU intensive . To address this issue , MoCo ( He et al. , 2020 ) proposes storing negative samples in the memory bank and updates the bank by the first-in-first-out principle . MoCo further proposes two operations to prevent trivial solutions , i.e. , momentum update key encoder and stop gradient . In recent works ( Chen et al. , 2020 ; Grill et al. , 2020 ) , the mainstream explanation of the two operations is they construct an asymmetric framework , which can avoid trivial solutions . Inspired by this , BYOL ( Grill et al. , 2020 ) adopts stop gradient operation and EMA algorithm to update target encoder . Further , BYOL introduces a predictor module to build a more asymmetric framework . Then , SimSiam ( Chen & He , 2021 ) empirically shows that stop gradient and the predictor is the key component to avoid trivial solutions . Another approach to preventing such solutions is introduced in W-MSE ( Ermolov et al. , 2021 ) . Different from previous works ( Chen et al. , 2020 ; Chen & He , 2021 ; He et al. , 2020 ) , W-MSE requires multiple augmented views to improve the accuracy . Besides , WMSE simply borrows Cholesky-based whitening transformation in SSL and the multi-view objective requires O ( NM2 ) complexity , where M is the number of views . feature-wise contrastive learning . Different from instance-wise learning , feature-wise methods contrast on feature dimension . Barlow Twins ( Zbontar et al. , 2021 ) is the first feature-wise method , which pushes the cross-correlation matrix to identity matrix I . Its objective includes both invariance term and redundancy reduction term , where the latter term can avoid trivial solutions . Inspired by Barlow Twins , VICReg ( Bardes et al. , 2021 ) proposes a new regularization term named invariancecovariance on feature dimension , and achieves similar results to Barlow Twins . However , both Barlow Twins and VICReg require large contrastive dimensions and the covariance regularization requires O ( d2 ) complexity , which could be also regarded as requiring negative pairs on feature dimension ( each negative pair is composed of features in different dimensions across images ) . Whitening transformation . Whitening , or sphering , is a common pre-processing step to transform random variables to orthogonality . However , due to rotational freedom , there are infinitely many possible whitening procedures . There is a diverse range of sphering methods , e.g . principal component analysis ( PCA ) ( Jégou & Chum , 2012 ) , Cholesky matrix decomposition ( Higham , 1990 ) and zero-phase component analysis ( ZCA ) ( Bell & Sejnowski , 1997 ) . Compared with other whitening methods , ZCA remains maximal correlation of original data , which we will clarify in Sec . 3.6 . 3 THE PROPOSED ZERO-CL . In this section , we present the framework of Zero-CL in detail , starting with the whitening transformation procedure , followed by the model ’ s framework as well as the objective function . At last , we provide theoretical analysis on whitening from maximal correlation perspective . 3.1 WHITENING TRANSFORMATION . Given a set of images { x } Ni=1 , we extract an embedding in contrastive space zi = g ( f ( xi , θ ) , γ ) using an encoder network ( He et al. , 2016 ) f ( · , θ ) and a MLP module g ( · , γ ) , where zi ∈ R1×d . Denote the set of embeddings as Z ∈ RN×d , whitening transformation can be formulated as : H = ( h1 , h2 , · · · , hN ) = WZ > ( 1 ) where H ∈ Rd×N is the whitened embedding matrix . The square matrix W ∈ Rd×d is the socalled whitening matrix . Since var ( H ) = I , it follows that WΣW = I and thus W ( ΣW > W ) = W , which is fulfilled if W satisfies W > W = Σ−1 . However , the constraint does not uniquely determine the whitening matrix W. Specifically , for any Wrot = RW with orthogonal matrix , R will also be a whitening transformation matrix . Here we present ZCA whitening matrix in detail . ZCA-based whitening takes E ( stacks together eigenvectors of the covariance matrix ) as the orthogonal matrix R. Then ZCA whitening matrix can be written as : WZCA = EΛ−1/2E > ( 2 ) By rotation matrix E , the whitened data will be as close as possible to original data ( see Theorem 1 ) . Note that in low-rank conditions , i.e. , some eigenvalues equal to 0 , a common approach is replacing Λ−1/2 with ( Λ + λI ) −1/2 to prevent zero division , where λ = 1e− 4 as default . 3.2 SYMMETRIC OBJECTIVE FUNCTION BACKGROUND . For instance-wise contrastive learning , to avoid trivial solutions in the symmetric framework , the objective function usually can be divided into alignment and uniformity terms ( Arora et al. , 2019 ) . We now review the loss formulated in SimCLR ( Chen et al. , 2020 ) as : Linfo = E ( x , x+ ) ∼ppos [ −f ( x ) > f ( x+ ) /τ ] ︸ ︷︷ ︸ alignment +E ( x , x+ ) ∼ppos { x− i } N i=1 ∼pdata [ log ( ef ( x ) > f ( x + ) /τ + ∑ i ef ( x ) > f ( x−i ) /τ ) ] ︸ ︷︷ ︸ uniformity ( 3 ) where τ is the temperature hyper-parameter . x+ and x− are positive and negative samples , respectively . The first term is the so-called alignment , which maximizes the similarity between positive pairs . The second term is the key to prevent trivial solution , pushing all the data points on a unit hyper-sphere uniformly . Then , we rewrite the feature-wise objective of Barlow Twins as : LBT = ∑ i ( 1−Cii ) 2︸ ︷︷ ︸ invariance +λ ∑ i ∑ j 6=i C2ij︸ ︷︷ ︸ redundancy reduction ( 4 ) where C ∈ Rd×d is the covariance matrix . The first term encourages correlation of the same feature across different views , while the second term minimizes correlation of different features . We can observe that the objective of both instance-wise and feature-wise methods requires square order calculation complexity , where the first term ( alignment , invariance ) requires linear order complexity and the second term ( uniformity , redundancy reduction ) requires square order complexity . We wonder if we can discard the second term , i.e. , completely discard negative pairs . | The paper is concerned with preventing the model collapse in the self-supervised learning scenario using contrastive losses. The main addition is an adaptation to the existing formulations that performs instance or feature whitening, avoiding the use of negative examples than can be expensive to store and to compute the similarity. Experiments on the selected datasets show that the method generally matches the current top-performing methods. | SP:4a2f4e8574d83dc747b286b888147b63cdea823e |
Zero-CL: Instance and Feature decorrelation for negative-free symmetric contrastive learning | 1 INTRODUCTION . One of the current main bottlenecks in deep network training is the dependence on heavy annotated training data , and this motivates the recent surge of interests in unsupervised ( Donahue & Simonyan , 2019 ) and self-supervised ( Chen & He , 2021 ; Chen et al. , 2020 ) methods . Specifically , in self-supervised representation learning ( SSL ) , a network is pre-trained without any form of manual annotation , thus providing a means to extract information from unlabeled data sources ( e.g. , text corpora , videos , images from the Internet , etc. ) . In self-supervision , label-based information is replaced by a prediction problem using a certain context or using a pretext task . Pretext task in SSL can mainly be divided into three categories : 1 ) Generative based approaches ( Donahue & Simonyan , 2019 ) learn to generate or otherwise model pixels in the input space . However , pixel-level generation is computationally expensive and may not be necessary for representation learning . 2 ) Contextual based methods ( Vincent et al. , 2008 ; Pathak et al. , 2016 ; Ye et al. , 2019 ) design pretext tasks ( denoising auto-encoders ( Vincent et al. , 2008 ) , context auto encoders ( Zhang et al. , 2016 ; 2017 ) , etc ) . 3 ) Contrastive based methods ( Chen et al. , 2020 ; Grill et al. , 2020 ; Caron et al. , 2020 ; Asano et al. , 2019 ) take augmented views of the same image as positive pair and others as negative pairs . Generally , one positive sample corresponds to lots of negative samples . In recent works , contrastive based methods have shown great promise , achieving state-of-the-art results in image classification ( Chen et al. , 2020 ) , video classification ( Han et al. , 2020 ) and other downstream tasks ( Chen & He , 2021 ) . However , trivial constant solutions ( different samples get the same representation ) is easily happening without the proper design of architecture and objective function . The well-known solutions to avoid this problem can be summarized into two parts : asymmetric model architecture and proper objective function . 1 ) Model architecture : MoCo ( He et al. , 2020 ) , BYOL ( Grill et al. , 2020 ) update encoders separately and stopping gradient operation is adopted to avoid such problem . Then , BYOL and SimSiam ( Chen & He , 2021 ) introduce a predictor module to avoid collapse , which is composed by MLP ( Goodfellow et al. , 2016 ) . Current mainstream interpretation is using the predic- tor to construct an asymmetric structure , which is useful to alleviate trivial solutions . 2 ) Objective function : SimCLR uses symmetric framework in contrastive learning . They prevent trivial solutions by using negative pairs and InfoNCE , where InfoNCE can be divided into an alignment term and a uniformity term ( Arora et al. , 2019 ) . The uniformity term pulls different samples to a hyper-sphere uniformly , forcing obtaining different representations and avoiding trivial solutions . Recently , Barlow Twins ( Zbontar et al. , 2021 ) designs a new objective function from the information redundancy perspective , which also has two terms ( an invariance term and a redundancy reduction term ) . The invariance term maximizes the correlation of the same feature across different views , and the redundancy term reduces information redundancy . However , for the symmetric framework , both SimCLR and Barlow Twins require square order complexity in objective functions , and the main complexity comes from the uniformity and redundancy term . In this paper , we propose two methods , named Zero-ICL and Zero-FCL , where Zero-ICL discards the uniformity term and only requires O ( N ) complexity by instance-wise whitening . Correspondingly , Zero-FCL discards the redundancy term by feature-wise whitening and only requires O ( d ) complexity . Our contributions are : 1 ) We propose a new contrastive learning framework to prevent trivial solutions , Zero-CL , which includes two parts , i.e. , Zero-ICL ( instance-wise ) and Zero-FCL ( feature-wise ) , either of which can work independently and only requires linear order complexity ( objective function ) . 2 ) To our best knowledge , Zero-ICL is the first attempt of instance-wise whitening , which is conceptually comprehensible for preventing collapses in contrastive learning . Note that most previous methods ( including other domains beyond vision ) e.g . ( Eldar & Oppenheim , 2003 ; Kessy et al. , 2018 ) only use whitening transformation to reduce the information redundancy on feature-wise . 3 ) We give empirical analysis on the relationship between previous methods and our Zero-CL , where previous negative sample consuming methods ( Zbontar et al. , 2021 ; Chen et al. , 2020 ) can be regarded as our method with Lagrangian transformation . Then , we theoretically introduce ZCA-based whitening from the maximal correlation ( Kessy et al. , 2018 ) perspective . 4 ) Experimental results on standard image benchmarks ( CIFAR-10/100 and ImageNet-100/1k ) show our method achieves new state-of-the-art results for symmetric contrastive learning compared with ( Chen et al. , 2020 ; Zbontar et al. , 2021 ) , especially for small hidden dimension and batch size . 2 RELATED WORK . We review recent contrastive learning works . We mainly divide the previous contrastive methods into feature-wise and instance-wise according to different contrastive dimensions . We particularly discuss the similarity and differences of some most related methods in Section 5 in detail . instance-wise contrastive learning . instance-wise contrastive learning aims to attract positive pairs and repulse negative pairs ( Chen et al. , 2020 ; He et al. , 2020 ) , where each pair is composed of two instance views . One of the widely used objective functions in instance-wise learning is InfoNCE , and extensive experiments in ( Oord et al. , 2018 ) show that InfoNCE requires negative pairs to avoid trivial solutions . SimCLR ( Chen et al. , 2020 ) regards views augmented from different images in a mini-batch as negative pairs . However , SimCLR requires a large batch size to improve the accuracy , which is GPU intensive . To address this issue , MoCo ( He et al. , 2020 ) proposes storing negative samples in the memory bank and updates the bank by the first-in-first-out principle . MoCo further proposes two operations to prevent trivial solutions , i.e. , momentum update key encoder and stop gradient . In recent works ( Chen et al. , 2020 ; Grill et al. , 2020 ) , the mainstream explanation of the two operations is they construct an asymmetric framework , which can avoid trivial solutions . Inspired by this , BYOL ( Grill et al. , 2020 ) adopts stop gradient operation and EMA algorithm to update target encoder . Further , BYOL introduces a predictor module to build a more asymmetric framework . Then , SimSiam ( Chen & He , 2021 ) empirically shows that stop gradient and the predictor is the key component to avoid trivial solutions . Another approach to preventing such solutions is introduced in W-MSE ( Ermolov et al. , 2021 ) . Different from previous works ( Chen et al. , 2020 ; Chen & He , 2021 ; He et al. , 2020 ) , W-MSE requires multiple augmented views to improve the accuracy . Besides , WMSE simply borrows Cholesky-based whitening transformation in SSL and the multi-view objective requires O ( NM2 ) complexity , where M is the number of views . feature-wise contrastive learning . Different from instance-wise learning , feature-wise methods contrast on feature dimension . Barlow Twins ( Zbontar et al. , 2021 ) is the first feature-wise method , which pushes the cross-correlation matrix to identity matrix I . Its objective includes both invariance term and redundancy reduction term , where the latter term can avoid trivial solutions . Inspired by Barlow Twins , VICReg ( Bardes et al. , 2021 ) proposes a new regularization term named invariancecovariance on feature dimension , and achieves similar results to Barlow Twins . However , both Barlow Twins and VICReg require large contrastive dimensions and the covariance regularization requires O ( d2 ) complexity , which could be also regarded as requiring negative pairs on feature dimension ( each negative pair is composed of features in different dimensions across images ) . Whitening transformation . Whitening , or sphering , is a common pre-processing step to transform random variables to orthogonality . However , due to rotational freedom , there are infinitely many possible whitening procedures . There is a diverse range of sphering methods , e.g . principal component analysis ( PCA ) ( Jégou & Chum , 2012 ) , Cholesky matrix decomposition ( Higham , 1990 ) and zero-phase component analysis ( ZCA ) ( Bell & Sejnowski , 1997 ) . Compared with other whitening methods , ZCA remains maximal correlation of original data , which we will clarify in Sec . 3.6 . 3 THE PROPOSED ZERO-CL . In this section , we present the framework of Zero-CL in detail , starting with the whitening transformation procedure , followed by the model ’ s framework as well as the objective function . At last , we provide theoretical analysis on whitening from maximal correlation perspective . 3.1 WHITENING TRANSFORMATION . Given a set of images { x } Ni=1 , we extract an embedding in contrastive space zi = g ( f ( xi , θ ) , γ ) using an encoder network ( He et al. , 2016 ) f ( · , θ ) and a MLP module g ( · , γ ) , where zi ∈ R1×d . Denote the set of embeddings as Z ∈ RN×d , whitening transformation can be formulated as : H = ( h1 , h2 , · · · , hN ) = WZ > ( 1 ) where H ∈ Rd×N is the whitened embedding matrix . The square matrix W ∈ Rd×d is the socalled whitening matrix . Since var ( H ) = I , it follows that WΣW = I and thus W ( ΣW > W ) = W , which is fulfilled if W satisfies W > W = Σ−1 . However , the constraint does not uniquely determine the whitening matrix W. Specifically , for any Wrot = RW with orthogonal matrix , R will also be a whitening transformation matrix . Here we present ZCA whitening matrix in detail . ZCA-based whitening takes E ( stacks together eigenvectors of the covariance matrix ) as the orthogonal matrix R. Then ZCA whitening matrix can be written as : WZCA = EΛ−1/2E > ( 2 ) By rotation matrix E , the whitened data will be as close as possible to original data ( see Theorem 1 ) . Note that in low-rank conditions , i.e. , some eigenvalues equal to 0 , a common approach is replacing Λ−1/2 with ( Λ + λI ) −1/2 to prevent zero division , where λ = 1e− 4 as default . 3.2 SYMMETRIC OBJECTIVE FUNCTION BACKGROUND . For instance-wise contrastive learning , to avoid trivial solutions in the symmetric framework , the objective function usually can be divided into alignment and uniformity terms ( Arora et al. , 2019 ) . We now review the loss formulated in SimCLR ( Chen et al. , 2020 ) as : Linfo = E ( x , x+ ) ∼ppos [ −f ( x ) > f ( x+ ) /τ ] ︸ ︷︷ ︸ alignment +E ( x , x+ ) ∼ppos { x− i } N i=1 ∼pdata [ log ( ef ( x ) > f ( x + ) /τ + ∑ i ef ( x ) > f ( x−i ) /τ ) ] ︸ ︷︷ ︸ uniformity ( 3 ) where τ is the temperature hyper-parameter . x+ and x− are positive and negative samples , respectively . The first term is the so-called alignment , which maximizes the similarity between positive pairs . The second term is the key to prevent trivial solution , pushing all the data points on a unit hyper-sphere uniformly . Then , we rewrite the feature-wise objective of Barlow Twins as : LBT = ∑ i ( 1−Cii ) 2︸ ︷︷ ︸ invariance +λ ∑ i ∑ j 6=i C2ij︸ ︷︷ ︸ redundancy reduction ( 4 ) where C ∈ Rd×d is the covariance matrix . The first term encourages correlation of the same feature across different views , while the second term minimizes correlation of different features . We can observe that the objective of both instance-wise and feature-wise methods requires square order calculation complexity , where the first term ( alignment , invariance ) requires linear order complexity and the second term ( uniformity , redundancy reduction ) requires square order complexity . We wonder if we can discard the second term , i.e. , completely discard negative pairs . | This paper addresses the collapse problem during self-supervised contrastive learning. ICL and FCL methods are proposed to decorrelate instances and features. Zero-Contrastive Learning can discard negative pairs with advantages in negative free, reducing correlation of different features to zero and retaining information during transformation. Promising experimental results are demonstrated on CIFAR and ImageNet. | SP:4a2f4e8574d83dc747b286b888147b63cdea823e |
Representing Mixtures of Word Embeddings with Mixtures of Topic Embeddings | 1 INTRODUCTION . For text analysis , topic models are widely used to extract a set of latent topics from a corpus ( a collection of documents ) . The extracted topics , revealing common word co-occurrence patterns within a document , often correspond to semantically meaningful concepts in the training corpus . Bayesian probabilistic topic models ( BPTMs ) , such as latent Dirichlet allocation ( LDA ) ( Blei et al. , 2003 ; Griffiths & Steyvers , 2004 ) and its nonparametric Bayesian generalizations ( Teh et al. , 2006 ; Zhou et al. , 2012 ) , have been the most popular ones . A BPTM is often formulated as a generative model that explains how each word of a document is generated given a set of topics and document-specific topic proportions . Bayesian inference of a BPTM is usually based on Gibbs sampling or variational inference ( VI ) , which can be less scalable for big corpora and need to be customized accordingly . With the recent development in auto-encoding VI , originated from variational autoencoders ( VAEs ) ( Kingma & Welling , 2014 ; Rezende et al. , 2014 ) , deep neural networks have been successfully used to develop neural topic models ( NTMs ) ( Miao et al. , 2016 ; Srivastava & Sutton , 2017 ; Burkhardt & Kramer , 2019 ; Zhang et al. , 2018 ; Dieng et al. , 2020 ; Zhao et al. , 2021 ) . The key advantage of NTMs is that approximate posterior inference can be carried out easily via a forward pass of the encoder network , without the need for expensive iterative inference scheme per test observation as in both Gibbs sampling and conventional VI . Hence , NTMs enjoy better flexibility and scalability than BPTMs . However , the reparameterization trick in VAEs can not be directly applied to the Dirichlet ( Burkhardt & Kramer , 2019 ) or gamma distributions ( Zhang et al. , 2018 ) , which are usually used as the prior and conditional posterior of latent topics and topic proportions , so approximations have to be used , potentially putting additional complexity or approximation errors . ∗Equal contribution . To address the above shortcomings , we in this paper propose a novel topic modeling framework in an intuitive and effective manner of enjoying several appealing properties over previously developed BPTMs and NTMs . Like other TMs , we also focus on learning the global topics shared across the corpus and the document-specific topic proportions , which are the two key outputs of a topic model . Without building an explicit generative process , we formulate the learning of topic model ( e.g. , optimizing the likelihood ) as the process of minimizing the distance between each observed document j and its corresponding trainable distribution . More specifically , the former ( document j ) can be regarded as as an empirical discrete distribution Pj , which has an uniform measure over all the words within this document . To construct the latter ( trainable distribution ) , we can represent Pj with K shared topics and its K-dimensional document-specific topic proportion , defined as Qj , where we view shared topics as K elements and topic proportion as the probability measure in Qj . It is very reasonable since the k-th element in topic proportion measures the weight of topic k for a document , and the document can be represented perfectly using the learned topic proportion and topics from a desired TM . Recalling that each topic and word are usually live in the V -dimensional ( vocabulary size ) space in TMs , it might be difficult to directly optimize the distance between Pj and Qj over V -dimensional space . Motivated by Dieng et al . ( 2020 ) , we further assume that both topics and words live in a H-dimensional embedding space , much smaller than vocabulary space . By abuse of notation , we still use Pj over the word embeddings and Qj over the topic embeddings as two representations for document j . Below , we turn towards pushing the document-specific to-be-learned distribution Qj to be as close as possible to the empirical distribution Pj . To this end , we develop a probabilistic bidirectional transport based method to measure the semantic difference between the two discrete distributions in an embedding space . By minimizing the expected difference between two Pj and Qj over all documents , we can learn the topic and word embeddings directly . Importantly , we naturally leverage semantic distances between topics and words in an embedding space to construct the point-to-point cost of moving between them , where the cost becomes a function of topic embeddings . Notably , we consider linking the word embeddings in Pj and topic embeddings in Qj in a bidirectional view . That is , given a word embedding drawn from Pj , it is more likely to be linked to a topic embedding that both is closer to it in the embedding space and exhibits a larger proportion in Qj ; vice versa . Our proposed framework has several key properties : 1 ) By bypassing the generative process , our proposed framework avoids the burden of developing complex sampling schemes or approximations for the posterior of BPTMs or NTMs . 2 ) The design of our proposed model complies with the principles of TMs , whose each learned topic describes an interpretable semantic concept . More interestingly , our model is flexible to learn word embeddings from scratch or use/finetune pretrained word embeddings . When pretrained word embeddings are used , our model naturally alleviates the issue of insufficient word co-occurrence information in short texts as discussed by prior work ( Dieng et al. , 2020 ; Zhao et al. , 2017 ; 2021 ) , which is one of the key drawbacks of many BPTMs and NTMs . 3 ) Conventional TMs usually enforce a simplex constraint on the topics over a fixed vocabulary , which hinders their applications in the case where the vocabulary varies . In our method , we view a document as a mixture of a set of words , which facilitates the deployment of the model when the size of the vocabulary varies . Finally , we have conducted comprehensive experiments on a wide variety of datasets in the comparison with advanced BPTMs and NTMs , which show that our model can achieve the state-of-the-art performance as well as applealing interpretability . 2 BACKGROUND . Topic Models : TMs usually represent each document in a corpus as a bag-of-words ( BoW ) count vector x ∈ RV+ , where xv represents the occurrences of word v in the vocabulary of size V . A TM aims to discover K topics in the corpus , each of which describes a specific semantic concept . A topic is or can be normalized into a distribution over the words in the vocabulary , named word distribution , φk ∈ ΣV , where ΣV is a V − 1 dimensional simplex and φvk indicates the weight or relevance of word v under this topic k. Each document comes from a mixture of topics , associated with a specific mixture proportion , which can be captured by a distribution over K topics , named topic proportion , θ ∈ ΣK , where θk indicates the weight of topic k for a document . As the most fundamental and popular series of TMs , BPTMs ( Blei et al. , 2003 ; Zhou et al. , 2012 ; Hoffman et al. , 2010 ) generate the document x with latent variables ( i.e. , topics { φk } Kk=1 and topic proportion θ ) sampled from pre-specified prior distributions ( e.g. , Gamma or Dirichlet ) . Like other Bayesian models , the learning process of a BPTM relies on Bayesian inference , such as variational inference or Gibbs sampling . Recently , NTMs ( Miao et al. , 2016 ; Srivastava & Sutton , 2017 ; Burkhardt & Kramer , 2019 ; Zhang et al. , 2018 ; Dieng et al. , 2020 ; Zhao et al. , 2021 ) have attracted significant research interests in topic modeling . Most existing NTMs can be regarded as extensions of BPTM like LDA within the VAEs framework ( Zhao et al. , 2021 ) . In general , NTMs consist of an encoder network that maps the ( normalized ) BoW input x to its topic proportion θ , and a decoder network that generates x conditioned on the topics { φk } Kk=1 and proportion θ . Despite their appealing flexibility and scalability , due to the unusable reparameterization trick in original VAEs for the Dirichlet or gamma distributions , NTMs have to develop complex sampling schemes or approximations , leading to potentially large approximation errors or learning complexity . Compare Two Discrete Distributions : This paper aims to quantify the difference between two discrete distributions ( word embeddings and topic embeddings ) , whose supports are points in the same embedding space . Specifically , let p and q be two discrete probability measures on the arbitrary space X ⊆ RH , formulated as p = ∑n i=1 uiδxi and q = ∑m j=1 vjδyj , where u = [ ui ] ∈ Σn and v = [ vj ] ∈ Σm denote two distributions of the discrete states . To measure the distance between p and q , a non-trivial way is to use optimal transport ( OT ) ( Peyré & Cuturi , 2019 ) , which defines the distance as an optimization problem as OT ( p , q ) : = min T∈Π ( u , v ) Tr ( T > C ) , ( 1 ) where C ∈ Rn×m≥0 is the transport cost matrix with Cij = c ( xi , yj ) , T ∈ R n×m > 0 a doubly stochastic transport matrix such that Π ( u , v ) = { T | T1Dv = u , T > 1Du = v } , Tij the transport probability between xi and yj , and Tr ( · ) the matrix trace . Since the transport plan is imposed on the constraint of T ∈ Π ( u , v ) , it has to be computed via constrained optimizations , such as the iterative Sinkhorn algorithm when an additional entropy regularization term is added ( Cuturi , 2013 ) . The recently introduced conditional transport ( CT ) framework ( Zheng & Zhou , 2020 ) can be used to measure the difference between two discrete distributions , which , like OT distance , does not require the distributions to share the same support . CT considers the transport plan in a bidirectional view , which consists of a forward transport plan as Tp→q and backward transport plan Tp←q . Therefore , the transport cost between two empirical distributions in CT can be expressed as CT ( p , q ) : = min Tp→q , Tq→p Tr [ ( Tp→q ) > C + ( Tq→p ) > C ] . ( 2 ) CT specifies Tp→qij =ui vje −dψ ( yj , xi ) ∑m j′=1 vj′e −dψ ( xi , yj′ ) and Tp←qij =vj uie −dψ ( yjxi ) ∑n i′=1 ui′e −dψ ( xi′ , yj ) and hence Tp→qij 1Dv = u and ( T p←q ij ) T1Du = v but in general T p←q ij 1Dv 6= u and ( T p→q ij ) T1Du 6= v. This provides a simpler way to measure the difference between p and q . Here dψ ( x , y ) = dψ ( y , x ) parameterized by ψ is defined to measure the difference between two vectors . This flexibility of CT potentially facilitates an easier integration with deep neural networks with a lower complexity and better scalability . These properties can be helpful to us in the development of a new topic modeling framework based on transportation between distributions , especially for neural topic models . | The manuscript proposes a combined topic modeling and word embedding method. The idea is to define word and topic embeddings in the same space, represent documents based on both of them, and use a transport-based method to train these two representations to be similar to each other. The final objective function combines a "conditional transport" objective with a log-likelihood term, and is optimized via Adam. Experiments find that the method achieves good topic coherence scores and document clustering metrics compared to baselines. | SP:3f355192300b36a619bbd2319a1c6eb0a6fbbf90 |
Representing Mixtures of Word Embeddings with Mixtures of Topic Embeddings | 1 INTRODUCTION . For text analysis , topic models are widely used to extract a set of latent topics from a corpus ( a collection of documents ) . The extracted topics , revealing common word co-occurrence patterns within a document , often correspond to semantically meaningful concepts in the training corpus . Bayesian probabilistic topic models ( BPTMs ) , such as latent Dirichlet allocation ( LDA ) ( Blei et al. , 2003 ; Griffiths & Steyvers , 2004 ) and its nonparametric Bayesian generalizations ( Teh et al. , 2006 ; Zhou et al. , 2012 ) , have been the most popular ones . A BPTM is often formulated as a generative model that explains how each word of a document is generated given a set of topics and document-specific topic proportions . Bayesian inference of a BPTM is usually based on Gibbs sampling or variational inference ( VI ) , which can be less scalable for big corpora and need to be customized accordingly . With the recent development in auto-encoding VI , originated from variational autoencoders ( VAEs ) ( Kingma & Welling , 2014 ; Rezende et al. , 2014 ) , deep neural networks have been successfully used to develop neural topic models ( NTMs ) ( Miao et al. , 2016 ; Srivastava & Sutton , 2017 ; Burkhardt & Kramer , 2019 ; Zhang et al. , 2018 ; Dieng et al. , 2020 ; Zhao et al. , 2021 ) . The key advantage of NTMs is that approximate posterior inference can be carried out easily via a forward pass of the encoder network , without the need for expensive iterative inference scheme per test observation as in both Gibbs sampling and conventional VI . Hence , NTMs enjoy better flexibility and scalability than BPTMs . However , the reparameterization trick in VAEs can not be directly applied to the Dirichlet ( Burkhardt & Kramer , 2019 ) or gamma distributions ( Zhang et al. , 2018 ) , which are usually used as the prior and conditional posterior of latent topics and topic proportions , so approximations have to be used , potentially putting additional complexity or approximation errors . ∗Equal contribution . To address the above shortcomings , we in this paper propose a novel topic modeling framework in an intuitive and effective manner of enjoying several appealing properties over previously developed BPTMs and NTMs . Like other TMs , we also focus on learning the global topics shared across the corpus and the document-specific topic proportions , which are the two key outputs of a topic model . Without building an explicit generative process , we formulate the learning of topic model ( e.g. , optimizing the likelihood ) as the process of minimizing the distance between each observed document j and its corresponding trainable distribution . More specifically , the former ( document j ) can be regarded as as an empirical discrete distribution Pj , which has an uniform measure over all the words within this document . To construct the latter ( trainable distribution ) , we can represent Pj with K shared topics and its K-dimensional document-specific topic proportion , defined as Qj , where we view shared topics as K elements and topic proportion as the probability measure in Qj . It is very reasonable since the k-th element in topic proportion measures the weight of topic k for a document , and the document can be represented perfectly using the learned topic proportion and topics from a desired TM . Recalling that each topic and word are usually live in the V -dimensional ( vocabulary size ) space in TMs , it might be difficult to directly optimize the distance between Pj and Qj over V -dimensional space . Motivated by Dieng et al . ( 2020 ) , we further assume that both topics and words live in a H-dimensional embedding space , much smaller than vocabulary space . By abuse of notation , we still use Pj over the word embeddings and Qj over the topic embeddings as two representations for document j . Below , we turn towards pushing the document-specific to-be-learned distribution Qj to be as close as possible to the empirical distribution Pj . To this end , we develop a probabilistic bidirectional transport based method to measure the semantic difference between the two discrete distributions in an embedding space . By minimizing the expected difference between two Pj and Qj over all documents , we can learn the topic and word embeddings directly . Importantly , we naturally leverage semantic distances between topics and words in an embedding space to construct the point-to-point cost of moving between them , where the cost becomes a function of topic embeddings . Notably , we consider linking the word embeddings in Pj and topic embeddings in Qj in a bidirectional view . That is , given a word embedding drawn from Pj , it is more likely to be linked to a topic embedding that both is closer to it in the embedding space and exhibits a larger proportion in Qj ; vice versa . Our proposed framework has several key properties : 1 ) By bypassing the generative process , our proposed framework avoids the burden of developing complex sampling schemes or approximations for the posterior of BPTMs or NTMs . 2 ) The design of our proposed model complies with the principles of TMs , whose each learned topic describes an interpretable semantic concept . More interestingly , our model is flexible to learn word embeddings from scratch or use/finetune pretrained word embeddings . When pretrained word embeddings are used , our model naturally alleviates the issue of insufficient word co-occurrence information in short texts as discussed by prior work ( Dieng et al. , 2020 ; Zhao et al. , 2017 ; 2021 ) , which is one of the key drawbacks of many BPTMs and NTMs . 3 ) Conventional TMs usually enforce a simplex constraint on the topics over a fixed vocabulary , which hinders their applications in the case where the vocabulary varies . In our method , we view a document as a mixture of a set of words , which facilitates the deployment of the model when the size of the vocabulary varies . Finally , we have conducted comprehensive experiments on a wide variety of datasets in the comparison with advanced BPTMs and NTMs , which show that our model can achieve the state-of-the-art performance as well as applealing interpretability . 2 BACKGROUND . Topic Models : TMs usually represent each document in a corpus as a bag-of-words ( BoW ) count vector x ∈ RV+ , where xv represents the occurrences of word v in the vocabulary of size V . A TM aims to discover K topics in the corpus , each of which describes a specific semantic concept . A topic is or can be normalized into a distribution over the words in the vocabulary , named word distribution , φk ∈ ΣV , where ΣV is a V − 1 dimensional simplex and φvk indicates the weight or relevance of word v under this topic k. Each document comes from a mixture of topics , associated with a specific mixture proportion , which can be captured by a distribution over K topics , named topic proportion , θ ∈ ΣK , where θk indicates the weight of topic k for a document . As the most fundamental and popular series of TMs , BPTMs ( Blei et al. , 2003 ; Zhou et al. , 2012 ; Hoffman et al. , 2010 ) generate the document x with latent variables ( i.e. , topics { φk } Kk=1 and topic proportion θ ) sampled from pre-specified prior distributions ( e.g. , Gamma or Dirichlet ) . Like other Bayesian models , the learning process of a BPTM relies on Bayesian inference , such as variational inference or Gibbs sampling . Recently , NTMs ( Miao et al. , 2016 ; Srivastava & Sutton , 2017 ; Burkhardt & Kramer , 2019 ; Zhang et al. , 2018 ; Dieng et al. , 2020 ; Zhao et al. , 2021 ) have attracted significant research interests in topic modeling . Most existing NTMs can be regarded as extensions of BPTM like LDA within the VAEs framework ( Zhao et al. , 2021 ) . In general , NTMs consist of an encoder network that maps the ( normalized ) BoW input x to its topic proportion θ , and a decoder network that generates x conditioned on the topics { φk } Kk=1 and proportion θ . Despite their appealing flexibility and scalability , due to the unusable reparameterization trick in original VAEs for the Dirichlet or gamma distributions , NTMs have to develop complex sampling schemes or approximations , leading to potentially large approximation errors or learning complexity . Compare Two Discrete Distributions : This paper aims to quantify the difference between two discrete distributions ( word embeddings and topic embeddings ) , whose supports are points in the same embedding space . Specifically , let p and q be two discrete probability measures on the arbitrary space X ⊆ RH , formulated as p = ∑n i=1 uiδxi and q = ∑m j=1 vjδyj , where u = [ ui ] ∈ Σn and v = [ vj ] ∈ Σm denote two distributions of the discrete states . To measure the distance between p and q , a non-trivial way is to use optimal transport ( OT ) ( Peyré & Cuturi , 2019 ) , which defines the distance as an optimization problem as OT ( p , q ) : = min T∈Π ( u , v ) Tr ( T > C ) , ( 1 ) where C ∈ Rn×m≥0 is the transport cost matrix with Cij = c ( xi , yj ) , T ∈ R n×m > 0 a doubly stochastic transport matrix such that Π ( u , v ) = { T | T1Dv = u , T > 1Du = v } , Tij the transport probability between xi and yj , and Tr ( · ) the matrix trace . Since the transport plan is imposed on the constraint of T ∈ Π ( u , v ) , it has to be computed via constrained optimizations , such as the iterative Sinkhorn algorithm when an additional entropy regularization term is added ( Cuturi , 2013 ) . The recently introduced conditional transport ( CT ) framework ( Zheng & Zhou , 2020 ) can be used to measure the difference between two discrete distributions , which , like OT distance , does not require the distributions to share the same support . CT considers the transport plan in a bidirectional view , which consists of a forward transport plan as Tp→q and backward transport plan Tp←q . Therefore , the transport cost between two empirical distributions in CT can be expressed as CT ( p , q ) : = min Tp→q , Tq→p Tr [ ( Tp→q ) > C + ( Tq→p ) > C ] . ( 2 ) CT specifies Tp→qij =ui vje −dψ ( yj , xi ) ∑m j′=1 vj′e −dψ ( xi , yj′ ) and Tp←qij =vj uie −dψ ( yjxi ) ∑n i′=1 ui′e −dψ ( xi′ , yj ) and hence Tp→qij 1Dv = u and ( T p←q ij ) T1Du = v but in general T p←q ij 1Dv 6= u and ( T p→q ij ) T1Du 6= v. This provides a simpler way to measure the difference between p and q . Here dψ ( x , y ) = dψ ( y , x ) parameterized by ψ is defined to measure the difference between two vectors . This flexibility of CT potentially facilitates an easier integration with deep neural networks with a lower complexity and better scalability . These properties can be helpful to us in the development of a new topic modeling framework based on transportation between distributions , especially for neural topic models . | Jointly learning latent topic representations with word embeddings has caught some attention in the past. The reason why researchers choose this route is to exploit the complementary advantage of both these models, for instance, to improve the performance of the model on short texts. In this paper, the authors study a new topic model where topics and words are encoded in the same embedding space. Usually, in the traditional topic modelling literature, the posterior inference is realised using algorithms such as Gibbs sampling or collapsed Gibbs sampling; however, in this paper, since the authors exploit complementary knowledge between the two models, the end-to-end model is jointly trained the document-specific discrete latent topic distribution is made to appear as close as possible to the discrete distribution over words in the document. A probabilistic bidirectional transport model is developed that measures the difference between the discrete distributions in the embedding space. The authors also discuss several key advantages of the model. Experiments are then followed with topic diversity and coherence measures as evaluation metrics which are widely used in the literature. Qualitatively, the authors show some example results from their dataset in the form of a t-SNE plot. | SP:3f355192300b36a619bbd2319a1c6eb0a6fbbf90 |
Representing Mixtures of Word Embeddings with Mixtures of Topic Embeddings | 1 INTRODUCTION . For text analysis , topic models are widely used to extract a set of latent topics from a corpus ( a collection of documents ) . The extracted topics , revealing common word co-occurrence patterns within a document , often correspond to semantically meaningful concepts in the training corpus . Bayesian probabilistic topic models ( BPTMs ) , such as latent Dirichlet allocation ( LDA ) ( Blei et al. , 2003 ; Griffiths & Steyvers , 2004 ) and its nonparametric Bayesian generalizations ( Teh et al. , 2006 ; Zhou et al. , 2012 ) , have been the most popular ones . A BPTM is often formulated as a generative model that explains how each word of a document is generated given a set of topics and document-specific topic proportions . Bayesian inference of a BPTM is usually based on Gibbs sampling or variational inference ( VI ) , which can be less scalable for big corpora and need to be customized accordingly . With the recent development in auto-encoding VI , originated from variational autoencoders ( VAEs ) ( Kingma & Welling , 2014 ; Rezende et al. , 2014 ) , deep neural networks have been successfully used to develop neural topic models ( NTMs ) ( Miao et al. , 2016 ; Srivastava & Sutton , 2017 ; Burkhardt & Kramer , 2019 ; Zhang et al. , 2018 ; Dieng et al. , 2020 ; Zhao et al. , 2021 ) . The key advantage of NTMs is that approximate posterior inference can be carried out easily via a forward pass of the encoder network , without the need for expensive iterative inference scheme per test observation as in both Gibbs sampling and conventional VI . Hence , NTMs enjoy better flexibility and scalability than BPTMs . However , the reparameterization trick in VAEs can not be directly applied to the Dirichlet ( Burkhardt & Kramer , 2019 ) or gamma distributions ( Zhang et al. , 2018 ) , which are usually used as the prior and conditional posterior of latent topics and topic proportions , so approximations have to be used , potentially putting additional complexity or approximation errors . ∗Equal contribution . To address the above shortcomings , we in this paper propose a novel topic modeling framework in an intuitive and effective manner of enjoying several appealing properties over previously developed BPTMs and NTMs . Like other TMs , we also focus on learning the global topics shared across the corpus and the document-specific topic proportions , which are the two key outputs of a topic model . Without building an explicit generative process , we formulate the learning of topic model ( e.g. , optimizing the likelihood ) as the process of minimizing the distance between each observed document j and its corresponding trainable distribution . More specifically , the former ( document j ) can be regarded as as an empirical discrete distribution Pj , which has an uniform measure over all the words within this document . To construct the latter ( trainable distribution ) , we can represent Pj with K shared topics and its K-dimensional document-specific topic proportion , defined as Qj , where we view shared topics as K elements and topic proportion as the probability measure in Qj . It is very reasonable since the k-th element in topic proportion measures the weight of topic k for a document , and the document can be represented perfectly using the learned topic proportion and topics from a desired TM . Recalling that each topic and word are usually live in the V -dimensional ( vocabulary size ) space in TMs , it might be difficult to directly optimize the distance between Pj and Qj over V -dimensional space . Motivated by Dieng et al . ( 2020 ) , we further assume that both topics and words live in a H-dimensional embedding space , much smaller than vocabulary space . By abuse of notation , we still use Pj over the word embeddings and Qj over the topic embeddings as two representations for document j . Below , we turn towards pushing the document-specific to-be-learned distribution Qj to be as close as possible to the empirical distribution Pj . To this end , we develop a probabilistic bidirectional transport based method to measure the semantic difference between the two discrete distributions in an embedding space . By minimizing the expected difference between two Pj and Qj over all documents , we can learn the topic and word embeddings directly . Importantly , we naturally leverage semantic distances between topics and words in an embedding space to construct the point-to-point cost of moving between them , where the cost becomes a function of topic embeddings . Notably , we consider linking the word embeddings in Pj and topic embeddings in Qj in a bidirectional view . That is , given a word embedding drawn from Pj , it is more likely to be linked to a topic embedding that both is closer to it in the embedding space and exhibits a larger proportion in Qj ; vice versa . Our proposed framework has several key properties : 1 ) By bypassing the generative process , our proposed framework avoids the burden of developing complex sampling schemes or approximations for the posterior of BPTMs or NTMs . 2 ) The design of our proposed model complies with the principles of TMs , whose each learned topic describes an interpretable semantic concept . More interestingly , our model is flexible to learn word embeddings from scratch or use/finetune pretrained word embeddings . When pretrained word embeddings are used , our model naturally alleviates the issue of insufficient word co-occurrence information in short texts as discussed by prior work ( Dieng et al. , 2020 ; Zhao et al. , 2017 ; 2021 ) , which is one of the key drawbacks of many BPTMs and NTMs . 3 ) Conventional TMs usually enforce a simplex constraint on the topics over a fixed vocabulary , which hinders their applications in the case where the vocabulary varies . In our method , we view a document as a mixture of a set of words , which facilitates the deployment of the model when the size of the vocabulary varies . Finally , we have conducted comprehensive experiments on a wide variety of datasets in the comparison with advanced BPTMs and NTMs , which show that our model can achieve the state-of-the-art performance as well as applealing interpretability . 2 BACKGROUND . Topic Models : TMs usually represent each document in a corpus as a bag-of-words ( BoW ) count vector x ∈ RV+ , where xv represents the occurrences of word v in the vocabulary of size V . A TM aims to discover K topics in the corpus , each of which describes a specific semantic concept . A topic is or can be normalized into a distribution over the words in the vocabulary , named word distribution , φk ∈ ΣV , where ΣV is a V − 1 dimensional simplex and φvk indicates the weight or relevance of word v under this topic k. Each document comes from a mixture of topics , associated with a specific mixture proportion , which can be captured by a distribution over K topics , named topic proportion , θ ∈ ΣK , where θk indicates the weight of topic k for a document . As the most fundamental and popular series of TMs , BPTMs ( Blei et al. , 2003 ; Zhou et al. , 2012 ; Hoffman et al. , 2010 ) generate the document x with latent variables ( i.e. , topics { φk } Kk=1 and topic proportion θ ) sampled from pre-specified prior distributions ( e.g. , Gamma or Dirichlet ) . Like other Bayesian models , the learning process of a BPTM relies on Bayesian inference , such as variational inference or Gibbs sampling . Recently , NTMs ( Miao et al. , 2016 ; Srivastava & Sutton , 2017 ; Burkhardt & Kramer , 2019 ; Zhang et al. , 2018 ; Dieng et al. , 2020 ; Zhao et al. , 2021 ) have attracted significant research interests in topic modeling . Most existing NTMs can be regarded as extensions of BPTM like LDA within the VAEs framework ( Zhao et al. , 2021 ) . In general , NTMs consist of an encoder network that maps the ( normalized ) BoW input x to its topic proportion θ , and a decoder network that generates x conditioned on the topics { φk } Kk=1 and proportion θ . Despite their appealing flexibility and scalability , due to the unusable reparameterization trick in original VAEs for the Dirichlet or gamma distributions , NTMs have to develop complex sampling schemes or approximations , leading to potentially large approximation errors or learning complexity . Compare Two Discrete Distributions : This paper aims to quantify the difference between two discrete distributions ( word embeddings and topic embeddings ) , whose supports are points in the same embedding space . Specifically , let p and q be two discrete probability measures on the arbitrary space X ⊆ RH , formulated as p = ∑n i=1 uiδxi and q = ∑m j=1 vjδyj , where u = [ ui ] ∈ Σn and v = [ vj ] ∈ Σm denote two distributions of the discrete states . To measure the distance between p and q , a non-trivial way is to use optimal transport ( OT ) ( Peyré & Cuturi , 2019 ) , which defines the distance as an optimization problem as OT ( p , q ) : = min T∈Π ( u , v ) Tr ( T > C ) , ( 1 ) where C ∈ Rn×m≥0 is the transport cost matrix with Cij = c ( xi , yj ) , T ∈ R n×m > 0 a doubly stochastic transport matrix such that Π ( u , v ) = { T | T1Dv = u , T > 1Du = v } , Tij the transport probability between xi and yj , and Tr ( · ) the matrix trace . Since the transport plan is imposed on the constraint of T ∈ Π ( u , v ) , it has to be computed via constrained optimizations , such as the iterative Sinkhorn algorithm when an additional entropy regularization term is added ( Cuturi , 2013 ) . The recently introduced conditional transport ( CT ) framework ( Zheng & Zhou , 2020 ) can be used to measure the difference between two discrete distributions , which , like OT distance , does not require the distributions to share the same support . CT considers the transport plan in a bidirectional view , which consists of a forward transport plan as Tp→q and backward transport plan Tp←q . Therefore , the transport cost between two empirical distributions in CT can be expressed as CT ( p , q ) : = min Tp→q , Tq→p Tr [ ( Tp→q ) > C + ( Tq→p ) > C ] . ( 2 ) CT specifies Tp→qij =ui vje −dψ ( yj , xi ) ∑m j′=1 vj′e −dψ ( xi , yj′ ) and Tp←qij =vj uie −dψ ( yjxi ) ∑n i′=1 ui′e −dψ ( xi′ , yj ) and hence Tp→qij 1Dv = u and ( T p←q ij ) T1Du = v but in general T p←q ij 1Dv 6= u and ( T p→q ij ) T1Du 6= v. This provides a simpler way to measure the difference between p and q . Here dψ ( x , y ) = dψ ( y , x ) parameterized by ψ is defined to measure the difference between two vectors . This flexibility of CT potentially facilitates an easier integration with deep neural networks with a lower complexity and better scalability . These properties can be helpful to us in the development of a new topic modeling framework based on transportation between distributions , especially for neural topic models . | This paper presents a new topic modeling framework called WeTe: each document in text corpus is represented as a bag of word embeddings vectors, and each topic is modeled as an embedding vector in the shared word embedding space. WeTe minimizes the expected difference between those two sets over all documents. A bidirectional transport-based method is proposed to learn the topic embeddings as well as topic proportions for documents efficiently. Extensive experiments on news and web pages show that the proposed model outperforms competitive methods for both deriving high-quality latent topics and generating better document representations for clustering tasks. | SP:3f355192300b36a619bbd2319a1c6eb0a6fbbf90 |
Demystifying Limited Adversarial Transferability in Automatic Speech Recognition Systems | 1 Introduction . It is hard to understate the pervasiveness of ASRs in security-critical systems . These include banking ( Amazon , 2021 ) , surveillance ( Froomkin , 2015 ) , online retail ( Vigderman , 2021 ) , and home security ( Bharadwaj , 2019 ) . However , ASRs are vulnerable to specially crafted adversarial samples , that force them to produce malicious outputs . In the research community , the most popular class of algorithms for this purpose are the optimization ( or gradient-based ) attacks ( Abdullah et al. , 2021b ) . This is largely because these attacks exhibit targeted transferability in some domains . Specifically , samples crafted for a local model ( surrogate ) can force a different black-box model ( target ) to produce the attacker chosen output . This is the case even if the surrogate and target use different architectures , training data , hyper-parameters , etc . Therefore , the transferability property has enabled attackers to exploit security-critical applications which include facial recognition systems ( Shan et al. , 2020 ) , image APIs ( Brown et al. , 2017 ; Liu et al. , 2016 ) , authentication systems ( Chen et al. , 2019 ) , and malware detectors ( Hu & Tan , 2017 ; Kreuk et al. , 2018b ; Grosse et al. , 2017 ) . In short , target transferability makes optimization attacks effective against several real-world systems . However , recent work has uncovered that these attacks do not exhibit target transferability between ASRs , even when the ASRs are trained on identical setups ( i.e. , same hyperparameters , architecture , random seed , training data ) ( Abdullah et al. , 2021b ) . Therefore , these attacks can not be used against black-box ASRs , casting doubt on the usefulness of the entire class of optimization attacks in the audio domain . However , the reasons for this failure is not understood . In this work , we study this phenomenon to uncover the factors that prevent the transferability of optimization attacks between ASRs . To ensure we can uncover each one of these factors , we perform an exhaustive ablation study on the entire ASR pipeline and observe the impact of the different components on the transferability rate . We test thousands of adversarial samples across multiple models and characterize six factors that impact the transferability rate . In doing so , we make the following contributions : 1 . We identify six previously unknown factors that impact target transferability . These include the input type , Mel Frequency Cepstral Coefficient ( MFCC ) , the Recurrent Neural Network ( RNN ) , output type , and the vocabulary and sequence sizes . These factors explain the near 0 % transferability rate seen in prior works . 2 . We highlight the relationship between accuracy and adversarial robustness in ASRs . The five factors that improve ASR robustness also improve accuracy . 3 . Our findings explain why one of the most popular classes of attacks , across the adversarial machine learning space , fails in the audio domain . These can be leveraged to strengthen models from other domains ( e.g. , images ) , that have traditionally been vulnerable to optimization attacks . We begin our study by listing all the factors from the existing literature that are known to hinder transferability ( Section 2.1 ) . Even when controlling for these factors , transferability rates in ASRs still do not achieve the near 100 % observed in the image models ( Section 4.1 ) . This suggests the existence of additional factors limiting transferability . We list the additional potential factors ( Section 2.3 ) , describe our design choices ( Section 3 ) , and through a series of ablation experiments , we systematically quantify the impact of each factor on transferability ( Section 4 ) . Based on our findings , we discuss several takeaways ( Section 5 ) , present related work ( Section 6 ) , and summarize our findings ( Section 7 ) . 2 Factors . 2.1 Known Factors From Existing Literature . Before delving into ASRs , it is first important to review the existing literature on transferability . While doing so , we identified 11 factors that are already known to limit transferability of optimization attacks : 1 . Smoothness of gradients ( Demontis et al. , 2019 ; Zhou et al. , 2018 ; Wu et al. , 2018 ) 2 . Attack type ( Kurakin et al. , 2016a ; Dong et al. , 2018 ; Liu et al. , 2016 ) 3 . Number of attack iterations ( Dong et al. , 2018 ) 4 . Number of output labels ( Liu et al. , 2016 ) 5 . Spectral makeup of the perturbations ( Sharma et al. , 2019 ; Guo et al. , 2018 ) 6 . Model architecture ( Wu et al. , 2018 ) 7 . Model accuracy ( Wu et al. , 2018 ) 8 . Model complexity ( Demontis et al. , 2019 ; Wu et al. , 2018 ; Wu & Zhu , 2020 ) 9 . Model agreement ( Tramèr et al. , 2017 ) 10 . Confidence of the adversarial sample ( Abdullah et al. , 2021b ) 11 . Asymmetry ( Wu et al. , 2018 ; Wu & Zhu , 2020 ) Unfortunately , outside of a single example ( Abdullah et al. , 2021b ) , the primary focus of most of these works has been image classification models . As a consequence , even when controlling for these factors , we observed that transferability between ASRs remains low ( Section 4.1 ) . This suggests the existence of unknown factors limiting transferability . 2.2 ASR Pipeline . To identify these unknown factors , we first provide a brief overview of the different components that make up the ASR pipeline ( Figure 1 ) . To that end , we consider the most commonly attacked ASR pipeline in the research community ( Abdullah et al. , 2021b ) . The first stage of an ASR splits the input audio into overlapping frames ( Figure 1 ( i ) ) . Next , a signal processing algorithm , ( e.g. , the MFCC ( Lin & Abdulla , 2015 ) ) extracts a feature vector from each of the overlapping frames ( Figure 1 ( ii ) ) . Next , the neural network ( Figure 1 ( iii ) ) assigns a single character label to each feature vector , resulting in a character list ( e.g. , “ hheellllo bbbboooob ” ) ( Figure 1 ( iv ) ) . These are then aggregated into a single word ( e.g. , “ hello ” ) , which is then combined with other words into a final sequence ( e.g . “ hello bob ” ) ( Figure 1 ( v ) ) . 2.3 Additional Potential Factors . Having described the ASR pipeline , we can now list the components that might potentially impact transferability . We will later experimentally investigate their impact during ablation study . These potential factors include : 2.3.1 Input Type : . Given previous findings ( Naseer et al. , 2019 ) , we hypothesize that the model ’ s input type can impact transferability . For example , audio inputs are time-varying and one-dimensional . They do not contain topographical structures . In contrast , images are two-dimensional , topographical inputs with neighborhoods of pixels representing a single object ( e.g. , pixels representing a dog ’ s snout ) . As a result , the input type will determine the model ’ s decision boundaries , which can impact transferability . 2.3.2 MFCC : . We hypothesize that the MFCC algorithm could be a factor limiting transferability . This algorithm uses hand-crafted filters to regularize the feature vector and consequently , remove the high spectral noise ( Mannell , 1994 ) . Since regularization of the decision boundary or gradients has been shown to impact transferability ( Demontis et al. , 2019 ; Zhou et al. , 2018 ; Wu et al. , 2018 ; Wu & Zhu , 2020 ) , we hypothesize that regularization of the feature vector using the MFCC plays a role as well . 2.3.3 RNN : . The network architecture can impact transferability as well . For example , the dropout layer , which is often included in model architectures for performance purposes , also inadvertently improves the transferability of adversarial samples ( Demontis et al. , 2019 ) . We hypothesize that the RNNis a factor limiting transferability in ASRs . This is because there are several RNN-based applications where authors have failed to demonstrate targeted transferability ( Abdullah et al. , 2021b ) .While these papers show transferability is hard in their respective domains , they do not contain definitive experiments studying why this is the case . 2.3.4 Output Type : . Since we know that output type can impact the transferability rate ( Wei et al. , 2018 ) , we hypothesize that a sequential output type ( instead of a single output label ) can influence it as well . This type of output is commonly found in ASRs . For an adversarial sample to transfer , the victim ASR needs to assign the attacker chosen character to each frame of the adversarial audio . This might increase the chances of a mistake , which for even a few frames , could lead to a semantically wrong transcript ( e.g. , “ cccaaatttt ” vs “ hhhaaatttt ” ) . 2.3.5 Vocabulary and Sequence Sizes : . The last factor we consider is the output complexity or the total number of output labels . Transferability becomes harder as the number of output labels increases ( Demontis et al. , 2019 ; Wu et al. , 2018 ; Wu & Zhu , 2020 ; Kurakin et al. , 2016b ) . However , the output labels are not fixed in ASRs , as they are in the case of images ( e.g. , 10 output labels for the MNIST dataset ) . This is because ASRs are designed to output variable size sequences to account for the variation in the input audio length . As a result , instead of considering total output labels , we use two metrics to capture output complexity : vocabulary and sequence sizes ( Figure 1 ( e ) and ( f ) ) . The vocabulary size is the number of unique words in the training data that the ASR has learned to recognize . Similarly , the sequence size is the average number of words in each audio sample in the dataset . Both of these variables work in tandem to account for the ASR ’ s output complexity . 3 Study Design . Having outlined the six potential factors , we can now design an ablation study to measure their impact on transferability . Designing this study is non-trivial since we need to account for the 11 known factors from existing literature ( Section 2.1 ) that limit transferability . If ignored , these factors alone can eliminate the transferability rate , hiding the effects of the aforementioned potential factors . We control for each of these 11 in our design . Initially , we ran our ablation study on DeepSpeech , a real-world ASR which is commonly used in the adversarial research community . However , our experiments consistently yielded 0 % transferability no matter what we did : removing or changing any of the ASR components did not change the transferability rate ( Appendix A.2. ) . Upon further investigation , we realized this was primarily due to the large complexity of the model ( a few million weights ) and training data , which forced the transferability rate to remain unchanged 0 % . Overcoming this complexity was one of the major challenges of our work . We had to carefully design our experiments to remove the impact of complexity that comes with realworld ASRs , while simultaneously exposing the hidden factors limiting transferability . As a consequence , we had to run our study on simple yet realistic ASR designs to uncover the factors impacting transferability . Dataset : Since transferability becomes harder with the total number of output labels ( Demontis et al. , 2019 ; Wu et al. , 2018 ; Wu & Zhu , 2020 ; Kurakin et al. , 2016b ) , we use the small Google Speech Commands dataset ( Warden , 2018 ) . This consists of clean , short audio files , each containing one of 30 unique labels . Each audio file is one second long ( or a vector of size ∼16,000 ) , either containing a number or a word . For the control experiment , we only choose a subset of the labels , specifically the numbers one to nine ( a total of nine labels ) . Model Architecture : With this data , we can now train a simple number recognition ASR . We use the same architecture ( Figure 1 ) typically found in existing adversarial research papers ( Abdullah et al. , 2021b ) The model outputs one of nine labels for a single audio . Additionally , we account for the known factors that hinder transferability . To do so , we train a small model of approximately 250,000 trainable parameters and do not include regularization ( e.g. , dropout ) to limit the effects of complexity and regularization . To reduce model complexity further , instead of using complex RNN cell types ( e.g. , LSTMs ( Gers et al. , 1999 ) and GRUs ( Chung et al. , 2014 ) ) , we use the vanilla RNN cell ( sim , 2021 ) ( referred to as RNN in the remainder of the paper ) . We train five instances of the ASR on the exact same setup and hyper-parameters ( architecture , random seed , epochs , batch size , training data slice , etc ) . Each of these is trained to the standard real-world ASR accuracy . Attack Formulation : For our experiment , we can choose from several existing audio domain optimization attacks . Since some of these attacks are architecture specific ( Abdullah et al. , 2020 ) , they have the potential to bias our results . As a consequence , we formulate a generic optimization attack that captures the intuition of existing works . This helps extend our results to all existing audio domain optimization attacks . To do so , we first outline the steps used by optimization attacks , which generally follow the same approach . First , a perturbation δ is produced by minimizing : ||δ| |22 + l ( x+ δ , t ) ( 1 ) where l is the loss function , x is the original audio sample , and t is the target label . Next , δ is clipped by magnitude factor α ∈ R to control the quality of the adversarial audio : δ = clip ( δ , α , −α ) ( 2 ) Lastly , the δ is added to the original audio x and clipped to create a valid sample xadv : xadv = clip ( x + δ , 1 , −1 ) ( 3 ) The clip step in Equation 2 is used to control the quality of the adversarial audio and is often specific to the target model architecture . For example , attacks that clip spectral gradients ( Qin et al. , 2019 ) can not work against end-to-end ASRs that do not have a spectrum generation step ( Abdullah et al. , 2020 ) . Therefore , in our generic attack , we remove Equation 2 making it model agnostic . Adversarial Audio Generation : We use this generic optimization attack to create adversarial samples for each of the five ASRs . Following prior work ( Abdullah et al. , 2021b ; Liu et al. , 2016 ) , we only perturb audio samples that all of the ASRs transcribed correctly . We attack every label in the dataset since some sample labels could be easier to perturb and some are easier to transfer ( Carlini et al. , 2019 ) . For example , we perturb an audio sample containing the label one to produce each of the remaining labels two to nine . Running the experiments in this exhaustive manner allows us to generalize our findings . We run the attack for 500 iterations . We save the adversarial sample every 50 iterations since the number of attack iterations can impact transferability ( Dong et al. , 2018 ) . We also ensure that every saved adversarial sample has confidence greater than 0.99 because lower confidence adversarial samples are less likely to transfer ( Abdullah et al. , 2021b ) . In total , we create 4050 adversarial audio samples . Transferability : Having created the adversarial samples for each of the five ASRs , we transfer them to the remaining four models . Targeted transferability is successful if both the surrogate and the target ASRs output the same target label . However , adversarial samples exhibit asymmetry ( Wu et al. , 2018 ; Wu & Zhu , 2020 ) , which is when an adversarial sample generated for model A transfers to model B , but not the other way around . To account for this , we average the number of successfully transferred samples between all five models . This final average is the transferability rate . | This paper presents an evaluation and explanation of the limited adversarial transferability in the ASR system. It first lists 11 known factors, e.g., smoothness of gradients, and then proposes four potential factors that limit the transferability. Then it examines the transferability in the DeepSpeech system and found its model is too complex for adversarial transferability. Hence, the author implements 5 ASR systems based on a simple model trained from the Google Speech Commands dataset. It generates 500 adversarial audio samples for each of the five ASRs and tries to transfer samples to others. The evaluation examines the target transferability rate of optimization attacks by one factor at a time. Then it gives some insights into the impact of each of the potential factors. | SP:a6d31e80b60bc886ed7dc8d636b62165e1086e68 |
Demystifying Limited Adversarial Transferability in Automatic Speech Recognition Systems | 1 Introduction . It is hard to understate the pervasiveness of ASRs in security-critical systems . These include banking ( Amazon , 2021 ) , surveillance ( Froomkin , 2015 ) , online retail ( Vigderman , 2021 ) , and home security ( Bharadwaj , 2019 ) . However , ASRs are vulnerable to specially crafted adversarial samples , that force them to produce malicious outputs . In the research community , the most popular class of algorithms for this purpose are the optimization ( or gradient-based ) attacks ( Abdullah et al. , 2021b ) . This is largely because these attacks exhibit targeted transferability in some domains . Specifically , samples crafted for a local model ( surrogate ) can force a different black-box model ( target ) to produce the attacker chosen output . This is the case even if the surrogate and target use different architectures , training data , hyper-parameters , etc . Therefore , the transferability property has enabled attackers to exploit security-critical applications which include facial recognition systems ( Shan et al. , 2020 ) , image APIs ( Brown et al. , 2017 ; Liu et al. , 2016 ) , authentication systems ( Chen et al. , 2019 ) , and malware detectors ( Hu & Tan , 2017 ; Kreuk et al. , 2018b ; Grosse et al. , 2017 ) . In short , target transferability makes optimization attacks effective against several real-world systems . However , recent work has uncovered that these attacks do not exhibit target transferability between ASRs , even when the ASRs are trained on identical setups ( i.e. , same hyperparameters , architecture , random seed , training data ) ( Abdullah et al. , 2021b ) . Therefore , these attacks can not be used against black-box ASRs , casting doubt on the usefulness of the entire class of optimization attacks in the audio domain . However , the reasons for this failure is not understood . In this work , we study this phenomenon to uncover the factors that prevent the transferability of optimization attacks between ASRs . To ensure we can uncover each one of these factors , we perform an exhaustive ablation study on the entire ASR pipeline and observe the impact of the different components on the transferability rate . We test thousands of adversarial samples across multiple models and characterize six factors that impact the transferability rate . In doing so , we make the following contributions : 1 . We identify six previously unknown factors that impact target transferability . These include the input type , Mel Frequency Cepstral Coefficient ( MFCC ) , the Recurrent Neural Network ( RNN ) , output type , and the vocabulary and sequence sizes . These factors explain the near 0 % transferability rate seen in prior works . 2 . We highlight the relationship between accuracy and adversarial robustness in ASRs . The five factors that improve ASR robustness also improve accuracy . 3 . Our findings explain why one of the most popular classes of attacks , across the adversarial machine learning space , fails in the audio domain . These can be leveraged to strengthen models from other domains ( e.g. , images ) , that have traditionally been vulnerable to optimization attacks . We begin our study by listing all the factors from the existing literature that are known to hinder transferability ( Section 2.1 ) . Even when controlling for these factors , transferability rates in ASRs still do not achieve the near 100 % observed in the image models ( Section 4.1 ) . This suggests the existence of additional factors limiting transferability . We list the additional potential factors ( Section 2.3 ) , describe our design choices ( Section 3 ) , and through a series of ablation experiments , we systematically quantify the impact of each factor on transferability ( Section 4 ) . Based on our findings , we discuss several takeaways ( Section 5 ) , present related work ( Section 6 ) , and summarize our findings ( Section 7 ) . 2 Factors . 2.1 Known Factors From Existing Literature . Before delving into ASRs , it is first important to review the existing literature on transferability . While doing so , we identified 11 factors that are already known to limit transferability of optimization attacks : 1 . Smoothness of gradients ( Demontis et al. , 2019 ; Zhou et al. , 2018 ; Wu et al. , 2018 ) 2 . Attack type ( Kurakin et al. , 2016a ; Dong et al. , 2018 ; Liu et al. , 2016 ) 3 . Number of attack iterations ( Dong et al. , 2018 ) 4 . Number of output labels ( Liu et al. , 2016 ) 5 . Spectral makeup of the perturbations ( Sharma et al. , 2019 ; Guo et al. , 2018 ) 6 . Model architecture ( Wu et al. , 2018 ) 7 . Model accuracy ( Wu et al. , 2018 ) 8 . Model complexity ( Demontis et al. , 2019 ; Wu et al. , 2018 ; Wu & Zhu , 2020 ) 9 . Model agreement ( Tramèr et al. , 2017 ) 10 . Confidence of the adversarial sample ( Abdullah et al. , 2021b ) 11 . Asymmetry ( Wu et al. , 2018 ; Wu & Zhu , 2020 ) Unfortunately , outside of a single example ( Abdullah et al. , 2021b ) , the primary focus of most of these works has been image classification models . As a consequence , even when controlling for these factors , we observed that transferability between ASRs remains low ( Section 4.1 ) . This suggests the existence of unknown factors limiting transferability . 2.2 ASR Pipeline . To identify these unknown factors , we first provide a brief overview of the different components that make up the ASR pipeline ( Figure 1 ) . To that end , we consider the most commonly attacked ASR pipeline in the research community ( Abdullah et al. , 2021b ) . The first stage of an ASR splits the input audio into overlapping frames ( Figure 1 ( i ) ) . Next , a signal processing algorithm , ( e.g. , the MFCC ( Lin & Abdulla , 2015 ) ) extracts a feature vector from each of the overlapping frames ( Figure 1 ( ii ) ) . Next , the neural network ( Figure 1 ( iii ) ) assigns a single character label to each feature vector , resulting in a character list ( e.g. , “ hheellllo bbbboooob ” ) ( Figure 1 ( iv ) ) . These are then aggregated into a single word ( e.g. , “ hello ” ) , which is then combined with other words into a final sequence ( e.g . “ hello bob ” ) ( Figure 1 ( v ) ) . 2.3 Additional Potential Factors . Having described the ASR pipeline , we can now list the components that might potentially impact transferability . We will later experimentally investigate their impact during ablation study . These potential factors include : 2.3.1 Input Type : . Given previous findings ( Naseer et al. , 2019 ) , we hypothesize that the model ’ s input type can impact transferability . For example , audio inputs are time-varying and one-dimensional . They do not contain topographical structures . In contrast , images are two-dimensional , topographical inputs with neighborhoods of pixels representing a single object ( e.g. , pixels representing a dog ’ s snout ) . As a result , the input type will determine the model ’ s decision boundaries , which can impact transferability . 2.3.2 MFCC : . We hypothesize that the MFCC algorithm could be a factor limiting transferability . This algorithm uses hand-crafted filters to regularize the feature vector and consequently , remove the high spectral noise ( Mannell , 1994 ) . Since regularization of the decision boundary or gradients has been shown to impact transferability ( Demontis et al. , 2019 ; Zhou et al. , 2018 ; Wu et al. , 2018 ; Wu & Zhu , 2020 ) , we hypothesize that regularization of the feature vector using the MFCC plays a role as well . 2.3.3 RNN : . The network architecture can impact transferability as well . For example , the dropout layer , which is often included in model architectures for performance purposes , also inadvertently improves the transferability of adversarial samples ( Demontis et al. , 2019 ) . We hypothesize that the RNNis a factor limiting transferability in ASRs . This is because there are several RNN-based applications where authors have failed to demonstrate targeted transferability ( Abdullah et al. , 2021b ) .While these papers show transferability is hard in their respective domains , they do not contain definitive experiments studying why this is the case . 2.3.4 Output Type : . Since we know that output type can impact the transferability rate ( Wei et al. , 2018 ) , we hypothesize that a sequential output type ( instead of a single output label ) can influence it as well . This type of output is commonly found in ASRs . For an adversarial sample to transfer , the victim ASR needs to assign the attacker chosen character to each frame of the adversarial audio . This might increase the chances of a mistake , which for even a few frames , could lead to a semantically wrong transcript ( e.g. , “ cccaaatttt ” vs “ hhhaaatttt ” ) . 2.3.5 Vocabulary and Sequence Sizes : . The last factor we consider is the output complexity or the total number of output labels . Transferability becomes harder as the number of output labels increases ( Demontis et al. , 2019 ; Wu et al. , 2018 ; Wu & Zhu , 2020 ; Kurakin et al. , 2016b ) . However , the output labels are not fixed in ASRs , as they are in the case of images ( e.g. , 10 output labels for the MNIST dataset ) . This is because ASRs are designed to output variable size sequences to account for the variation in the input audio length . As a result , instead of considering total output labels , we use two metrics to capture output complexity : vocabulary and sequence sizes ( Figure 1 ( e ) and ( f ) ) . The vocabulary size is the number of unique words in the training data that the ASR has learned to recognize . Similarly , the sequence size is the average number of words in each audio sample in the dataset . Both of these variables work in tandem to account for the ASR ’ s output complexity . 3 Study Design . Having outlined the six potential factors , we can now design an ablation study to measure their impact on transferability . Designing this study is non-trivial since we need to account for the 11 known factors from existing literature ( Section 2.1 ) that limit transferability . If ignored , these factors alone can eliminate the transferability rate , hiding the effects of the aforementioned potential factors . We control for each of these 11 in our design . Initially , we ran our ablation study on DeepSpeech , a real-world ASR which is commonly used in the adversarial research community . However , our experiments consistently yielded 0 % transferability no matter what we did : removing or changing any of the ASR components did not change the transferability rate ( Appendix A.2. ) . Upon further investigation , we realized this was primarily due to the large complexity of the model ( a few million weights ) and training data , which forced the transferability rate to remain unchanged 0 % . Overcoming this complexity was one of the major challenges of our work . We had to carefully design our experiments to remove the impact of complexity that comes with realworld ASRs , while simultaneously exposing the hidden factors limiting transferability . As a consequence , we had to run our study on simple yet realistic ASR designs to uncover the factors impacting transferability . Dataset : Since transferability becomes harder with the total number of output labels ( Demontis et al. , 2019 ; Wu et al. , 2018 ; Wu & Zhu , 2020 ; Kurakin et al. , 2016b ) , we use the small Google Speech Commands dataset ( Warden , 2018 ) . This consists of clean , short audio files , each containing one of 30 unique labels . Each audio file is one second long ( or a vector of size ∼16,000 ) , either containing a number or a word . For the control experiment , we only choose a subset of the labels , specifically the numbers one to nine ( a total of nine labels ) . Model Architecture : With this data , we can now train a simple number recognition ASR . We use the same architecture ( Figure 1 ) typically found in existing adversarial research papers ( Abdullah et al. , 2021b ) The model outputs one of nine labels for a single audio . Additionally , we account for the known factors that hinder transferability . To do so , we train a small model of approximately 250,000 trainable parameters and do not include regularization ( e.g. , dropout ) to limit the effects of complexity and regularization . To reduce model complexity further , instead of using complex RNN cell types ( e.g. , LSTMs ( Gers et al. , 1999 ) and GRUs ( Chung et al. , 2014 ) ) , we use the vanilla RNN cell ( sim , 2021 ) ( referred to as RNN in the remainder of the paper ) . We train five instances of the ASR on the exact same setup and hyper-parameters ( architecture , random seed , epochs , batch size , training data slice , etc ) . Each of these is trained to the standard real-world ASR accuracy . Attack Formulation : For our experiment , we can choose from several existing audio domain optimization attacks . Since some of these attacks are architecture specific ( Abdullah et al. , 2020 ) , they have the potential to bias our results . As a consequence , we formulate a generic optimization attack that captures the intuition of existing works . This helps extend our results to all existing audio domain optimization attacks . To do so , we first outline the steps used by optimization attacks , which generally follow the same approach . First , a perturbation δ is produced by minimizing : ||δ| |22 + l ( x+ δ , t ) ( 1 ) where l is the loss function , x is the original audio sample , and t is the target label . Next , δ is clipped by magnitude factor α ∈ R to control the quality of the adversarial audio : δ = clip ( δ , α , −α ) ( 2 ) Lastly , the δ is added to the original audio x and clipped to create a valid sample xadv : xadv = clip ( x + δ , 1 , −1 ) ( 3 ) The clip step in Equation 2 is used to control the quality of the adversarial audio and is often specific to the target model architecture . For example , attacks that clip spectral gradients ( Qin et al. , 2019 ) can not work against end-to-end ASRs that do not have a spectrum generation step ( Abdullah et al. , 2020 ) . Therefore , in our generic attack , we remove Equation 2 making it model agnostic . Adversarial Audio Generation : We use this generic optimization attack to create adversarial samples for each of the five ASRs . Following prior work ( Abdullah et al. , 2021b ; Liu et al. , 2016 ) , we only perturb audio samples that all of the ASRs transcribed correctly . We attack every label in the dataset since some sample labels could be easier to perturb and some are easier to transfer ( Carlini et al. , 2019 ) . For example , we perturb an audio sample containing the label one to produce each of the remaining labels two to nine . Running the experiments in this exhaustive manner allows us to generalize our findings . We run the attack for 500 iterations . We save the adversarial sample every 50 iterations since the number of attack iterations can impact transferability ( Dong et al. , 2018 ) . We also ensure that every saved adversarial sample has confidence greater than 0.99 because lower confidence adversarial samples are less likely to transfer ( Abdullah et al. , 2021b ) . In total , we create 4050 adversarial audio samples . Transferability : Having created the adversarial samples for each of the five ASRs , we transfer them to the remaining four models . Targeted transferability is successful if both the surrogate and the target ASRs output the same target label . However , adversarial samples exhibit asymmetry ( Wu et al. , 2018 ; Wu & Zhu , 2020 ) , which is when an adversarial sample generated for model A transfers to model B , but not the other way around . To account for this , we average the number of successfully transferred samples between all five models . This final average is the transferability rate . | The paper conducts a systematic study on the phenomenon that attacks targeting ASR systems often have low transferability. To do that, the authors take a representative ASR pipeline and perform ablation studies by modifying or removing the components that may have an effect on the attack transferability. Results show that many existing designs for improving the robustness of ASR can also prevent transfer attacks. Based on the findings, the authors also discuss the takeaways and future directions for the ASR. | SP:a6d31e80b60bc886ed7dc8d636b62165e1086e68 |
Demystifying Limited Adversarial Transferability in Automatic Speech Recognition Systems | 1 Introduction . It is hard to understate the pervasiveness of ASRs in security-critical systems . These include banking ( Amazon , 2021 ) , surveillance ( Froomkin , 2015 ) , online retail ( Vigderman , 2021 ) , and home security ( Bharadwaj , 2019 ) . However , ASRs are vulnerable to specially crafted adversarial samples , that force them to produce malicious outputs . In the research community , the most popular class of algorithms for this purpose are the optimization ( or gradient-based ) attacks ( Abdullah et al. , 2021b ) . This is largely because these attacks exhibit targeted transferability in some domains . Specifically , samples crafted for a local model ( surrogate ) can force a different black-box model ( target ) to produce the attacker chosen output . This is the case even if the surrogate and target use different architectures , training data , hyper-parameters , etc . Therefore , the transferability property has enabled attackers to exploit security-critical applications which include facial recognition systems ( Shan et al. , 2020 ) , image APIs ( Brown et al. , 2017 ; Liu et al. , 2016 ) , authentication systems ( Chen et al. , 2019 ) , and malware detectors ( Hu & Tan , 2017 ; Kreuk et al. , 2018b ; Grosse et al. , 2017 ) . In short , target transferability makes optimization attacks effective against several real-world systems . However , recent work has uncovered that these attacks do not exhibit target transferability between ASRs , even when the ASRs are trained on identical setups ( i.e. , same hyperparameters , architecture , random seed , training data ) ( Abdullah et al. , 2021b ) . Therefore , these attacks can not be used against black-box ASRs , casting doubt on the usefulness of the entire class of optimization attacks in the audio domain . However , the reasons for this failure is not understood . In this work , we study this phenomenon to uncover the factors that prevent the transferability of optimization attacks between ASRs . To ensure we can uncover each one of these factors , we perform an exhaustive ablation study on the entire ASR pipeline and observe the impact of the different components on the transferability rate . We test thousands of adversarial samples across multiple models and characterize six factors that impact the transferability rate . In doing so , we make the following contributions : 1 . We identify six previously unknown factors that impact target transferability . These include the input type , Mel Frequency Cepstral Coefficient ( MFCC ) , the Recurrent Neural Network ( RNN ) , output type , and the vocabulary and sequence sizes . These factors explain the near 0 % transferability rate seen in prior works . 2 . We highlight the relationship between accuracy and adversarial robustness in ASRs . The five factors that improve ASR robustness also improve accuracy . 3 . Our findings explain why one of the most popular classes of attacks , across the adversarial machine learning space , fails in the audio domain . These can be leveraged to strengthen models from other domains ( e.g. , images ) , that have traditionally been vulnerable to optimization attacks . We begin our study by listing all the factors from the existing literature that are known to hinder transferability ( Section 2.1 ) . Even when controlling for these factors , transferability rates in ASRs still do not achieve the near 100 % observed in the image models ( Section 4.1 ) . This suggests the existence of additional factors limiting transferability . We list the additional potential factors ( Section 2.3 ) , describe our design choices ( Section 3 ) , and through a series of ablation experiments , we systematically quantify the impact of each factor on transferability ( Section 4 ) . Based on our findings , we discuss several takeaways ( Section 5 ) , present related work ( Section 6 ) , and summarize our findings ( Section 7 ) . 2 Factors . 2.1 Known Factors From Existing Literature . Before delving into ASRs , it is first important to review the existing literature on transferability . While doing so , we identified 11 factors that are already known to limit transferability of optimization attacks : 1 . Smoothness of gradients ( Demontis et al. , 2019 ; Zhou et al. , 2018 ; Wu et al. , 2018 ) 2 . Attack type ( Kurakin et al. , 2016a ; Dong et al. , 2018 ; Liu et al. , 2016 ) 3 . Number of attack iterations ( Dong et al. , 2018 ) 4 . Number of output labels ( Liu et al. , 2016 ) 5 . Spectral makeup of the perturbations ( Sharma et al. , 2019 ; Guo et al. , 2018 ) 6 . Model architecture ( Wu et al. , 2018 ) 7 . Model accuracy ( Wu et al. , 2018 ) 8 . Model complexity ( Demontis et al. , 2019 ; Wu et al. , 2018 ; Wu & Zhu , 2020 ) 9 . Model agreement ( Tramèr et al. , 2017 ) 10 . Confidence of the adversarial sample ( Abdullah et al. , 2021b ) 11 . Asymmetry ( Wu et al. , 2018 ; Wu & Zhu , 2020 ) Unfortunately , outside of a single example ( Abdullah et al. , 2021b ) , the primary focus of most of these works has been image classification models . As a consequence , even when controlling for these factors , we observed that transferability between ASRs remains low ( Section 4.1 ) . This suggests the existence of unknown factors limiting transferability . 2.2 ASR Pipeline . To identify these unknown factors , we first provide a brief overview of the different components that make up the ASR pipeline ( Figure 1 ) . To that end , we consider the most commonly attacked ASR pipeline in the research community ( Abdullah et al. , 2021b ) . The first stage of an ASR splits the input audio into overlapping frames ( Figure 1 ( i ) ) . Next , a signal processing algorithm , ( e.g. , the MFCC ( Lin & Abdulla , 2015 ) ) extracts a feature vector from each of the overlapping frames ( Figure 1 ( ii ) ) . Next , the neural network ( Figure 1 ( iii ) ) assigns a single character label to each feature vector , resulting in a character list ( e.g. , “ hheellllo bbbboooob ” ) ( Figure 1 ( iv ) ) . These are then aggregated into a single word ( e.g. , “ hello ” ) , which is then combined with other words into a final sequence ( e.g . “ hello bob ” ) ( Figure 1 ( v ) ) . 2.3 Additional Potential Factors . Having described the ASR pipeline , we can now list the components that might potentially impact transferability . We will later experimentally investigate their impact during ablation study . These potential factors include : 2.3.1 Input Type : . Given previous findings ( Naseer et al. , 2019 ) , we hypothesize that the model ’ s input type can impact transferability . For example , audio inputs are time-varying and one-dimensional . They do not contain topographical structures . In contrast , images are two-dimensional , topographical inputs with neighborhoods of pixels representing a single object ( e.g. , pixels representing a dog ’ s snout ) . As a result , the input type will determine the model ’ s decision boundaries , which can impact transferability . 2.3.2 MFCC : . We hypothesize that the MFCC algorithm could be a factor limiting transferability . This algorithm uses hand-crafted filters to regularize the feature vector and consequently , remove the high spectral noise ( Mannell , 1994 ) . Since regularization of the decision boundary or gradients has been shown to impact transferability ( Demontis et al. , 2019 ; Zhou et al. , 2018 ; Wu et al. , 2018 ; Wu & Zhu , 2020 ) , we hypothesize that regularization of the feature vector using the MFCC plays a role as well . 2.3.3 RNN : . The network architecture can impact transferability as well . For example , the dropout layer , which is often included in model architectures for performance purposes , also inadvertently improves the transferability of adversarial samples ( Demontis et al. , 2019 ) . We hypothesize that the RNNis a factor limiting transferability in ASRs . This is because there are several RNN-based applications where authors have failed to demonstrate targeted transferability ( Abdullah et al. , 2021b ) .While these papers show transferability is hard in their respective domains , they do not contain definitive experiments studying why this is the case . 2.3.4 Output Type : . Since we know that output type can impact the transferability rate ( Wei et al. , 2018 ) , we hypothesize that a sequential output type ( instead of a single output label ) can influence it as well . This type of output is commonly found in ASRs . For an adversarial sample to transfer , the victim ASR needs to assign the attacker chosen character to each frame of the adversarial audio . This might increase the chances of a mistake , which for even a few frames , could lead to a semantically wrong transcript ( e.g. , “ cccaaatttt ” vs “ hhhaaatttt ” ) . 2.3.5 Vocabulary and Sequence Sizes : . The last factor we consider is the output complexity or the total number of output labels . Transferability becomes harder as the number of output labels increases ( Demontis et al. , 2019 ; Wu et al. , 2018 ; Wu & Zhu , 2020 ; Kurakin et al. , 2016b ) . However , the output labels are not fixed in ASRs , as they are in the case of images ( e.g. , 10 output labels for the MNIST dataset ) . This is because ASRs are designed to output variable size sequences to account for the variation in the input audio length . As a result , instead of considering total output labels , we use two metrics to capture output complexity : vocabulary and sequence sizes ( Figure 1 ( e ) and ( f ) ) . The vocabulary size is the number of unique words in the training data that the ASR has learned to recognize . Similarly , the sequence size is the average number of words in each audio sample in the dataset . Both of these variables work in tandem to account for the ASR ’ s output complexity . 3 Study Design . Having outlined the six potential factors , we can now design an ablation study to measure their impact on transferability . Designing this study is non-trivial since we need to account for the 11 known factors from existing literature ( Section 2.1 ) that limit transferability . If ignored , these factors alone can eliminate the transferability rate , hiding the effects of the aforementioned potential factors . We control for each of these 11 in our design . Initially , we ran our ablation study on DeepSpeech , a real-world ASR which is commonly used in the adversarial research community . However , our experiments consistently yielded 0 % transferability no matter what we did : removing or changing any of the ASR components did not change the transferability rate ( Appendix A.2. ) . Upon further investigation , we realized this was primarily due to the large complexity of the model ( a few million weights ) and training data , which forced the transferability rate to remain unchanged 0 % . Overcoming this complexity was one of the major challenges of our work . We had to carefully design our experiments to remove the impact of complexity that comes with realworld ASRs , while simultaneously exposing the hidden factors limiting transferability . As a consequence , we had to run our study on simple yet realistic ASR designs to uncover the factors impacting transferability . Dataset : Since transferability becomes harder with the total number of output labels ( Demontis et al. , 2019 ; Wu et al. , 2018 ; Wu & Zhu , 2020 ; Kurakin et al. , 2016b ) , we use the small Google Speech Commands dataset ( Warden , 2018 ) . This consists of clean , short audio files , each containing one of 30 unique labels . Each audio file is one second long ( or a vector of size ∼16,000 ) , either containing a number or a word . For the control experiment , we only choose a subset of the labels , specifically the numbers one to nine ( a total of nine labels ) . Model Architecture : With this data , we can now train a simple number recognition ASR . We use the same architecture ( Figure 1 ) typically found in existing adversarial research papers ( Abdullah et al. , 2021b ) The model outputs one of nine labels for a single audio . Additionally , we account for the known factors that hinder transferability . To do so , we train a small model of approximately 250,000 trainable parameters and do not include regularization ( e.g. , dropout ) to limit the effects of complexity and regularization . To reduce model complexity further , instead of using complex RNN cell types ( e.g. , LSTMs ( Gers et al. , 1999 ) and GRUs ( Chung et al. , 2014 ) ) , we use the vanilla RNN cell ( sim , 2021 ) ( referred to as RNN in the remainder of the paper ) . We train five instances of the ASR on the exact same setup and hyper-parameters ( architecture , random seed , epochs , batch size , training data slice , etc ) . Each of these is trained to the standard real-world ASR accuracy . Attack Formulation : For our experiment , we can choose from several existing audio domain optimization attacks . Since some of these attacks are architecture specific ( Abdullah et al. , 2020 ) , they have the potential to bias our results . As a consequence , we formulate a generic optimization attack that captures the intuition of existing works . This helps extend our results to all existing audio domain optimization attacks . To do so , we first outline the steps used by optimization attacks , which generally follow the same approach . First , a perturbation δ is produced by minimizing : ||δ| |22 + l ( x+ δ , t ) ( 1 ) where l is the loss function , x is the original audio sample , and t is the target label . Next , δ is clipped by magnitude factor α ∈ R to control the quality of the adversarial audio : δ = clip ( δ , α , −α ) ( 2 ) Lastly , the δ is added to the original audio x and clipped to create a valid sample xadv : xadv = clip ( x + δ , 1 , −1 ) ( 3 ) The clip step in Equation 2 is used to control the quality of the adversarial audio and is often specific to the target model architecture . For example , attacks that clip spectral gradients ( Qin et al. , 2019 ) can not work against end-to-end ASRs that do not have a spectrum generation step ( Abdullah et al. , 2020 ) . Therefore , in our generic attack , we remove Equation 2 making it model agnostic . Adversarial Audio Generation : We use this generic optimization attack to create adversarial samples for each of the five ASRs . Following prior work ( Abdullah et al. , 2021b ; Liu et al. , 2016 ) , we only perturb audio samples that all of the ASRs transcribed correctly . We attack every label in the dataset since some sample labels could be easier to perturb and some are easier to transfer ( Carlini et al. , 2019 ) . For example , we perturb an audio sample containing the label one to produce each of the remaining labels two to nine . Running the experiments in this exhaustive manner allows us to generalize our findings . We run the attack for 500 iterations . We save the adversarial sample every 50 iterations since the number of attack iterations can impact transferability ( Dong et al. , 2018 ) . We also ensure that every saved adversarial sample has confidence greater than 0.99 because lower confidence adversarial samples are less likely to transfer ( Abdullah et al. , 2021b ) . In total , we create 4050 adversarial audio samples . Transferability : Having created the adversarial samples for each of the five ASRs , we transfer them to the remaining four models . Targeted transferability is successful if both the surrogate and the target ASRs output the same target label . However , adversarial samples exhibit asymmetry ( Wu et al. , 2018 ; Wu & Zhu , 2020 ) , which is when an adversarial sample generated for model A transfers to model B , but not the other way around . To account for this , we average the number of successfully transferred samples between all five models . This final average is the transferability rate . | It is known that targeted transferability is ineffective against typical ASR systems, but it is not fully understand why. In this work the authors show the impact of targeted transferability against a simplified ASR system. Specifically, they perform an ablation study to assess which components of an ASR may be contributing to the non targeted transferability issue. Their results provide insights into ASR case, which may help against other transferable attack types, and also help in other domains. | SP:a6d31e80b60bc886ed7dc8d636b62165e1086e68 |
GNN-LM: Language Modeling based on Global Contexts via GNN | 1 INTRODUCTION . Language modeling ( LM ) is a basic and long-standing task in natural language processing ( Shannon , 2001 ; Bahl et al. , 1983 ; Chen & Goodman , 1999 ; Mikolov et al. , 2012 ; Xie et al. , 2017 ) . It aims at predicting the upcoming token given the sequence of previous context consisting of a sequence of tokens . A common practice to train a language model is to enforce the model to maximize the probability of the upcoming ground-truth token at training time . At test time , the next token to predict could be the one with the highest probability ( via greedy search ) or the one that maximizes a window of tokens through the beam search strategy . This form of training-test procedure can be viewed as a process of memorization , or doing a close-book examination , if we compare the training data to a book and inference to doing an examination : The process of iterating N epochs over the training data is comparable to reviewing the book N times and the model needs to memorize what is the most likely to appear given specific context based on the training data . At test time , the book needs to be closed , i.e. , the model does not have means to refer to the training data at test time , and the model has to invoke related memory to predict the next token during inference . There are two limitations to this close-book examination strategy : ( 1 ) the memorization-based language models are usually hard to memorize the knowledge of hard examples ( e.g. , long-tail cases in the training set ) ; ( 2 ) memory required to memorize the whole training data is usually intensive . The difficulty of resolving these two problems can be substantially alleviated if the model can be provided with related contexts from the training set so that the model can reference them for decisions . This process can be viewed as a strategy different from memorization or close-book examination – copy , or in other words , open-book examination . For example , given a prefix “ J . K. Rowling is best known for writing ” and we want to predict the upcoming token , a language model will more easily generate token “ Harry ” if it can refer to the context “ J . K. Rowling wrote the Harry Potter fantasy series ” . Motivated by the observation that “ to copy is easier than to memorize ” , or “ an open-book exam is easier than to a close-book exam ” , in this work , we introduce a new language modeling scheme 1The code can be found at https : //github.com/ShannonAI/GNN-LM – GNN-LM , which provides an LM model with the ability to reference similar contexts from the entire training corpus as cues for prediction . The similar contexts , defined as the k neighbors of the input in the training corpus , are served as additional references for the model to predict the next token . To integrate retrieved neighbors with the input , we build a directed heterogeneous graph on top of the input and the extracted contexts , where nodes are the tokens and edges represent the connections between them . We define two types of nodes – the original node from the input context and the neighbor node from the extracted contexts , and two types of edges – the inter-context edge and the intra-context edge that respectively associate inter ( i.e. , context within the input ) and intra ( i.e. , context in the retrieved sentences ) contexts . A graph neural network ( GNN ) is employed to aggregate information from both inter-context and intra-context , which is used to generate the target token . We observe that the proposed scheme retrieves the related contexts as references , making it significantly easier for the model to predict upcoming words in the LM task . We further combine GNN-LM with kNN-LM ( Khandelwal et al. , 2019 ) , an orthogonal technique enhancing language models , to improve the overall performance of our model . We carry out experiments on three widely used language modeling benchmarks : WikiText-103 , One Billion Word and Enwik8 . Experimental results show that our proposed framework outperforms the strong baseline on all three benchmarks . Specifically , applying the GNN-LM framework to a strong base LM leads to substantial performance boost ( -1.9 perplexity ) on WikiText-103 , and combining with kNN-LM achieves a new state-of-the-art perplexity of 14.8 – a 3.9 point improvement over the base LM . We perform comprehensive analyses including complexity analysis and the effects of different components to better understand the mechanics of GNN-LM . 2 GNN-LM . 2.1 OVERALL PIPELINE . We present the overall pipeline of our model in Figure 1 . At each time step t , a neural language model ( LM ) f ( · ) first encodes a sequence of context tokens ct = ( w1 , w2 , ... , wt−1 ) to a high-dimensional representation ht = f ( ct ) ∈ Rd , where d is the dimension of hidden states . Then a transformation matrixW ∈ RV×d is used to estimate the probability of the t-th token p ( wt|ct ) = softmax ( Wht ) , where V is the size of the vocabulary . We augment the vanilla neural language model by allowing it to reference samples in the training set that are similar to the current decoded sequence . Concretely , we leverage a novel self-attention augmented Graph Neural Network ( GNN ) on top of the vanilla LM to enable message passing between the context c and retrieved reference tokens from the training set , updating the representation ht generated by the vanilla LM . The updated representation , which aggregates additional information from reference tokens , is then used to estimate pLM ( wt|ct ) . 2.2 GRAPH CONSTRUCTION . The first step of our proposed framework is to build a graph capturing the connections between the context tokens ct = ( w1 , w2 , ... , wt−1 ) and those similar to ct in the training set . To this end , we construct a directed heterogeneous graph , where the nodes are tokens from ct or the tokens from the neighbor contexts retrieved from the training set , and the edges represent different relationships between the nodes to be discussed below . Formally , we define a graph as G = ( V , E , A , R , τ , φ ) , where V is a collection of nodes v and E is a collection of edges e. We define two types of nodes A = { ao , an } , where ao means that the node is within the input ct. an means the node is in N ( ct ) , the set of extracted contexts within the neighborhood of ct. We also define two types of edges R = { rinter , rintra } , where rinter means inter-context connection ( from an nodes to ao nodes ) and rintra means intra-context connection ( between two nodes of same type ) . Each token within the input is a node of type ao , and edges of type rintra are constructed from node wi to wj ( i ≤ j ) , which can be viewed as a graph interpretation of the transformer structure . Both nodes and edges are associated with their respective type mapping functions τ ( v ) : V → A and φ ( e ) : E → R. For an input context ct , we retrieve k nearest neighbors N ( ct ) = { c ( 1 ) t1 , ... , c ( k ) tk } of ct from the training set as follows : we first use ht to query the cached representations of all tokens for training samples , where the cached representations are obtained by a pretrained LM . The distance is measured by the cosine similarity2 , and we retrieve the top K tokens denoted by { w ( i ) j } . The superscript ( i ) denotes the i-th training sample and the subscript j denotes the j-th time step . w ( i ) j thus means that the j-th time step of the i-th training sample is retrieved as one of the nearest neighbors to ht . w ( i ) j is expanded to c ( i ) j by adding both left and right contexts , where c ( i ) j = { w ( i ) j+p } rp=−l , where l and r respectively denote the left and right window size . The corresponding representations { h ( i ) j+p } rp=−l are used as the initialized node embeddings Different from kNN-LM ( Khandelwal et al. , 2019 ) that uses w ( i ) j+1 , which is the token right after the retrieved token w ( i ) j , to directly augment the output probability , we explicitly take advantage of all contextual tokens near w ( i ) ti as additional information in the form of graph nodes . In this way , the model is able to reference similar contexts in the training set and leverage the corresponding ground-truth target tokens via the heterogeneous graph built on both the original input tokens and the context reference tokens . For the neighbor context window size l and r , we set l = r = 1 in all experiments . During experiments , we find that using shallow ( i.e . 3 ) GNN layers and adding rintra edges between adjacent tokens can alleviate overfitting . Since a 3-layer GNN only aggregates information from 3-hop nodes in the graph , using larger l and r have no influence on GNN representations . 2.3 GNN ON THE CONSTRUCTED GRAPH . We now use graph neural networks ( GNNs ) to aggregate and percolate the token information based on the graph constructed in Section 2.2 . In this work , to accommodate the modeling of rintra from node wi to wj ( i ≤ j ) within ct , where Transformer with self-attention is usually adopted , we extend the self-attention mechanism to rinter , and construct a self-attention augmented GNN . Specifically , the l-th layer representation of node n is computed by ( here we use the superscript [ l ] to represent the l-th layer ) : h [ l ] n = Aggregate ∀s∈N ( n ) ( Attention ( s , e , n ) · Feature ( s , e , n ) ) + h [ l−1 ] n . ( 1 ) Attention ( s , e , n ) estimates the importance of the source node s on target node n with relationship e , Feature ( s , e , n ) is the information feature that s should pass to n , and Aggregate ( · ) aggregates the neighborhood message with the attention weights . To draw on the information in the heterogeneous graph , we use different sets of parameters for different node types τ ( · ) and different edge types φ ( · ) akin to Hu et al . ( 2020 ) . 2In practice , we use FAISS ( Johnson et al. , 2019 ) for fast approximate kNN search . Attention Similar to the multi-head attention mechanism of Transformer ( Vaswani et al. , 2017 ) , the Attention ( · , · , · ) operator in our model consists of h heads , which compute attention weights independently , followed by concatenation to get the final output . For simplicity , we only describe the single-head situation below . For each edge ( s , e , n ) , the representation of target node n is mapped to a query vector Q ( n ) , and the representation of source node s is mapped to a key vector K ( s ) . The scaled inner-production is then used to compute the attention weight between Q ( n ) and K ( s ) , which is further normalized over all edges that have the same edge type : K ( s ) =W kτ ( s ) h [ l−1 ] s , Q ( n ) =W q τ ( n ) h [ l−1 ] n , Attention ( s , e , n ) = 1 Z exp ( K ( s ) W ATTφ ( e ) Q ( n ) > · µ〈τ ( s ) , φ ( e ) , τ ( n ) 〉√ d ) , Z = ∑ s′∈N ( n ) , e′∈φ ( e ) Attention ( s′ , e′ , n ) , ( 2 ) where d is the hidden dimensionality , and W qτ ( s ) ∈ R d×d , W kτ ( n ) ∈ R d×d , W ATTφ ( e ) ∈ R d×d , µ ∈ R|A|×|R|×|A| are learnable model parameters . Feature Parallel to the calculation of attention weights , we propagate information from source node s to target node n. The single-head feature is defined by : Feature ( s , e , n ) =W vτ ( s ) h [ l−1 ] s W FEA φ ( e ) , ( 3 ) whereW vτ ( s ) ∈ R d×d andW FEAφ ( e ) ∈ R d×d are learnable model parameters . Aggregate Aggregate ( · ) weight-sums the feature Message ( s , e , n ) within the vicinity using Attention ( s , e , n ) , and the result is then linearly projected into a d-dimensional representation : Aggregate ( · ) =W oτ ( n ) ( ⊕ ∀s∈N ( n ) ( Attention ( s , e , n ) · Feature ( s , e , n ) ) ) ( 4 ) where ⊕ is element-wise addition and W oτ ( n ) ∈ R d×d is model parameter . The representation of token wt−1 from the last layer is used to compute the language model probability pLM ( wt|ct ) . 2.4 kNN BASED PROBABILITY FOR NEXT TOKEN We further incorporate the proposed model with kNN ( Khandelwal et al. , 2019 ; 2020 ; Meng et al. , 2021 ) , a related but orthogonal technique , to improve the performance of our model . It extends a vanilla LM by linearly interpolating it with a k-nearest neighbors ( kNN ) model . Concretely , for each input context ct = ( w1 , w2 , ... , wt−1 ) , we retrieve the k nearest neighbors N ( ct ) = { c ( 1 ) t1 , ... , c ( k ) tk } , and compute the kNN based probability for the next token by : p ( wt|ct ) = λpkNN ( wt|ct ) + ( 1− λ ) pLM ( wt|ct ) , pkNN ( wt|ct ) = 1 Z k∑ i=1 1 wt=w ( i ) ti exp ( cos ( f ( ct ) , f ( c ( i ) ti ) ) /T ) , ( 5 ) with Z being the normalization factor , f ( · ) is the neural language model encoding contexts to high dimensional representations , cos ( · , · ) is cosine similarity , and λ and T are hyperparameters.3 | The paper presents a GNN based language model where neighbor contexts are retrieved, encoded via a graph neural network, and used to enhance generation. Evaluation on three benchmarks indicates that the proposed approach can outperform a bunch of baseline models. Contributions: 1. a new retrieval-augmented language model implemented via GNN techniques. 2. improvements over state-of-the-art models on three benchmarks. | SP:4b9476d9247e7baafaee1b113ea8760e8b509fa7 |
GNN-LM: Language Modeling based on Global Contexts via GNN | 1 INTRODUCTION . Language modeling ( LM ) is a basic and long-standing task in natural language processing ( Shannon , 2001 ; Bahl et al. , 1983 ; Chen & Goodman , 1999 ; Mikolov et al. , 2012 ; Xie et al. , 2017 ) . It aims at predicting the upcoming token given the sequence of previous context consisting of a sequence of tokens . A common practice to train a language model is to enforce the model to maximize the probability of the upcoming ground-truth token at training time . At test time , the next token to predict could be the one with the highest probability ( via greedy search ) or the one that maximizes a window of tokens through the beam search strategy . This form of training-test procedure can be viewed as a process of memorization , or doing a close-book examination , if we compare the training data to a book and inference to doing an examination : The process of iterating N epochs over the training data is comparable to reviewing the book N times and the model needs to memorize what is the most likely to appear given specific context based on the training data . At test time , the book needs to be closed , i.e. , the model does not have means to refer to the training data at test time , and the model has to invoke related memory to predict the next token during inference . There are two limitations to this close-book examination strategy : ( 1 ) the memorization-based language models are usually hard to memorize the knowledge of hard examples ( e.g. , long-tail cases in the training set ) ; ( 2 ) memory required to memorize the whole training data is usually intensive . The difficulty of resolving these two problems can be substantially alleviated if the model can be provided with related contexts from the training set so that the model can reference them for decisions . This process can be viewed as a strategy different from memorization or close-book examination – copy , or in other words , open-book examination . For example , given a prefix “ J . K. Rowling is best known for writing ” and we want to predict the upcoming token , a language model will more easily generate token “ Harry ” if it can refer to the context “ J . K. Rowling wrote the Harry Potter fantasy series ” . Motivated by the observation that “ to copy is easier than to memorize ” , or “ an open-book exam is easier than to a close-book exam ” , in this work , we introduce a new language modeling scheme 1The code can be found at https : //github.com/ShannonAI/GNN-LM – GNN-LM , which provides an LM model with the ability to reference similar contexts from the entire training corpus as cues for prediction . The similar contexts , defined as the k neighbors of the input in the training corpus , are served as additional references for the model to predict the next token . To integrate retrieved neighbors with the input , we build a directed heterogeneous graph on top of the input and the extracted contexts , where nodes are the tokens and edges represent the connections between them . We define two types of nodes – the original node from the input context and the neighbor node from the extracted contexts , and two types of edges – the inter-context edge and the intra-context edge that respectively associate inter ( i.e. , context within the input ) and intra ( i.e. , context in the retrieved sentences ) contexts . A graph neural network ( GNN ) is employed to aggregate information from both inter-context and intra-context , which is used to generate the target token . We observe that the proposed scheme retrieves the related contexts as references , making it significantly easier for the model to predict upcoming words in the LM task . We further combine GNN-LM with kNN-LM ( Khandelwal et al. , 2019 ) , an orthogonal technique enhancing language models , to improve the overall performance of our model . We carry out experiments on three widely used language modeling benchmarks : WikiText-103 , One Billion Word and Enwik8 . Experimental results show that our proposed framework outperforms the strong baseline on all three benchmarks . Specifically , applying the GNN-LM framework to a strong base LM leads to substantial performance boost ( -1.9 perplexity ) on WikiText-103 , and combining with kNN-LM achieves a new state-of-the-art perplexity of 14.8 – a 3.9 point improvement over the base LM . We perform comprehensive analyses including complexity analysis and the effects of different components to better understand the mechanics of GNN-LM . 2 GNN-LM . 2.1 OVERALL PIPELINE . We present the overall pipeline of our model in Figure 1 . At each time step t , a neural language model ( LM ) f ( · ) first encodes a sequence of context tokens ct = ( w1 , w2 , ... , wt−1 ) to a high-dimensional representation ht = f ( ct ) ∈ Rd , where d is the dimension of hidden states . Then a transformation matrixW ∈ RV×d is used to estimate the probability of the t-th token p ( wt|ct ) = softmax ( Wht ) , where V is the size of the vocabulary . We augment the vanilla neural language model by allowing it to reference samples in the training set that are similar to the current decoded sequence . Concretely , we leverage a novel self-attention augmented Graph Neural Network ( GNN ) on top of the vanilla LM to enable message passing between the context c and retrieved reference tokens from the training set , updating the representation ht generated by the vanilla LM . The updated representation , which aggregates additional information from reference tokens , is then used to estimate pLM ( wt|ct ) . 2.2 GRAPH CONSTRUCTION . The first step of our proposed framework is to build a graph capturing the connections between the context tokens ct = ( w1 , w2 , ... , wt−1 ) and those similar to ct in the training set . To this end , we construct a directed heterogeneous graph , where the nodes are tokens from ct or the tokens from the neighbor contexts retrieved from the training set , and the edges represent different relationships between the nodes to be discussed below . Formally , we define a graph as G = ( V , E , A , R , τ , φ ) , where V is a collection of nodes v and E is a collection of edges e. We define two types of nodes A = { ao , an } , where ao means that the node is within the input ct. an means the node is in N ( ct ) , the set of extracted contexts within the neighborhood of ct. We also define two types of edges R = { rinter , rintra } , where rinter means inter-context connection ( from an nodes to ao nodes ) and rintra means intra-context connection ( between two nodes of same type ) . Each token within the input is a node of type ao , and edges of type rintra are constructed from node wi to wj ( i ≤ j ) , which can be viewed as a graph interpretation of the transformer structure . Both nodes and edges are associated with their respective type mapping functions τ ( v ) : V → A and φ ( e ) : E → R. For an input context ct , we retrieve k nearest neighbors N ( ct ) = { c ( 1 ) t1 , ... , c ( k ) tk } of ct from the training set as follows : we first use ht to query the cached representations of all tokens for training samples , where the cached representations are obtained by a pretrained LM . The distance is measured by the cosine similarity2 , and we retrieve the top K tokens denoted by { w ( i ) j } . The superscript ( i ) denotes the i-th training sample and the subscript j denotes the j-th time step . w ( i ) j thus means that the j-th time step of the i-th training sample is retrieved as one of the nearest neighbors to ht . w ( i ) j is expanded to c ( i ) j by adding both left and right contexts , where c ( i ) j = { w ( i ) j+p } rp=−l , where l and r respectively denote the left and right window size . The corresponding representations { h ( i ) j+p } rp=−l are used as the initialized node embeddings Different from kNN-LM ( Khandelwal et al. , 2019 ) that uses w ( i ) j+1 , which is the token right after the retrieved token w ( i ) j , to directly augment the output probability , we explicitly take advantage of all contextual tokens near w ( i ) ti as additional information in the form of graph nodes . In this way , the model is able to reference similar contexts in the training set and leverage the corresponding ground-truth target tokens via the heterogeneous graph built on both the original input tokens and the context reference tokens . For the neighbor context window size l and r , we set l = r = 1 in all experiments . During experiments , we find that using shallow ( i.e . 3 ) GNN layers and adding rintra edges between adjacent tokens can alleviate overfitting . Since a 3-layer GNN only aggregates information from 3-hop nodes in the graph , using larger l and r have no influence on GNN representations . 2.3 GNN ON THE CONSTRUCTED GRAPH . We now use graph neural networks ( GNNs ) to aggregate and percolate the token information based on the graph constructed in Section 2.2 . In this work , to accommodate the modeling of rintra from node wi to wj ( i ≤ j ) within ct , where Transformer with self-attention is usually adopted , we extend the self-attention mechanism to rinter , and construct a self-attention augmented GNN . Specifically , the l-th layer representation of node n is computed by ( here we use the superscript [ l ] to represent the l-th layer ) : h [ l ] n = Aggregate ∀s∈N ( n ) ( Attention ( s , e , n ) · Feature ( s , e , n ) ) + h [ l−1 ] n . ( 1 ) Attention ( s , e , n ) estimates the importance of the source node s on target node n with relationship e , Feature ( s , e , n ) is the information feature that s should pass to n , and Aggregate ( · ) aggregates the neighborhood message with the attention weights . To draw on the information in the heterogeneous graph , we use different sets of parameters for different node types τ ( · ) and different edge types φ ( · ) akin to Hu et al . ( 2020 ) . 2In practice , we use FAISS ( Johnson et al. , 2019 ) for fast approximate kNN search . Attention Similar to the multi-head attention mechanism of Transformer ( Vaswani et al. , 2017 ) , the Attention ( · , · , · ) operator in our model consists of h heads , which compute attention weights independently , followed by concatenation to get the final output . For simplicity , we only describe the single-head situation below . For each edge ( s , e , n ) , the representation of target node n is mapped to a query vector Q ( n ) , and the representation of source node s is mapped to a key vector K ( s ) . The scaled inner-production is then used to compute the attention weight between Q ( n ) and K ( s ) , which is further normalized over all edges that have the same edge type : K ( s ) =W kτ ( s ) h [ l−1 ] s , Q ( n ) =W q τ ( n ) h [ l−1 ] n , Attention ( s , e , n ) = 1 Z exp ( K ( s ) W ATTφ ( e ) Q ( n ) > · µ〈τ ( s ) , φ ( e ) , τ ( n ) 〉√ d ) , Z = ∑ s′∈N ( n ) , e′∈φ ( e ) Attention ( s′ , e′ , n ) , ( 2 ) where d is the hidden dimensionality , and W qτ ( s ) ∈ R d×d , W kτ ( n ) ∈ R d×d , W ATTφ ( e ) ∈ R d×d , µ ∈ R|A|×|R|×|A| are learnable model parameters . Feature Parallel to the calculation of attention weights , we propagate information from source node s to target node n. The single-head feature is defined by : Feature ( s , e , n ) =W vτ ( s ) h [ l−1 ] s W FEA φ ( e ) , ( 3 ) whereW vτ ( s ) ∈ R d×d andW FEAφ ( e ) ∈ R d×d are learnable model parameters . Aggregate Aggregate ( · ) weight-sums the feature Message ( s , e , n ) within the vicinity using Attention ( s , e , n ) , and the result is then linearly projected into a d-dimensional representation : Aggregate ( · ) =W oτ ( n ) ( ⊕ ∀s∈N ( n ) ( Attention ( s , e , n ) · Feature ( s , e , n ) ) ) ( 4 ) where ⊕ is element-wise addition and W oτ ( n ) ∈ R d×d is model parameter . The representation of token wt−1 from the last layer is used to compute the language model probability pLM ( wt|ct ) . 2.4 kNN BASED PROBABILITY FOR NEXT TOKEN We further incorporate the proposed model with kNN ( Khandelwal et al. , 2019 ; 2020 ; Meng et al. , 2021 ) , a related but orthogonal technique , to improve the performance of our model . It extends a vanilla LM by linearly interpolating it with a k-nearest neighbors ( kNN ) model . Concretely , for each input context ct = ( w1 , w2 , ... , wt−1 ) , we retrieve the k nearest neighbors N ( ct ) = { c ( 1 ) t1 , ... , c ( k ) tk } , and compute the kNN based probability for the next token by : p ( wt|ct ) = λpkNN ( wt|ct ) + ( 1− λ ) pLM ( wt|ct ) , pkNN ( wt|ct ) = 1 Z k∑ i=1 1 wt=w ( i ) ti exp ( cos ( f ( ct ) , f ( c ( i ) ti ) ) /T ) , ( 5 ) with Z being the normalization factor , f ( · ) is the neural language model encoding contexts to high dimensional representations , cos ( · , · ) is cosine similarity , and λ and T are hyperparameters.3 | This paper proposes a method to model original texts and similar texts in a graph structure for language modeling with graph neural networks. In the graph, the nodes are texts or similar contexts and the edges are connections between the nodes. The new model achieves the new state-of-the-art on WikiText-103 and shows substantial improvements over other language modeling datasets such as One Billion Word and Enwiki8 datasets . | SP:4b9476d9247e7baafaee1b113ea8760e8b509fa7 |
GNN-LM: Language Modeling based on Global Contexts via GNN | 1 INTRODUCTION . Language modeling ( LM ) is a basic and long-standing task in natural language processing ( Shannon , 2001 ; Bahl et al. , 1983 ; Chen & Goodman , 1999 ; Mikolov et al. , 2012 ; Xie et al. , 2017 ) . It aims at predicting the upcoming token given the sequence of previous context consisting of a sequence of tokens . A common practice to train a language model is to enforce the model to maximize the probability of the upcoming ground-truth token at training time . At test time , the next token to predict could be the one with the highest probability ( via greedy search ) or the one that maximizes a window of tokens through the beam search strategy . This form of training-test procedure can be viewed as a process of memorization , or doing a close-book examination , if we compare the training data to a book and inference to doing an examination : The process of iterating N epochs over the training data is comparable to reviewing the book N times and the model needs to memorize what is the most likely to appear given specific context based on the training data . At test time , the book needs to be closed , i.e. , the model does not have means to refer to the training data at test time , and the model has to invoke related memory to predict the next token during inference . There are two limitations to this close-book examination strategy : ( 1 ) the memorization-based language models are usually hard to memorize the knowledge of hard examples ( e.g. , long-tail cases in the training set ) ; ( 2 ) memory required to memorize the whole training data is usually intensive . The difficulty of resolving these two problems can be substantially alleviated if the model can be provided with related contexts from the training set so that the model can reference them for decisions . This process can be viewed as a strategy different from memorization or close-book examination – copy , or in other words , open-book examination . For example , given a prefix “ J . K. Rowling is best known for writing ” and we want to predict the upcoming token , a language model will more easily generate token “ Harry ” if it can refer to the context “ J . K. Rowling wrote the Harry Potter fantasy series ” . Motivated by the observation that “ to copy is easier than to memorize ” , or “ an open-book exam is easier than to a close-book exam ” , in this work , we introduce a new language modeling scheme 1The code can be found at https : //github.com/ShannonAI/GNN-LM – GNN-LM , which provides an LM model with the ability to reference similar contexts from the entire training corpus as cues for prediction . The similar contexts , defined as the k neighbors of the input in the training corpus , are served as additional references for the model to predict the next token . To integrate retrieved neighbors with the input , we build a directed heterogeneous graph on top of the input and the extracted contexts , where nodes are the tokens and edges represent the connections between them . We define two types of nodes – the original node from the input context and the neighbor node from the extracted contexts , and two types of edges – the inter-context edge and the intra-context edge that respectively associate inter ( i.e. , context within the input ) and intra ( i.e. , context in the retrieved sentences ) contexts . A graph neural network ( GNN ) is employed to aggregate information from both inter-context and intra-context , which is used to generate the target token . We observe that the proposed scheme retrieves the related contexts as references , making it significantly easier for the model to predict upcoming words in the LM task . We further combine GNN-LM with kNN-LM ( Khandelwal et al. , 2019 ) , an orthogonal technique enhancing language models , to improve the overall performance of our model . We carry out experiments on three widely used language modeling benchmarks : WikiText-103 , One Billion Word and Enwik8 . Experimental results show that our proposed framework outperforms the strong baseline on all three benchmarks . Specifically , applying the GNN-LM framework to a strong base LM leads to substantial performance boost ( -1.9 perplexity ) on WikiText-103 , and combining with kNN-LM achieves a new state-of-the-art perplexity of 14.8 – a 3.9 point improvement over the base LM . We perform comprehensive analyses including complexity analysis and the effects of different components to better understand the mechanics of GNN-LM . 2 GNN-LM . 2.1 OVERALL PIPELINE . We present the overall pipeline of our model in Figure 1 . At each time step t , a neural language model ( LM ) f ( · ) first encodes a sequence of context tokens ct = ( w1 , w2 , ... , wt−1 ) to a high-dimensional representation ht = f ( ct ) ∈ Rd , where d is the dimension of hidden states . Then a transformation matrixW ∈ RV×d is used to estimate the probability of the t-th token p ( wt|ct ) = softmax ( Wht ) , where V is the size of the vocabulary . We augment the vanilla neural language model by allowing it to reference samples in the training set that are similar to the current decoded sequence . Concretely , we leverage a novel self-attention augmented Graph Neural Network ( GNN ) on top of the vanilla LM to enable message passing between the context c and retrieved reference tokens from the training set , updating the representation ht generated by the vanilla LM . The updated representation , which aggregates additional information from reference tokens , is then used to estimate pLM ( wt|ct ) . 2.2 GRAPH CONSTRUCTION . The first step of our proposed framework is to build a graph capturing the connections between the context tokens ct = ( w1 , w2 , ... , wt−1 ) and those similar to ct in the training set . To this end , we construct a directed heterogeneous graph , where the nodes are tokens from ct or the tokens from the neighbor contexts retrieved from the training set , and the edges represent different relationships between the nodes to be discussed below . Formally , we define a graph as G = ( V , E , A , R , τ , φ ) , where V is a collection of nodes v and E is a collection of edges e. We define two types of nodes A = { ao , an } , where ao means that the node is within the input ct. an means the node is in N ( ct ) , the set of extracted contexts within the neighborhood of ct. We also define two types of edges R = { rinter , rintra } , where rinter means inter-context connection ( from an nodes to ao nodes ) and rintra means intra-context connection ( between two nodes of same type ) . Each token within the input is a node of type ao , and edges of type rintra are constructed from node wi to wj ( i ≤ j ) , which can be viewed as a graph interpretation of the transformer structure . Both nodes and edges are associated with their respective type mapping functions τ ( v ) : V → A and φ ( e ) : E → R. For an input context ct , we retrieve k nearest neighbors N ( ct ) = { c ( 1 ) t1 , ... , c ( k ) tk } of ct from the training set as follows : we first use ht to query the cached representations of all tokens for training samples , where the cached representations are obtained by a pretrained LM . The distance is measured by the cosine similarity2 , and we retrieve the top K tokens denoted by { w ( i ) j } . The superscript ( i ) denotes the i-th training sample and the subscript j denotes the j-th time step . w ( i ) j thus means that the j-th time step of the i-th training sample is retrieved as one of the nearest neighbors to ht . w ( i ) j is expanded to c ( i ) j by adding both left and right contexts , where c ( i ) j = { w ( i ) j+p } rp=−l , where l and r respectively denote the left and right window size . The corresponding representations { h ( i ) j+p } rp=−l are used as the initialized node embeddings Different from kNN-LM ( Khandelwal et al. , 2019 ) that uses w ( i ) j+1 , which is the token right after the retrieved token w ( i ) j , to directly augment the output probability , we explicitly take advantage of all contextual tokens near w ( i ) ti as additional information in the form of graph nodes . In this way , the model is able to reference similar contexts in the training set and leverage the corresponding ground-truth target tokens via the heterogeneous graph built on both the original input tokens and the context reference tokens . For the neighbor context window size l and r , we set l = r = 1 in all experiments . During experiments , we find that using shallow ( i.e . 3 ) GNN layers and adding rintra edges between adjacent tokens can alleviate overfitting . Since a 3-layer GNN only aggregates information from 3-hop nodes in the graph , using larger l and r have no influence on GNN representations . 2.3 GNN ON THE CONSTRUCTED GRAPH . We now use graph neural networks ( GNNs ) to aggregate and percolate the token information based on the graph constructed in Section 2.2 . In this work , to accommodate the modeling of rintra from node wi to wj ( i ≤ j ) within ct , where Transformer with self-attention is usually adopted , we extend the self-attention mechanism to rinter , and construct a self-attention augmented GNN . Specifically , the l-th layer representation of node n is computed by ( here we use the superscript [ l ] to represent the l-th layer ) : h [ l ] n = Aggregate ∀s∈N ( n ) ( Attention ( s , e , n ) · Feature ( s , e , n ) ) + h [ l−1 ] n . ( 1 ) Attention ( s , e , n ) estimates the importance of the source node s on target node n with relationship e , Feature ( s , e , n ) is the information feature that s should pass to n , and Aggregate ( · ) aggregates the neighborhood message with the attention weights . To draw on the information in the heterogeneous graph , we use different sets of parameters for different node types τ ( · ) and different edge types φ ( · ) akin to Hu et al . ( 2020 ) . 2In practice , we use FAISS ( Johnson et al. , 2019 ) for fast approximate kNN search . Attention Similar to the multi-head attention mechanism of Transformer ( Vaswani et al. , 2017 ) , the Attention ( · , · , · ) operator in our model consists of h heads , which compute attention weights independently , followed by concatenation to get the final output . For simplicity , we only describe the single-head situation below . For each edge ( s , e , n ) , the representation of target node n is mapped to a query vector Q ( n ) , and the representation of source node s is mapped to a key vector K ( s ) . The scaled inner-production is then used to compute the attention weight between Q ( n ) and K ( s ) , which is further normalized over all edges that have the same edge type : K ( s ) =W kτ ( s ) h [ l−1 ] s , Q ( n ) =W q τ ( n ) h [ l−1 ] n , Attention ( s , e , n ) = 1 Z exp ( K ( s ) W ATTφ ( e ) Q ( n ) > · µ〈τ ( s ) , φ ( e ) , τ ( n ) 〉√ d ) , Z = ∑ s′∈N ( n ) , e′∈φ ( e ) Attention ( s′ , e′ , n ) , ( 2 ) where d is the hidden dimensionality , and W qτ ( s ) ∈ R d×d , W kτ ( n ) ∈ R d×d , W ATTφ ( e ) ∈ R d×d , µ ∈ R|A|×|R|×|A| are learnable model parameters . Feature Parallel to the calculation of attention weights , we propagate information from source node s to target node n. The single-head feature is defined by : Feature ( s , e , n ) =W vτ ( s ) h [ l−1 ] s W FEA φ ( e ) , ( 3 ) whereW vτ ( s ) ∈ R d×d andW FEAφ ( e ) ∈ R d×d are learnable model parameters . Aggregate Aggregate ( · ) weight-sums the feature Message ( s , e , n ) within the vicinity using Attention ( s , e , n ) , and the result is then linearly projected into a d-dimensional representation : Aggregate ( · ) =W oτ ( n ) ( ⊕ ∀s∈N ( n ) ( Attention ( s , e , n ) · Feature ( s , e , n ) ) ) ( 4 ) where ⊕ is element-wise addition and W oτ ( n ) ∈ R d×d is model parameter . The representation of token wt−1 from the last layer is used to compute the language model probability pLM ( wt|ct ) . 2.4 kNN BASED PROBABILITY FOR NEXT TOKEN We further incorporate the proposed model with kNN ( Khandelwal et al. , 2019 ; 2020 ; Meng et al. , 2021 ) , a related but orthogonal technique , to improve the performance of our model . It extends a vanilla LM by linearly interpolating it with a k-nearest neighbors ( kNN ) model . Concretely , for each input context ct = ( w1 , w2 , ... , wt−1 ) , we retrieve the k nearest neighbors N ( ct ) = { c ( 1 ) t1 , ... , c ( k ) tk } , and compute the kNN based probability for the next token by : p ( wt|ct ) = λpkNN ( wt|ct ) + ( 1− λ ) pLM ( wt|ct ) , pkNN ( wt|ct ) = 1 Z k∑ i=1 1 wt=w ( i ) ti exp ( cos ( f ( ct ) , f ( c ( i ) ti ) ) /T ) , ( 5 ) with Z being the normalization factor , f ( · ) is the neural language model encoding contexts to high dimensional representations , cos ( · , · ) is cosine similarity , and λ and T are hyperparameters.3 | This work build a novel GNN-LM to do language modeling by using global context information. The proposed model is novel and quite different from previous LM structures. This work in my view draws the connection between traditional n-gram language model and neural language model. The overall performance is quite impressive in all standard LM datasets. Extensive ablation study is conducted to understand the model. | SP:4b9476d9247e7baafaee1b113ea8760e8b509fa7 |
Decoupled Kernel Neural Processes: Neural Network-Parameterized Stochastic Processes using Explicit Data-driven Kernel | Neural Processes ( NPs ) are a class of stochastic processes parametrized by neural networks . Unlike traditional stochastic processes ( e.g. , Gaussian processes ) , which require specifying explicit kernel functions , NPs implicitly learn kernel functions appropriate for a given task through observed data . While this data-driven learning of stochastic processes has been shown to model various types of data , the current NPs ’ implicit treatment of the mean and the covariance of the output variables limits its full potential when the underlying distribution of the given data is highly complex . To address this , we introduce a new class of neural stochastic processes , Decoupled Kernel Neural Processes ( DKNPs ) , which explicitly learn a separate mean and kernel function to directly model the covariance between output variables in a data-driven manner . By estimating kernel functions with cross-attentive neural networks , DKNPs demonstrate improved uncertainty estimation in terms of conditional likelihood and diversity in generated samples in 1-D and 2-D regression tasks , compared to other concurrent NP variants . Also , maintaining explicit kernel functions , a key component of stochastic processes , allows the model to reveal a deeper understanding of underlying distributions . 1 INTRODUCTION . Neural processes ( NPs ) ( Garnelo et al. , 2018a ; b ) are a class of stochastic processes parametrized by neural networks . By embracing statistical properties in stochastic processes , NPs can effectively estimate the uncertainty of underlying distributions of functions with a set of realizations and their data points . Different from traditional stochastic processes ( e.g. , Gaussian processes ( GP ) ( Rasmussen & Williams , 2006 ) ) , NPs learn data-driven stochastic processes without a need to specify or keep an explicit form of kernel functions . As a result of their simplicity and flexibility , there have been numerous efforts to further develop improved variants of NPs ( Kim et al. , 2019 ; Lee et al. , 2020 ; Gordon et al. , 2020 ) and apply them to various downstream tasks ( Singh et al. , 2019 ; Requeima et al. , 2019 ) . Though significant progress has been made in NPs , the current architectures of NPs either fails to capture output dependencies as in Conditional NPs ( Garnelo et al. , 2018a ; Gordon et al. , 2020 ) , or indirectly capture the full stochasticity present in the traditional stochastic processes . For instance , different from GPs , conventional NPs reserve stochasticity in a global latent variable and output variables separately . The output variables estimate point-wise uncertainty , which corresponds to the diagonal elements of a kernel matrix . Similarly , the global latent variable takes charge of the functional uncertainty and diversity , represented by the full covariance matrix in GPs . Due to this inductive bias of conventional NPs , the role of estimating functional stochasticity is mainly assigned to a fixed-length vector ( i.e . the global latent variable ) , and consequently , capturing the underlying distributions can be restricted in complex scenarios ( e.g. , variable relationships are periodic or abruptly changing at a certain point ) . Although several approaches attempt to alleviate the problem by introducing attention ( Kim et al. , 2019 ) and bootstrapping ( Lee et al. , 2020 ) on top of conventional NPs , the problem still exists as the architectural limitation ( i.e . implicit modeling of the mean and covariance ) has not been addressed directly . Besides this , as NPs implicitly learn the kernel functions inside the model , the interpretability of kernels such as in GPs ( Lloyd et al. , 2014 ) is diminished . To address this concern , we propose Decoupled Kernel Neural Processes ( DKNPs ) , a new class of neural stochastic processes that explicitly learn a separate mean and kernel function to directly model the covariance between output variables in a data-driven manner . Our experiments in 1-D and 2-D regression tasks reveal that the DKNP outperforms concurrent NP variants in terms of predictive likelihood , better global coherence of generated samples , and improved interpretability via explicitly learned kernels . 2 BACKGROUND . 2.1 NEURAL PROCESS . Given a stochastic process sample consisting of n points , let us denote the input and output as X = { xi } ni=1 and Y = { yi } ni=1 , respectively , where xi ∈ Rdx and yi ∈ Rdy . For a set of target input XT = { xi } i∈T ⊂ X , NPs model the conditional distribution of target outputs YT conditioned on the context set ( XC , YC ) = { ( xi , yi ) } i∈C using a factorized Gaussian distribution : log p ( YT |XT , XC , YC ) = ∑ i∈T log p ( yi|xi , XC , YC ) . ( 1 ) For obtaining the predictive distribution log p ( yi|xi , XC , YC ) , NPs use an encoder-decoder architecture that ensures the permutation invariance of the predictions of the target points given the context set ( XC , YC ) . Following Kim et al . ( 2019 ) and Lee et al . ( 2020 ) , we consider the NP encoder consisting of two separate paths , namely the deterministic path and the latent path . For the deterministic path , fθ represents each context points in { ( xi , yi ) } i∈C as ri ∈ Rdr , i.e. , ri = fθ ( xi , yi ) . Then , we aggregate the ri ’ s by averaging them across all context points , rC = 1nc ∑ i∈C ri where nc = |C| . This vector rC ∈ Rdr is the summarized representation of context points , and it is permutation invariant over the order of ( xi , yi ) ∈ ( XC , YC ) . The latent path of the NP encoder operates in a similar fashion to the deterministic path , i.e. , eC = 1 nc ∑ i∈C ei where ei = gϕ ( [ xi ; yi ] ) . Unlike the deterministic path , however , the la- tent path uses stochastic layers for obtaining a distribution of the latent variable z ∈ Rdz ; q ( z|eC ) = N ( z ; µz , σ2z ) where µz , σz are the output of the additional fully-connected layer applied to eC . Finally , by concatenating these aggregated vectors rC , z with the target inputs xi ∈ XT , the decoder hψ produces the predictive distribution p ( yt|xt , rC , z ) = N ( y ; µy , σ2y ) where ( µy , σy ) = hψ ( xt , rC , z ) . Note that the σy is used for capturing the point-wise uncertainty . During the training phase , the parameters are learned by maximizing the evidence lower bound of log p ( YT |XT , XC , YC ) via the reparametrization trick ( Kingma & Welling , 2014 ; Rezende et al. , 2014 ) as follows : log p ( YT |XT , XC , YC ) ≥ Eq ( z|XT , YT ) [ log p ( YT |XT , z ) ] −KL ( q ( z|eT ) ∥q ( z|eC ) ) ( 2 ) where q ( z|eT ) = q ( et|XT , YT ) is a distribution of latent variable by encoding the set of target points ( XT , YT ) = { ( xi , yi ) } i∈T . This objective function consists of two parts : 1 ) the reconstruction loss for the target points and 2 ) the KL divergence term , minimizing the divergence between two distributions q ( z|XT , YT ) and q ( z|XC , YC ) . Note that , in practice , we assume that XC ⊂ XT during the training phase . The KL divergence term encourages two distributions inferred by the context sets and target sets to be similar , which is reasonable because two sets are generated from the same function . Therefore , during the inference phase , the distribution of q ( z|XC , YC ) captures the functional stochasticity which is demonstrated with the coherent sample generation . It can be thought that z learns to capture the correlation of output variables of the stochastic processes . 2.2 ATTENTIVE NEURAL PROCESSES . Multihead Attention Given n key-value pairs of matrices K ∈ Rn×dmodel and V ∈ Rn×dmodel , and m queries Q ∈ Rm×dmodel , the scaled dot product attention is formulated as : Attention ( Q , K , V ) = Softmax ( QK⊤√ dmodel ) V ∈ Rm×dmodel , ( 3 ) where K , V , and Q are projected by learnable linear maps WKs , W V s , and W Q t from the source S and target T . The attention mechanism can be calculated from multiple subspaces , namely , multihead attention ( MHA ) ( Vaswani et al. , 2017 ) . Denoting a single attention head as Headi = Attention ( Qi , Ki , Vi ) , the aggregate attention from multiple subspaces can be expressed as : MHA ( Q , K , V ) = Concat ( Head1 , ... , HeadH ) WO ∈ Rm×dmodel , ( 4 ) where WO is the learnable linear map for aggretating the subspaces . Attentive NPs Attentive NPs ( ANPs ) leverage attention to resolve the underfitting issue in NPs . Unlike NPs that produce a single variable rC from the deterministic path , ANPs utilize a queryspecific variable r∗i by applying the attention score ai for each ri during the aggregation of the deterministic path , formulated as r∗i = ∑ i∈C ai · ri . The attention-based aggregation of ANPs resembles how the GPs utilize the correlation to estimate the predictive distribution of the context and the target points . 3 DECOUPLED KERNEL NEURAL PROCESSES . Decoupled Kernel Neural Processes use attention to explicitly learn a separate mean and kernel function so as to directly model covariances between output variables with related input variables in a data-driven fashion , which is contrary to conventional NPs that implicitly model the mean and kernel function through the latent variable z . As shown in Figure 2 , DKNPs estimate the predictive distribution as multivariate Gaussian N ( y ; µy , Σy ) by using two attention-based deterministic paths using Multihead Cross-Attention ( MCA ) to model the mean vector ( upper path ) and the full covariance matrix ( lower path ) . Here , attention modules are extensively utilized as Le et al . ( 2018 ) ; Kim et al . ( 2019 ) have demonstrated attention was helpful in achieving low predictive uncertainty near the context points . With the predictive distribution N ( y ; µy , Σy ) , DKNPs are trained and evaluated based on the function likelihood . The core design of DKNPs is motivated by the predictive posterior distribution of GPs , where XT , XC , YC are used for deriving the posterior mean,1 but only XT , XC for deriving the posterior covariance as follows : GP : p ( YT |XT , XC , YC ) = N ( YT ; Σ ⊤ XC , XT Σ −1 XC , XC YC , ΣXT , XT − Σ ⊤ XC , XT Σ −1 XC , XC ΣXC , XT ) , ( 5 ) DKNP : p ( YT |XT , XC , YC ) = N ( YT ; MLPψ ◦ MCA ( MLPθ ( XC , YC ) , MLPϕ ( XT , XC ) ) , MLPω ◦ MCA ( MLPϕ ( XT , XC ) ) ) , ( 6 ) where , in contrast to GPs , DKNPs ’ covariance is learned via attention.2 This decoupled process allows DKNPs to explicitly learn the prior of the given dataset , and thus act as a true generative process , ensuring the global consistency of all points in the given stochastic process samples . Unlike DKNPs , NPs pack all information ( XC , YC , XT ) into latent variables to derive both mean and covariance , thus inherently becoming a conditional process that requires a sufficient amount of context points , unable to explicitly learn a prior . Specifically , the DKNPs pass each context point { ( xi , yi ) } i∈C , the concatenation of xi and yi , to MLPθ and represent it as ei . Similarly , we produce the representation vector of xi , hi , using another MLPϕ for all inputs { xi } i∈C∪T . Then , ei and hi are passed to the MCA module to create the mean vector µy . All heads in the MCA module perform cross-attention , Q = { hi } i∈T , K = { hi } i∈C , and V = { ei } i∈C . We adopted the architecture of MCA used in image transformers ( Parmar et al. , 2018 ) , where the original query vectors are added to the output from the MCA through the residual path . This allows to do inference the output distributions without context points , which can be considered as prior distributions of DKNPs—the learned prior of DKNP . After the MCA , the last MLPψ generates the predictive mean vector µy for each data point . Intuitively , this can be interpreted as predicting the target mean based on the context and the correlation , which resembles the estimation of the predictive distribution in GPs and ANPs . Different from the NPs , DKNPs explicitly capture the correlation between the output variables using another multihead cross-attention ( MCA ) , where Q = { hi } i∈T , K = { hi } i∈C , and V = { ei } i∈C . Then MLPω produces the representation vector wi ∈ Rdw for each position , which are combined to generate the covariance matrix Σ = WW⊤ , where Wi , : = wi and Σij = kernel ( xi , xj ) = w⊤i wj . One might consider using self-attention to let the model learn the correlation between all data points . However , the self-attention module on only X as inputs receives no indication of context and target points and therefore fails to reduce the uncertainty near the points that have high confidence ( e.g. , context points ) . Also , the interaction between the target points through self-attention does not guarantee consistency under the marginal distribution of target points when the context points are given . Lastly , it is also important to note that the representation h is shared when modeling both the mean and the covariance . This motivation is drawn from Equation 5 that the calculation of the mean is also based on the kernel matrices , Σ⊤XC , XT and Σ −1 XC , XC . To train the DKNPs , the obtained mean vector µ and the covariance matrix Σ act as parameters of a predictive distribution N ( Y ; µY , ΣY ) . Instead of maximizing the lower bound of the log-likelihood as in most NP models , the training objective of DKNPs is to maximize the tractable log-likelihood of the Gaussian as follows : log p ( YT |XT , XC , YC ) = logN ( YT ; µY , ΣY ) where ΣY = WW⊤ . ( 7 ) 1We follow the typical GP formulation where the mean function is set to zero . 2Note that DKNPs assume C ⊂ T during training , which makes Eq . 5 and Eq . 6 technically different . This difference comes from DKNPs using all data points for better learning the kernels , unlike fixed-kernel GPs . DKNPs and GPs , however , are different methods and superior empirical performance led to the current design choice . Although the proposed objective function is equivalent to CNP ’ s ( Garnelo et al. , 2018a ) , modeling the correlation between output variables for capturing functional stochasticity shares the same motivation of NPs , thus DKNP being one of NP variants . | Neural processes are a recent proposed type of flexible stochastic processes that models distributions of functions. The distribution of functions implicitly captured by a global latent variable Z that are fed into neural networks. Unlike NPs, the function-space view of Gaussian processes model the function distribution directly as a Gaussian using mean and covariance functions. This work proposes to combine the strength of the two by using attention-based neural networks to model the conditional mean and covariance functions, getting rid of the global latent variable Z. | SP:a7e4825b230d11a18a37675da80d8f0c5399b50a |
Decoupled Kernel Neural Processes: Neural Network-Parameterized Stochastic Processes using Explicit Data-driven Kernel | Neural Processes ( NPs ) are a class of stochastic processes parametrized by neural networks . Unlike traditional stochastic processes ( e.g. , Gaussian processes ) , which require specifying explicit kernel functions , NPs implicitly learn kernel functions appropriate for a given task through observed data . While this data-driven learning of stochastic processes has been shown to model various types of data , the current NPs ’ implicit treatment of the mean and the covariance of the output variables limits its full potential when the underlying distribution of the given data is highly complex . To address this , we introduce a new class of neural stochastic processes , Decoupled Kernel Neural Processes ( DKNPs ) , which explicitly learn a separate mean and kernel function to directly model the covariance between output variables in a data-driven manner . By estimating kernel functions with cross-attentive neural networks , DKNPs demonstrate improved uncertainty estimation in terms of conditional likelihood and diversity in generated samples in 1-D and 2-D regression tasks , compared to other concurrent NP variants . Also , maintaining explicit kernel functions , a key component of stochastic processes , allows the model to reveal a deeper understanding of underlying distributions . 1 INTRODUCTION . Neural processes ( NPs ) ( Garnelo et al. , 2018a ; b ) are a class of stochastic processes parametrized by neural networks . By embracing statistical properties in stochastic processes , NPs can effectively estimate the uncertainty of underlying distributions of functions with a set of realizations and their data points . Different from traditional stochastic processes ( e.g. , Gaussian processes ( GP ) ( Rasmussen & Williams , 2006 ) ) , NPs learn data-driven stochastic processes without a need to specify or keep an explicit form of kernel functions . As a result of their simplicity and flexibility , there have been numerous efforts to further develop improved variants of NPs ( Kim et al. , 2019 ; Lee et al. , 2020 ; Gordon et al. , 2020 ) and apply them to various downstream tasks ( Singh et al. , 2019 ; Requeima et al. , 2019 ) . Though significant progress has been made in NPs , the current architectures of NPs either fails to capture output dependencies as in Conditional NPs ( Garnelo et al. , 2018a ; Gordon et al. , 2020 ) , or indirectly capture the full stochasticity present in the traditional stochastic processes . For instance , different from GPs , conventional NPs reserve stochasticity in a global latent variable and output variables separately . The output variables estimate point-wise uncertainty , which corresponds to the diagonal elements of a kernel matrix . Similarly , the global latent variable takes charge of the functional uncertainty and diversity , represented by the full covariance matrix in GPs . Due to this inductive bias of conventional NPs , the role of estimating functional stochasticity is mainly assigned to a fixed-length vector ( i.e . the global latent variable ) , and consequently , capturing the underlying distributions can be restricted in complex scenarios ( e.g. , variable relationships are periodic or abruptly changing at a certain point ) . Although several approaches attempt to alleviate the problem by introducing attention ( Kim et al. , 2019 ) and bootstrapping ( Lee et al. , 2020 ) on top of conventional NPs , the problem still exists as the architectural limitation ( i.e . implicit modeling of the mean and covariance ) has not been addressed directly . Besides this , as NPs implicitly learn the kernel functions inside the model , the interpretability of kernels such as in GPs ( Lloyd et al. , 2014 ) is diminished . To address this concern , we propose Decoupled Kernel Neural Processes ( DKNPs ) , a new class of neural stochastic processes that explicitly learn a separate mean and kernel function to directly model the covariance between output variables in a data-driven manner . Our experiments in 1-D and 2-D regression tasks reveal that the DKNP outperforms concurrent NP variants in terms of predictive likelihood , better global coherence of generated samples , and improved interpretability via explicitly learned kernels . 2 BACKGROUND . 2.1 NEURAL PROCESS . Given a stochastic process sample consisting of n points , let us denote the input and output as X = { xi } ni=1 and Y = { yi } ni=1 , respectively , where xi ∈ Rdx and yi ∈ Rdy . For a set of target input XT = { xi } i∈T ⊂ X , NPs model the conditional distribution of target outputs YT conditioned on the context set ( XC , YC ) = { ( xi , yi ) } i∈C using a factorized Gaussian distribution : log p ( YT |XT , XC , YC ) = ∑ i∈T log p ( yi|xi , XC , YC ) . ( 1 ) For obtaining the predictive distribution log p ( yi|xi , XC , YC ) , NPs use an encoder-decoder architecture that ensures the permutation invariance of the predictions of the target points given the context set ( XC , YC ) . Following Kim et al . ( 2019 ) and Lee et al . ( 2020 ) , we consider the NP encoder consisting of two separate paths , namely the deterministic path and the latent path . For the deterministic path , fθ represents each context points in { ( xi , yi ) } i∈C as ri ∈ Rdr , i.e. , ri = fθ ( xi , yi ) . Then , we aggregate the ri ’ s by averaging them across all context points , rC = 1nc ∑ i∈C ri where nc = |C| . This vector rC ∈ Rdr is the summarized representation of context points , and it is permutation invariant over the order of ( xi , yi ) ∈ ( XC , YC ) . The latent path of the NP encoder operates in a similar fashion to the deterministic path , i.e. , eC = 1 nc ∑ i∈C ei where ei = gϕ ( [ xi ; yi ] ) . Unlike the deterministic path , however , the la- tent path uses stochastic layers for obtaining a distribution of the latent variable z ∈ Rdz ; q ( z|eC ) = N ( z ; µz , σ2z ) where µz , σz are the output of the additional fully-connected layer applied to eC . Finally , by concatenating these aggregated vectors rC , z with the target inputs xi ∈ XT , the decoder hψ produces the predictive distribution p ( yt|xt , rC , z ) = N ( y ; µy , σ2y ) where ( µy , σy ) = hψ ( xt , rC , z ) . Note that the σy is used for capturing the point-wise uncertainty . During the training phase , the parameters are learned by maximizing the evidence lower bound of log p ( YT |XT , XC , YC ) via the reparametrization trick ( Kingma & Welling , 2014 ; Rezende et al. , 2014 ) as follows : log p ( YT |XT , XC , YC ) ≥ Eq ( z|XT , YT ) [ log p ( YT |XT , z ) ] −KL ( q ( z|eT ) ∥q ( z|eC ) ) ( 2 ) where q ( z|eT ) = q ( et|XT , YT ) is a distribution of latent variable by encoding the set of target points ( XT , YT ) = { ( xi , yi ) } i∈T . This objective function consists of two parts : 1 ) the reconstruction loss for the target points and 2 ) the KL divergence term , minimizing the divergence between two distributions q ( z|XT , YT ) and q ( z|XC , YC ) . Note that , in practice , we assume that XC ⊂ XT during the training phase . The KL divergence term encourages two distributions inferred by the context sets and target sets to be similar , which is reasonable because two sets are generated from the same function . Therefore , during the inference phase , the distribution of q ( z|XC , YC ) captures the functional stochasticity which is demonstrated with the coherent sample generation . It can be thought that z learns to capture the correlation of output variables of the stochastic processes . 2.2 ATTENTIVE NEURAL PROCESSES . Multihead Attention Given n key-value pairs of matrices K ∈ Rn×dmodel and V ∈ Rn×dmodel , and m queries Q ∈ Rm×dmodel , the scaled dot product attention is formulated as : Attention ( Q , K , V ) = Softmax ( QK⊤√ dmodel ) V ∈ Rm×dmodel , ( 3 ) where K , V , and Q are projected by learnable linear maps WKs , W V s , and W Q t from the source S and target T . The attention mechanism can be calculated from multiple subspaces , namely , multihead attention ( MHA ) ( Vaswani et al. , 2017 ) . Denoting a single attention head as Headi = Attention ( Qi , Ki , Vi ) , the aggregate attention from multiple subspaces can be expressed as : MHA ( Q , K , V ) = Concat ( Head1 , ... , HeadH ) WO ∈ Rm×dmodel , ( 4 ) where WO is the learnable linear map for aggretating the subspaces . Attentive NPs Attentive NPs ( ANPs ) leverage attention to resolve the underfitting issue in NPs . Unlike NPs that produce a single variable rC from the deterministic path , ANPs utilize a queryspecific variable r∗i by applying the attention score ai for each ri during the aggregation of the deterministic path , formulated as r∗i = ∑ i∈C ai · ri . The attention-based aggregation of ANPs resembles how the GPs utilize the correlation to estimate the predictive distribution of the context and the target points . 3 DECOUPLED KERNEL NEURAL PROCESSES . Decoupled Kernel Neural Processes use attention to explicitly learn a separate mean and kernel function so as to directly model covariances between output variables with related input variables in a data-driven fashion , which is contrary to conventional NPs that implicitly model the mean and kernel function through the latent variable z . As shown in Figure 2 , DKNPs estimate the predictive distribution as multivariate Gaussian N ( y ; µy , Σy ) by using two attention-based deterministic paths using Multihead Cross-Attention ( MCA ) to model the mean vector ( upper path ) and the full covariance matrix ( lower path ) . Here , attention modules are extensively utilized as Le et al . ( 2018 ) ; Kim et al . ( 2019 ) have demonstrated attention was helpful in achieving low predictive uncertainty near the context points . With the predictive distribution N ( y ; µy , Σy ) , DKNPs are trained and evaluated based on the function likelihood . The core design of DKNPs is motivated by the predictive posterior distribution of GPs , where XT , XC , YC are used for deriving the posterior mean,1 but only XT , XC for deriving the posterior covariance as follows : GP : p ( YT |XT , XC , YC ) = N ( YT ; Σ ⊤ XC , XT Σ −1 XC , XC YC , ΣXT , XT − Σ ⊤ XC , XT Σ −1 XC , XC ΣXC , XT ) , ( 5 ) DKNP : p ( YT |XT , XC , YC ) = N ( YT ; MLPψ ◦ MCA ( MLPθ ( XC , YC ) , MLPϕ ( XT , XC ) ) , MLPω ◦ MCA ( MLPϕ ( XT , XC ) ) ) , ( 6 ) where , in contrast to GPs , DKNPs ’ covariance is learned via attention.2 This decoupled process allows DKNPs to explicitly learn the prior of the given dataset , and thus act as a true generative process , ensuring the global consistency of all points in the given stochastic process samples . Unlike DKNPs , NPs pack all information ( XC , YC , XT ) into latent variables to derive both mean and covariance , thus inherently becoming a conditional process that requires a sufficient amount of context points , unable to explicitly learn a prior . Specifically , the DKNPs pass each context point { ( xi , yi ) } i∈C , the concatenation of xi and yi , to MLPθ and represent it as ei . Similarly , we produce the representation vector of xi , hi , using another MLPϕ for all inputs { xi } i∈C∪T . Then , ei and hi are passed to the MCA module to create the mean vector µy . All heads in the MCA module perform cross-attention , Q = { hi } i∈T , K = { hi } i∈C , and V = { ei } i∈C . We adopted the architecture of MCA used in image transformers ( Parmar et al. , 2018 ) , where the original query vectors are added to the output from the MCA through the residual path . This allows to do inference the output distributions without context points , which can be considered as prior distributions of DKNPs—the learned prior of DKNP . After the MCA , the last MLPψ generates the predictive mean vector µy for each data point . Intuitively , this can be interpreted as predicting the target mean based on the context and the correlation , which resembles the estimation of the predictive distribution in GPs and ANPs . Different from the NPs , DKNPs explicitly capture the correlation between the output variables using another multihead cross-attention ( MCA ) , where Q = { hi } i∈T , K = { hi } i∈C , and V = { ei } i∈C . Then MLPω produces the representation vector wi ∈ Rdw for each position , which are combined to generate the covariance matrix Σ = WW⊤ , where Wi , : = wi and Σij = kernel ( xi , xj ) = w⊤i wj . One might consider using self-attention to let the model learn the correlation between all data points . However , the self-attention module on only X as inputs receives no indication of context and target points and therefore fails to reduce the uncertainty near the points that have high confidence ( e.g. , context points ) . Also , the interaction between the target points through self-attention does not guarantee consistency under the marginal distribution of target points when the context points are given . Lastly , it is also important to note that the representation h is shared when modeling both the mean and the covariance . This motivation is drawn from Equation 5 that the calculation of the mean is also based on the kernel matrices , Σ⊤XC , XT and Σ −1 XC , XC . To train the DKNPs , the obtained mean vector µ and the covariance matrix Σ act as parameters of a predictive distribution N ( Y ; µY , ΣY ) . Instead of maximizing the lower bound of the log-likelihood as in most NP models , the training objective of DKNPs is to maximize the tractable log-likelihood of the Gaussian as follows : log p ( YT |XT , XC , YC ) = logN ( YT ; µY , ΣY ) where ΣY = WW⊤ . ( 7 ) 1We follow the typical GP formulation where the mean function is set to zero . 2Note that DKNPs assume C ⊂ T during training , which makes Eq . 5 and Eq . 6 technically different . This difference comes from DKNPs using all data points for better learning the kernels , unlike fixed-kernel GPs . DKNPs and GPs , however , are different methods and superior empirical performance led to the current design choice . Although the proposed objective function is equivalent to CNP ’ s ( Garnelo et al. , 2018a ) , modeling the correlation between output variables for capturing functional stochasticity shares the same motivation of NPs , thus DKNP being one of NP variants . | The paper proposes Decoupled Kernel Neural Processes (DKNPs), which is a variant of neural processes first proposed a few years ago. The main contribution is to decouple the process of learning the mean and the covariance functions separately. Empirical evaluations are provided to demonstrate its usefulness. | SP:a7e4825b230d11a18a37675da80d8f0c5399b50a |
Decoupled Kernel Neural Processes: Neural Network-Parameterized Stochastic Processes using Explicit Data-driven Kernel | Neural Processes ( NPs ) are a class of stochastic processes parametrized by neural networks . Unlike traditional stochastic processes ( e.g. , Gaussian processes ) , which require specifying explicit kernel functions , NPs implicitly learn kernel functions appropriate for a given task through observed data . While this data-driven learning of stochastic processes has been shown to model various types of data , the current NPs ’ implicit treatment of the mean and the covariance of the output variables limits its full potential when the underlying distribution of the given data is highly complex . To address this , we introduce a new class of neural stochastic processes , Decoupled Kernel Neural Processes ( DKNPs ) , which explicitly learn a separate mean and kernel function to directly model the covariance between output variables in a data-driven manner . By estimating kernel functions with cross-attentive neural networks , DKNPs demonstrate improved uncertainty estimation in terms of conditional likelihood and diversity in generated samples in 1-D and 2-D regression tasks , compared to other concurrent NP variants . Also , maintaining explicit kernel functions , a key component of stochastic processes , allows the model to reveal a deeper understanding of underlying distributions . 1 INTRODUCTION . Neural processes ( NPs ) ( Garnelo et al. , 2018a ; b ) are a class of stochastic processes parametrized by neural networks . By embracing statistical properties in stochastic processes , NPs can effectively estimate the uncertainty of underlying distributions of functions with a set of realizations and their data points . Different from traditional stochastic processes ( e.g. , Gaussian processes ( GP ) ( Rasmussen & Williams , 2006 ) ) , NPs learn data-driven stochastic processes without a need to specify or keep an explicit form of kernel functions . As a result of their simplicity and flexibility , there have been numerous efforts to further develop improved variants of NPs ( Kim et al. , 2019 ; Lee et al. , 2020 ; Gordon et al. , 2020 ) and apply them to various downstream tasks ( Singh et al. , 2019 ; Requeima et al. , 2019 ) . Though significant progress has been made in NPs , the current architectures of NPs either fails to capture output dependencies as in Conditional NPs ( Garnelo et al. , 2018a ; Gordon et al. , 2020 ) , or indirectly capture the full stochasticity present in the traditional stochastic processes . For instance , different from GPs , conventional NPs reserve stochasticity in a global latent variable and output variables separately . The output variables estimate point-wise uncertainty , which corresponds to the diagonal elements of a kernel matrix . Similarly , the global latent variable takes charge of the functional uncertainty and diversity , represented by the full covariance matrix in GPs . Due to this inductive bias of conventional NPs , the role of estimating functional stochasticity is mainly assigned to a fixed-length vector ( i.e . the global latent variable ) , and consequently , capturing the underlying distributions can be restricted in complex scenarios ( e.g. , variable relationships are periodic or abruptly changing at a certain point ) . Although several approaches attempt to alleviate the problem by introducing attention ( Kim et al. , 2019 ) and bootstrapping ( Lee et al. , 2020 ) on top of conventional NPs , the problem still exists as the architectural limitation ( i.e . implicit modeling of the mean and covariance ) has not been addressed directly . Besides this , as NPs implicitly learn the kernel functions inside the model , the interpretability of kernels such as in GPs ( Lloyd et al. , 2014 ) is diminished . To address this concern , we propose Decoupled Kernel Neural Processes ( DKNPs ) , a new class of neural stochastic processes that explicitly learn a separate mean and kernel function to directly model the covariance between output variables in a data-driven manner . Our experiments in 1-D and 2-D regression tasks reveal that the DKNP outperforms concurrent NP variants in terms of predictive likelihood , better global coherence of generated samples , and improved interpretability via explicitly learned kernels . 2 BACKGROUND . 2.1 NEURAL PROCESS . Given a stochastic process sample consisting of n points , let us denote the input and output as X = { xi } ni=1 and Y = { yi } ni=1 , respectively , where xi ∈ Rdx and yi ∈ Rdy . For a set of target input XT = { xi } i∈T ⊂ X , NPs model the conditional distribution of target outputs YT conditioned on the context set ( XC , YC ) = { ( xi , yi ) } i∈C using a factorized Gaussian distribution : log p ( YT |XT , XC , YC ) = ∑ i∈T log p ( yi|xi , XC , YC ) . ( 1 ) For obtaining the predictive distribution log p ( yi|xi , XC , YC ) , NPs use an encoder-decoder architecture that ensures the permutation invariance of the predictions of the target points given the context set ( XC , YC ) . Following Kim et al . ( 2019 ) and Lee et al . ( 2020 ) , we consider the NP encoder consisting of two separate paths , namely the deterministic path and the latent path . For the deterministic path , fθ represents each context points in { ( xi , yi ) } i∈C as ri ∈ Rdr , i.e. , ri = fθ ( xi , yi ) . Then , we aggregate the ri ’ s by averaging them across all context points , rC = 1nc ∑ i∈C ri where nc = |C| . This vector rC ∈ Rdr is the summarized representation of context points , and it is permutation invariant over the order of ( xi , yi ) ∈ ( XC , YC ) . The latent path of the NP encoder operates in a similar fashion to the deterministic path , i.e. , eC = 1 nc ∑ i∈C ei where ei = gϕ ( [ xi ; yi ] ) . Unlike the deterministic path , however , the la- tent path uses stochastic layers for obtaining a distribution of the latent variable z ∈ Rdz ; q ( z|eC ) = N ( z ; µz , σ2z ) where µz , σz are the output of the additional fully-connected layer applied to eC . Finally , by concatenating these aggregated vectors rC , z with the target inputs xi ∈ XT , the decoder hψ produces the predictive distribution p ( yt|xt , rC , z ) = N ( y ; µy , σ2y ) where ( µy , σy ) = hψ ( xt , rC , z ) . Note that the σy is used for capturing the point-wise uncertainty . During the training phase , the parameters are learned by maximizing the evidence lower bound of log p ( YT |XT , XC , YC ) via the reparametrization trick ( Kingma & Welling , 2014 ; Rezende et al. , 2014 ) as follows : log p ( YT |XT , XC , YC ) ≥ Eq ( z|XT , YT ) [ log p ( YT |XT , z ) ] −KL ( q ( z|eT ) ∥q ( z|eC ) ) ( 2 ) where q ( z|eT ) = q ( et|XT , YT ) is a distribution of latent variable by encoding the set of target points ( XT , YT ) = { ( xi , yi ) } i∈T . This objective function consists of two parts : 1 ) the reconstruction loss for the target points and 2 ) the KL divergence term , minimizing the divergence between two distributions q ( z|XT , YT ) and q ( z|XC , YC ) . Note that , in practice , we assume that XC ⊂ XT during the training phase . The KL divergence term encourages two distributions inferred by the context sets and target sets to be similar , which is reasonable because two sets are generated from the same function . Therefore , during the inference phase , the distribution of q ( z|XC , YC ) captures the functional stochasticity which is demonstrated with the coherent sample generation . It can be thought that z learns to capture the correlation of output variables of the stochastic processes . 2.2 ATTENTIVE NEURAL PROCESSES . Multihead Attention Given n key-value pairs of matrices K ∈ Rn×dmodel and V ∈ Rn×dmodel , and m queries Q ∈ Rm×dmodel , the scaled dot product attention is formulated as : Attention ( Q , K , V ) = Softmax ( QK⊤√ dmodel ) V ∈ Rm×dmodel , ( 3 ) where K , V , and Q are projected by learnable linear maps WKs , W V s , and W Q t from the source S and target T . The attention mechanism can be calculated from multiple subspaces , namely , multihead attention ( MHA ) ( Vaswani et al. , 2017 ) . Denoting a single attention head as Headi = Attention ( Qi , Ki , Vi ) , the aggregate attention from multiple subspaces can be expressed as : MHA ( Q , K , V ) = Concat ( Head1 , ... , HeadH ) WO ∈ Rm×dmodel , ( 4 ) where WO is the learnable linear map for aggretating the subspaces . Attentive NPs Attentive NPs ( ANPs ) leverage attention to resolve the underfitting issue in NPs . Unlike NPs that produce a single variable rC from the deterministic path , ANPs utilize a queryspecific variable r∗i by applying the attention score ai for each ri during the aggregation of the deterministic path , formulated as r∗i = ∑ i∈C ai · ri . The attention-based aggregation of ANPs resembles how the GPs utilize the correlation to estimate the predictive distribution of the context and the target points . 3 DECOUPLED KERNEL NEURAL PROCESSES . Decoupled Kernel Neural Processes use attention to explicitly learn a separate mean and kernel function so as to directly model covariances between output variables with related input variables in a data-driven fashion , which is contrary to conventional NPs that implicitly model the mean and kernel function through the latent variable z . As shown in Figure 2 , DKNPs estimate the predictive distribution as multivariate Gaussian N ( y ; µy , Σy ) by using two attention-based deterministic paths using Multihead Cross-Attention ( MCA ) to model the mean vector ( upper path ) and the full covariance matrix ( lower path ) . Here , attention modules are extensively utilized as Le et al . ( 2018 ) ; Kim et al . ( 2019 ) have demonstrated attention was helpful in achieving low predictive uncertainty near the context points . With the predictive distribution N ( y ; µy , Σy ) , DKNPs are trained and evaluated based on the function likelihood . The core design of DKNPs is motivated by the predictive posterior distribution of GPs , where XT , XC , YC are used for deriving the posterior mean,1 but only XT , XC for deriving the posterior covariance as follows : GP : p ( YT |XT , XC , YC ) = N ( YT ; Σ ⊤ XC , XT Σ −1 XC , XC YC , ΣXT , XT − Σ ⊤ XC , XT Σ −1 XC , XC ΣXC , XT ) , ( 5 ) DKNP : p ( YT |XT , XC , YC ) = N ( YT ; MLPψ ◦ MCA ( MLPθ ( XC , YC ) , MLPϕ ( XT , XC ) ) , MLPω ◦ MCA ( MLPϕ ( XT , XC ) ) ) , ( 6 ) where , in contrast to GPs , DKNPs ’ covariance is learned via attention.2 This decoupled process allows DKNPs to explicitly learn the prior of the given dataset , and thus act as a true generative process , ensuring the global consistency of all points in the given stochastic process samples . Unlike DKNPs , NPs pack all information ( XC , YC , XT ) into latent variables to derive both mean and covariance , thus inherently becoming a conditional process that requires a sufficient amount of context points , unable to explicitly learn a prior . Specifically , the DKNPs pass each context point { ( xi , yi ) } i∈C , the concatenation of xi and yi , to MLPθ and represent it as ei . Similarly , we produce the representation vector of xi , hi , using another MLPϕ for all inputs { xi } i∈C∪T . Then , ei and hi are passed to the MCA module to create the mean vector µy . All heads in the MCA module perform cross-attention , Q = { hi } i∈T , K = { hi } i∈C , and V = { ei } i∈C . We adopted the architecture of MCA used in image transformers ( Parmar et al. , 2018 ) , where the original query vectors are added to the output from the MCA through the residual path . This allows to do inference the output distributions without context points , which can be considered as prior distributions of DKNPs—the learned prior of DKNP . After the MCA , the last MLPψ generates the predictive mean vector µy for each data point . Intuitively , this can be interpreted as predicting the target mean based on the context and the correlation , which resembles the estimation of the predictive distribution in GPs and ANPs . Different from the NPs , DKNPs explicitly capture the correlation between the output variables using another multihead cross-attention ( MCA ) , where Q = { hi } i∈T , K = { hi } i∈C , and V = { ei } i∈C . Then MLPω produces the representation vector wi ∈ Rdw for each position , which are combined to generate the covariance matrix Σ = WW⊤ , where Wi , : = wi and Σij = kernel ( xi , xj ) = w⊤i wj . One might consider using self-attention to let the model learn the correlation between all data points . However , the self-attention module on only X as inputs receives no indication of context and target points and therefore fails to reduce the uncertainty near the points that have high confidence ( e.g. , context points ) . Also , the interaction between the target points through self-attention does not guarantee consistency under the marginal distribution of target points when the context points are given . Lastly , it is also important to note that the representation h is shared when modeling both the mean and the covariance . This motivation is drawn from Equation 5 that the calculation of the mean is also based on the kernel matrices , Σ⊤XC , XT and Σ −1 XC , XC . To train the DKNPs , the obtained mean vector µ and the covariance matrix Σ act as parameters of a predictive distribution N ( Y ; µY , ΣY ) . Instead of maximizing the lower bound of the log-likelihood as in most NP models , the training objective of DKNPs is to maximize the tractable log-likelihood of the Gaussian as follows : log p ( YT |XT , XC , YC ) = logN ( YT ; µY , ΣY ) where ΣY = WW⊤ . ( 7 ) 1We follow the typical GP formulation where the mean function is set to zero . 2Note that DKNPs assume C ⊂ T during training , which makes Eq . 5 and Eq . 6 technically different . This difference comes from DKNPs using all data points for better learning the kernels , unlike fixed-kernel GPs . DKNPs and GPs , however , are different methods and superior empirical performance led to the current design choice . Although the proposed objective function is equivalent to CNP ’ s ( Garnelo et al. , 2018a ) , modeling the correlation between output variables for capturing functional stochasticity shares the same motivation of NPs , thus DKNP being one of NP variants . | The authors proposed a novel extension of the neural process by explicitly and separately modeling the mean and the covariance of output variables via multi-head attention. The general NP has the problem that it doesn't well calibrate the output uncertainty when the data sample size is small. However, DKNP seems to mimic the uncertainty calibration behavior similar to GP which is encouraging. The experimental results look convincing with an extensive comparison over state-of-the-art NP variants. | SP:a7e4825b230d11a18a37675da80d8f0c5399b50a |
Decentralized Cross-Entropy Method for Model-Based Reinforcement Learning | Cross-Entropy Method ( CEM ) is a popular approach to planning in model-based reinforcement learning . It has so far always taken a centralized approach where the sampling distribution is updated centrally based on the result of a top-k operation applied to all samples . We show that such a centralized approach makes CEM vulnerable to local optima and impairs its sample efficiency , even in a one-dimensional multi-modal optimization task . In this paper , we propose Decentralized CEM ( DecentCEM ) where an ensemble of CEM instances run independently from one another and each performs a local improvement of its own sampling distribution . In the exemplar optimization task , the proposed decentralized approach DecentCEM finds the global optimum much more consistently than the centralized CEM approaches that use either a single or a mixture of Gaussian distributions . Also , we show that DecentCEM is theoretically sound . Further , we extend the decentralized approach to sequential decision-making problems where we show in several continuous control benchmark environments that it provides an effective mechanism to improve the performance of CEM algorithms , under the same sample budget for planning . 1 INTRODUCTION . Model-based reinforcement learning ( MBRL ) uses a model as a proxy of the environment for planning actions in multiple steps . This paper studies planning in MBRL with a specific focus on the Cross-Entropy Method ( CEM ) ( De Boer et al. , 2005 ; Mannor et al. , 2003 ) , which is popular in MBRL due to its ease of use and strong empirical performance ( Chua et al. , 2018 ; Hafner et al. , 2019 ; Wang & Ba , 2020 ; Zhang et al. , 2021 ; Yang et al. , 2020 ) . CEM is a stochastic , derivativefree optimization method . It uses a sampling distribution to generate imaginary trajectories of environment-agent interactions with the model . These trajectories are then ranked based on their returns computed from the rewards given by the model . The sampling distribution is updated to increase the likelihood of producing the top-k trajectories with higher returns . These steps are iterated and eventually yield an improved distribution over the action sequences to guide the action execution in the real environment . Despite the strong empirical performance of CEM for planning , it is prone to two problems : ( 1 ) lower sample efficiency as the dimensionality of solution space increases , and ( 2 ) the Gaussian distribution that is commonly used for sampling may cause the optimization to get stuck in local optima of multi-modal solution spaces commonly seen in real-world problems . Previous works addressing these problems either add gradient-based updates of the samples to optimize the parameters of CEM , or adopt more expressive sampling distributions , such as using Gaussian Mixture Model ( Okada & Taniguchi , 2020 ) or masked auto-regressive neural network ( Hakhamaneshi et al. , 2020 ) . Nevertheless , all CEM implementations to date are limited to a centralized formulation where the ranking step involves all samples . As analyzed below and in Section 3 , such a centralized design makes CEM vulnerable to local optima and impairs its sample efficiency . We propose Decentralized CEM ( DecentCEM ) to address the above problems . Rather than ranking all samples , as in the centralized design , our method distribute the sampling budget across an ensemble of CEM instances . These instances run independently from one another , and each performs a local improvement of its own sampling distribution based on the ranking of its generated samples . The best action is then aggregated by taking an arg max among the solution of the instances . It recovers the conventional CEM when the number of instance is one . We hypothesize that by shifting to this decentralized design , CEM can be less susceptible to premature convergence caused by the centralized ranking step . As illustrated in Fig . 1 , the centralized sampling distribution exhibits a bias toward the sub-optimal solutions near top right , due to the global top-k ranking . This bias would occur regardless of the family of distributions used . In comparison , a decentralized approach could maintain enough diversity thanks to its local top-k ranking in each sampling instance . Through a one-dimensional multi-modal optimization problem in Section 3 , we show that DecentCEM empirically finds the global optimum more consistently than centralized CEM approaches that use either a single Gaussian or a mixture of Gaussian distributions . Also we show that DecentCEM is theoretically sound that it converges almost surely to a local optimum . We further apply DecentCEM to sequential decision making problems and use neural networks to parameterize the sampling distribution in each CEM instance . Empirical results in several continuous control benchmarks suggest that DecentCEM offers an effective mechanism to improve the sample efficiency over the baseline CEM methods under the same sample budget for planning . 2 PRELIMINARIES . We consider a Markov Decision Process ( MDP ) specified by ( S , A , R , P , γ , d0 , T ) . S ⊂ Rds is the state space , A ⊂ Rda is the action space . R : S × A → R is the reward function that maps a state and action pair to a real-valued reward . P ( s′|s , a ) : S × A × S → R+ is the transition probability from a state and action pair s , a to the next state s′ . γ ∈ [ 0 , 1 ] is the discount factor . d0 denotes the distribution of the initial state s0 . At time step t , the agent receives a state st 1 and takes an action at according to a policy π ( ·|s ) that maps the state to a probability distribution over the action space . The environment transitions to the next state st+1 ∼ P ( ·|st , at ) and gives a reward rt = R ( st , at ) to the agent 2 . The return Gt = ∑T i=0 γ irt+i , is the sum of discounted reward within an episode length of T . The agent aims to find a policy π that maximizes the expected return . We denote the learned model in MBRL as fω ( ·|s , a ) , which is parameterized by ω and approximates P ( ·|s , a ) . Planning with the Cross Entropy Method Planning in MBRL is about leveraging the model to find the best action in terms of its return . Model-Predictive-Control ( MPC ) performs online planning at each time step up to a horizon to find the optimal action sequence : πMPC ( st ) = arg max at : t+H−1 E [ ΣH−1i=0 γ ir ( st+i , at+i ) + γ HV ( sH ) ] ( 1 ) whereH is the planning horizon , at : t+H−1 denotes the action sequence from time step t to t+H−1 , and V ( sH ) is the terminal value function at the end of the planning horizon . The first action in this sequence is executed and the rest are discarded . The agent then re-plans at the next time step . The Cross-Entropy Method ( CEM ) is a gradient-free optimization method that can be used for solving Eq . ( 1 ) . The workflow is shown in Fig . 2 . CEM planning starts by generating N samples { τj } Nj=1 = { ( âj,0 , âj,1 , · · · , âj , H−1 ) } Nj=1 from an initial sampling distribution gφ ( τ ) parameterized 1We assume full observability , i.e. , we assume that the agent has access to the state . 2We assume that the agent receives the true reward . This makes the problem easier but is unfair to MBRL methods that do not assume this . Thus , we will limit comparison to methods that also make this assumption . by φ , where each sample τj is an action sequence from the current time step up to the planning horizon H . The domain of gφ ( τ ) has a dimension of dτ = daH . Using a model f , CEM generates imaginary rollouts based on the action sequence { τj } ( in the case of a stochastic model ) and estimate the associated value v ( τj ) = E [ ΣH−1i=0 γir ( sj , i , aj , i ) ] where sj,0 is the current state s and sj , i+1 ∼ f ( sj , i , aj , i ) . The terminal value γHV ( sj , H ) is omitted here following convention in the CEM planning literature but the MPC performance can be further improved if paired with an accurate value predictor ( Bertsekas , 2005 ; Lowrey et al. , 2019 ) . The sampling distribution is then updated by fitting to the current top-k samples in terms of their value estimates v ( τj ) , using the Maximum Likelihood Estimation ( MLE ) which solves : φ′ = arg max φ N∑ j=1 1 ( v ( τj ) ≥ vth ) log gφ ( τj ) ( 2 ) where vth is the threshold equal to the value of the k-th best sample and 1 ( · ) is the indicator function . In practice , the update to the distribution parameters are smoothed by φl+1 = αφ′+ ( 1−α ) φl where α ∈ [ 0 , 1 ] is a smoothing parameter that balances between the solution to Eq . ( 2 ) and the parameter at the current internal iteration l. CEM repeats this process of sampling and distribution update in an inner-loop , until it reaches the stopping condition . In practice , it is stopped when either a maximum number of iterations has been reached or the parameters have not changed for a few iterations . The output of CEM is an action sequence , typically set as the expectation3 of the most recent sampling distribution for uni-modal distributions such as Gaussians µ̂ = E ( gφ ) = ( â0 , â1 , · · · , âH−1 ) . Choices of Sampling Distributions in CEM A common choice of the sampling distribution is a multivariate Gaussian distribution under which Eq . ( 2 ) has a straight-forward analytical solution . But the uni-modal nature of Gaussian makes it inadequate in solving multi-modal optimization that often occur in MBRL . To increase the capacity of the distribution , a Gaussian Mixture Model ( GMM ) can be used ( Okada & Taniguchi , 2020 ) . We denote such an approach as CEM-GMM . Going forward , we use CEM to refer to the vanilla version that uses a Gaussian distribution . Computationally , the major difference between CEM and CEM-GMM is that the distribution update in CEM-GMM involves solving for more parameters . Detailed steps can be found in Okada & Taniguchi ( 2020 ) . 3 DECENTRALIZED CEM . In this section , we first introduce the formulation of the proposed decentralized approach called the Decentralized CEM ( DecentCEM ) . Then we illustrate the intuition behind the proposed approach using a one-dimensional synthetic multi-modal optimization example where we show the issues of the existing CEM methods and how they can be addressed by DecentCEM . Formulation of DecentCEM DecentCEM is composed of an ensemble of multiple CEM instances indexed by i , each having its own sampling distributions gφi . They can be described by a set of distribution parameters Φ = { φi } Mi=1 . Each instance i manages its own sampling and distribution update by the steps described in Section 2 , independently from other instances . Note that the number of samples and elites are evenly split among the M instances . The top- kM sample sets are decentralized and managed by each instance independently whereas the centralized approach only keeps one set of top-k samples regardless of the distribution family used . After the stopping 3Other options are discussed in Appendix A.2 condition is reached for all instances , the final sampling distribution is taken as the best distribution in the set Φ according to ( the arg max uses a deterministic tie-breaking ) : φDecentCEM = arg max φi∈Φ Eφi [ v ( x ) ] ≈ arg max φi∈Φ N M∑ j=1 v ( τi , j ) ( 3 ) where Eφi [ v ( x ) ] denotes the expectation with respect to the distribution gφi , approximated by the sample mean . When M = 1 , it recovers the conventional CEM method . Motivational Example Consider a one dimensional multi-modal optimization problem shown in Fig.3 ( Left ) . There are eight local optima , including one global optimum f ( x∗ ) = −1.9 where x∗ = 5.146 . This objective function mimics the RL value landscape that has many local optima , as shown by Wang & Ba ( 2020 ) . This optimization problem is “ easy ” in the sense that a grid search over the domain can get us a solution close to the global optimum . However , only our proposed DecentCEM method successfully converges to the global optimum consistently under varying population size ( i.e. , number of samples ) and random runs , as shown in Fig.3 ( Right ) 4 . Both CEM-GMM and the proposed DecentCEM are equipped with multiple sampling distributions . The fact that CEM-GMM is outperformed by DecentCEM may appear surprising . To gain some insights , we illustrate in Fig . 4 how the sampling distribution evolves during the iterative update ( more details in Fig . 9 in Appendix ) . CEM updated the unimodal distribution toward a local optimum despite seeing the global optimum . CEM-GMM appears to have a similar issue . During MLE on the top-k samples , it moved most distribution components towards the same local optimum which quickly lead to mode collapse . On the contrary , DecentCEM successfully escaped the local optima thanks to its independent distribution update over decentralized top-k samples and was able to maintain a decent diversity among the distributions . GMM suits density estimation problems like distribution-based clustering where the samples are drawn from a fixed true distribution that can be represented by multi-modal Gaussians . However , 4For a fair comparison , hyperparameter search has been conducted on all three methods for each population size ( Appendix A ) . in CEM for optimization , exploration is coupled with density estimation : the sampling distribution in CEM is not fixed but rather gets updated iteratively toward the top-k samples . And the “ true ” distribution in optimization puts uniform non-zero densities to the global optima and zero densities everywhere else . When there is a unique global optimum , it degenerates into a Dirac measure that assigns the entire density to the optimum . Density estimation of such a distribution only needs one Gaussian but the exploration is challenging . In other words , the conditions for GMM to work well are not necessarily met when used as the sampling distribution in CEM . CEM-GMM is subject to mode collapse during the iterative top-k greedification , causing premature convergence , as observed in Fig 4 . In comparison , our proposed decentralized approach takes care of the exploration aspect by running multiple CEM instances independently , each performing its own local improvement . This is shown to be effective from this optimization example and the benchmark results in Section 6 . CEM-GMM only consistently converge to the global optimum when we increase the population size to the maximum 1,000 which causes expensive computations . Our proposed DecentCEM runs more than 100 times faster than CEM-GMM at this population size , shown in Table A.3 in Appendix . Convergence of DecentCEM We state the convergence result of DecentCEM in Theorem 3.1 . We show that the previous convergence result of CEM ( Hu et al. , 2011 ) applies to DecentCEM under the same sample budget . The key observation is that the convergence property of each CEM instance still holds since the number of samples in each instance is only changed by a constant factor ( the number of instances ) . We leave the detailed proof to appendix H. Theorem 3.1 ( Convergence of DecentCEM ) . If Assumptions 1-5 hold for a CEM instance described in Algorithm 3 and we decentralize it by evenly dividing its sample sizeNk intoM CEM instances in DecentCEM algorithm that satisfies Assumption 6 , then the sequence of iterates { ηi , k } generated by each CEM instance indexed by i converges almost surely to an internally chain recurrent set ( Hirsch et al. , 2001 ) of Equation 7 . Furthermore , the solution of DecentCEM { ηo , k } converges almost surely to the best solution of the individual instances in terms of the expected value of Em−1 ( η ) [ V ( x ) ] . | This paper proposes an extension of the Cross-Entropy Method (CEM) for optimisation that consists in an ensemble of multiple standard CEM instances, each one being optimised independently, and the solution at each step is the output of the top performer CEM at that step. Simulation results in a continuous control benchmark show that the proposed algorithm matches or outperforms previous CEM variants. The authors also use a toy problem to illustrate how using an ensemble can help to escape local minimum. | SP:91fb34076c936364379e33e7579b5daeccc5c8e9 |
Decentralized Cross-Entropy Method for Model-Based Reinforcement Learning | Cross-Entropy Method ( CEM ) is a popular approach to planning in model-based reinforcement learning . It has so far always taken a centralized approach where the sampling distribution is updated centrally based on the result of a top-k operation applied to all samples . We show that such a centralized approach makes CEM vulnerable to local optima and impairs its sample efficiency , even in a one-dimensional multi-modal optimization task . In this paper , we propose Decentralized CEM ( DecentCEM ) where an ensemble of CEM instances run independently from one another and each performs a local improvement of its own sampling distribution . In the exemplar optimization task , the proposed decentralized approach DecentCEM finds the global optimum much more consistently than the centralized CEM approaches that use either a single or a mixture of Gaussian distributions . Also , we show that DecentCEM is theoretically sound . Further , we extend the decentralized approach to sequential decision-making problems where we show in several continuous control benchmark environments that it provides an effective mechanism to improve the performance of CEM algorithms , under the same sample budget for planning . 1 INTRODUCTION . Model-based reinforcement learning ( MBRL ) uses a model as a proxy of the environment for planning actions in multiple steps . This paper studies planning in MBRL with a specific focus on the Cross-Entropy Method ( CEM ) ( De Boer et al. , 2005 ; Mannor et al. , 2003 ) , which is popular in MBRL due to its ease of use and strong empirical performance ( Chua et al. , 2018 ; Hafner et al. , 2019 ; Wang & Ba , 2020 ; Zhang et al. , 2021 ; Yang et al. , 2020 ) . CEM is a stochastic , derivativefree optimization method . It uses a sampling distribution to generate imaginary trajectories of environment-agent interactions with the model . These trajectories are then ranked based on their returns computed from the rewards given by the model . The sampling distribution is updated to increase the likelihood of producing the top-k trajectories with higher returns . These steps are iterated and eventually yield an improved distribution over the action sequences to guide the action execution in the real environment . Despite the strong empirical performance of CEM for planning , it is prone to two problems : ( 1 ) lower sample efficiency as the dimensionality of solution space increases , and ( 2 ) the Gaussian distribution that is commonly used for sampling may cause the optimization to get stuck in local optima of multi-modal solution spaces commonly seen in real-world problems . Previous works addressing these problems either add gradient-based updates of the samples to optimize the parameters of CEM , or adopt more expressive sampling distributions , such as using Gaussian Mixture Model ( Okada & Taniguchi , 2020 ) or masked auto-regressive neural network ( Hakhamaneshi et al. , 2020 ) . Nevertheless , all CEM implementations to date are limited to a centralized formulation where the ranking step involves all samples . As analyzed below and in Section 3 , such a centralized design makes CEM vulnerable to local optima and impairs its sample efficiency . We propose Decentralized CEM ( DecentCEM ) to address the above problems . Rather than ranking all samples , as in the centralized design , our method distribute the sampling budget across an ensemble of CEM instances . These instances run independently from one another , and each performs a local improvement of its own sampling distribution based on the ranking of its generated samples . The best action is then aggregated by taking an arg max among the solution of the instances . It recovers the conventional CEM when the number of instance is one . We hypothesize that by shifting to this decentralized design , CEM can be less susceptible to premature convergence caused by the centralized ranking step . As illustrated in Fig . 1 , the centralized sampling distribution exhibits a bias toward the sub-optimal solutions near top right , due to the global top-k ranking . This bias would occur regardless of the family of distributions used . In comparison , a decentralized approach could maintain enough diversity thanks to its local top-k ranking in each sampling instance . Through a one-dimensional multi-modal optimization problem in Section 3 , we show that DecentCEM empirically finds the global optimum more consistently than centralized CEM approaches that use either a single Gaussian or a mixture of Gaussian distributions . Also we show that DecentCEM is theoretically sound that it converges almost surely to a local optimum . We further apply DecentCEM to sequential decision making problems and use neural networks to parameterize the sampling distribution in each CEM instance . Empirical results in several continuous control benchmarks suggest that DecentCEM offers an effective mechanism to improve the sample efficiency over the baseline CEM methods under the same sample budget for planning . 2 PRELIMINARIES . We consider a Markov Decision Process ( MDP ) specified by ( S , A , R , P , γ , d0 , T ) . S ⊂ Rds is the state space , A ⊂ Rda is the action space . R : S × A → R is the reward function that maps a state and action pair to a real-valued reward . P ( s′|s , a ) : S × A × S → R+ is the transition probability from a state and action pair s , a to the next state s′ . γ ∈ [ 0 , 1 ] is the discount factor . d0 denotes the distribution of the initial state s0 . At time step t , the agent receives a state st 1 and takes an action at according to a policy π ( ·|s ) that maps the state to a probability distribution over the action space . The environment transitions to the next state st+1 ∼ P ( ·|st , at ) and gives a reward rt = R ( st , at ) to the agent 2 . The return Gt = ∑T i=0 γ irt+i , is the sum of discounted reward within an episode length of T . The agent aims to find a policy π that maximizes the expected return . We denote the learned model in MBRL as fω ( ·|s , a ) , which is parameterized by ω and approximates P ( ·|s , a ) . Planning with the Cross Entropy Method Planning in MBRL is about leveraging the model to find the best action in terms of its return . Model-Predictive-Control ( MPC ) performs online planning at each time step up to a horizon to find the optimal action sequence : πMPC ( st ) = arg max at : t+H−1 E [ ΣH−1i=0 γ ir ( st+i , at+i ) + γ HV ( sH ) ] ( 1 ) whereH is the planning horizon , at : t+H−1 denotes the action sequence from time step t to t+H−1 , and V ( sH ) is the terminal value function at the end of the planning horizon . The first action in this sequence is executed and the rest are discarded . The agent then re-plans at the next time step . The Cross-Entropy Method ( CEM ) is a gradient-free optimization method that can be used for solving Eq . ( 1 ) . The workflow is shown in Fig . 2 . CEM planning starts by generating N samples { τj } Nj=1 = { ( âj,0 , âj,1 , · · · , âj , H−1 ) } Nj=1 from an initial sampling distribution gφ ( τ ) parameterized 1We assume full observability , i.e. , we assume that the agent has access to the state . 2We assume that the agent receives the true reward . This makes the problem easier but is unfair to MBRL methods that do not assume this . Thus , we will limit comparison to methods that also make this assumption . by φ , where each sample τj is an action sequence from the current time step up to the planning horizon H . The domain of gφ ( τ ) has a dimension of dτ = daH . Using a model f , CEM generates imaginary rollouts based on the action sequence { τj } ( in the case of a stochastic model ) and estimate the associated value v ( τj ) = E [ ΣH−1i=0 γir ( sj , i , aj , i ) ] where sj,0 is the current state s and sj , i+1 ∼ f ( sj , i , aj , i ) . The terminal value γHV ( sj , H ) is omitted here following convention in the CEM planning literature but the MPC performance can be further improved if paired with an accurate value predictor ( Bertsekas , 2005 ; Lowrey et al. , 2019 ) . The sampling distribution is then updated by fitting to the current top-k samples in terms of their value estimates v ( τj ) , using the Maximum Likelihood Estimation ( MLE ) which solves : φ′ = arg max φ N∑ j=1 1 ( v ( τj ) ≥ vth ) log gφ ( τj ) ( 2 ) where vth is the threshold equal to the value of the k-th best sample and 1 ( · ) is the indicator function . In practice , the update to the distribution parameters are smoothed by φl+1 = αφ′+ ( 1−α ) φl where α ∈ [ 0 , 1 ] is a smoothing parameter that balances between the solution to Eq . ( 2 ) and the parameter at the current internal iteration l. CEM repeats this process of sampling and distribution update in an inner-loop , until it reaches the stopping condition . In practice , it is stopped when either a maximum number of iterations has been reached or the parameters have not changed for a few iterations . The output of CEM is an action sequence , typically set as the expectation3 of the most recent sampling distribution for uni-modal distributions such as Gaussians µ̂ = E ( gφ ) = ( â0 , â1 , · · · , âH−1 ) . Choices of Sampling Distributions in CEM A common choice of the sampling distribution is a multivariate Gaussian distribution under which Eq . ( 2 ) has a straight-forward analytical solution . But the uni-modal nature of Gaussian makes it inadequate in solving multi-modal optimization that often occur in MBRL . To increase the capacity of the distribution , a Gaussian Mixture Model ( GMM ) can be used ( Okada & Taniguchi , 2020 ) . We denote such an approach as CEM-GMM . Going forward , we use CEM to refer to the vanilla version that uses a Gaussian distribution . Computationally , the major difference between CEM and CEM-GMM is that the distribution update in CEM-GMM involves solving for more parameters . Detailed steps can be found in Okada & Taniguchi ( 2020 ) . 3 DECENTRALIZED CEM . In this section , we first introduce the formulation of the proposed decentralized approach called the Decentralized CEM ( DecentCEM ) . Then we illustrate the intuition behind the proposed approach using a one-dimensional synthetic multi-modal optimization example where we show the issues of the existing CEM methods and how they can be addressed by DecentCEM . Formulation of DecentCEM DecentCEM is composed of an ensemble of multiple CEM instances indexed by i , each having its own sampling distributions gφi . They can be described by a set of distribution parameters Φ = { φi } Mi=1 . Each instance i manages its own sampling and distribution update by the steps described in Section 2 , independently from other instances . Note that the number of samples and elites are evenly split among the M instances . The top- kM sample sets are decentralized and managed by each instance independently whereas the centralized approach only keeps one set of top-k samples regardless of the distribution family used . After the stopping 3Other options are discussed in Appendix A.2 condition is reached for all instances , the final sampling distribution is taken as the best distribution in the set Φ according to ( the arg max uses a deterministic tie-breaking ) : φDecentCEM = arg max φi∈Φ Eφi [ v ( x ) ] ≈ arg max φi∈Φ N M∑ j=1 v ( τi , j ) ( 3 ) where Eφi [ v ( x ) ] denotes the expectation with respect to the distribution gφi , approximated by the sample mean . When M = 1 , it recovers the conventional CEM method . Motivational Example Consider a one dimensional multi-modal optimization problem shown in Fig.3 ( Left ) . There are eight local optima , including one global optimum f ( x∗ ) = −1.9 where x∗ = 5.146 . This objective function mimics the RL value landscape that has many local optima , as shown by Wang & Ba ( 2020 ) . This optimization problem is “ easy ” in the sense that a grid search over the domain can get us a solution close to the global optimum . However , only our proposed DecentCEM method successfully converges to the global optimum consistently under varying population size ( i.e. , number of samples ) and random runs , as shown in Fig.3 ( Right ) 4 . Both CEM-GMM and the proposed DecentCEM are equipped with multiple sampling distributions . The fact that CEM-GMM is outperformed by DecentCEM may appear surprising . To gain some insights , we illustrate in Fig . 4 how the sampling distribution evolves during the iterative update ( more details in Fig . 9 in Appendix ) . CEM updated the unimodal distribution toward a local optimum despite seeing the global optimum . CEM-GMM appears to have a similar issue . During MLE on the top-k samples , it moved most distribution components towards the same local optimum which quickly lead to mode collapse . On the contrary , DecentCEM successfully escaped the local optima thanks to its independent distribution update over decentralized top-k samples and was able to maintain a decent diversity among the distributions . GMM suits density estimation problems like distribution-based clustering where the samples are drawn from a fixed true distribution that can be represented by multi-modal Gaussians . However , 4For a fair comparison , hyperparameter search has been conducted on all three methods for each population size ( Appendix A ) . in CEM for optimization , exploration is coupled with density estimation : the sampling distribution in CEM is not fixed but rather gets updated iteratively toward the top-k samples . And the “ true ” distribution in optimization puts uniform non-zero densities to the global optima and zero densities everywhere else . When there is a unique global optimum , it degenerates into a Dirac measure that assigns the entire density to the optimum . Density estimation of such a distribution only needs one Gaussian but the exploration is challenging . In other words , the conditions for GMM to work well are not necessarily met when used as the sampling distribution in CEM . CEM-GMM is subject to mode collapse during the iterative top-k greedification , causing premature convergence , as observed in Fig 4 . In comparison , our proposed decentralized approach takes care of the exploration aspect by running multiple CEM instances independently , each performing its own local improvement . This is shown to be effective from this optimization example and the benchmark results in Section 6 . CEM-GMM only consistently converge to the global optimum when we increase the population size to the maximum 1,000 which causes expensive computations . Our proposed DecentCEM runs more than 100 times faster than CEM-GMM at this population size , shown in Table A.3 in Appendix . Convergence of DecentCEM We state the convergence result of DecentCEM in Theorem 3.1 . We show that the previous convergence result of CEM ( Hu et al. , 2011 ) applies to DecentCEM under the same sample budget . The key observation is that the convergence property of each CEM instance still holds since the number of samples in each instance is only changed by a constant factor ( the number of instances ) . We leave the detailed proof to appendix H. Theorem 3.1 ( Convergence of DecentCEM ) . If Assumptions 1-5 hold for a CEM instance described in Algorithm 3 and we decentralize it by evenly dividing its sample sizeNk intoM CEM instances in DecentCEM algorithm that satisfies Assumption 6 , then the sequence of iterates { ηi , k } generated by each CEM instance indexed by i converges almost surely to an internally chain recurrent set ( Hirsch et al. , 2001 ) of Equation 7 . Furthermore , the solution of DecentCEM { ηo , k } converges almost surely to the best solution of the individual instances in terms of the expected value of Em−1 ( η ) [ V ( x ) ] . | This paper studies a novel CEM method for model-based RL. While previous approaches used a centralized method (based on a unimodal Gaussian or Gaussian mixture), they propose a decentralized CEM, where each instance independently tracks its own data and top-k estimates. They first test their new method on a 1D toy task, showing better convergence to the global optimum. They then test their method on several model-based RL tasks, outperforming previous methods in some tasks, while being on par or inferior in others. | SP:91fb34076c936364379e33e7579b5daeccc5c8e9 |
Decentralized Cross-Entropy Method for Model-Based Reinforcement Learning | Cross-Entropy Method ( CEM ) is a popular approach to planning in model-based reinforcement learning . It has so far always taken a centralized approach where the sampling distribution is updated centrally based on the result of a top-k operation applied to all samples . We show that such a centralized approach makes CEM vulnerable to local optima and impairs its sample efficiency , even in a one-dimensional multi-modal optimization task . In this paper , we propose Decentralized CEM ( DecentCEM ) where an ensemble of CEM instances run independently from one another and each performs a local improvement of its own sampling distribution . In the exemplar optimization task , the proposed decentralized approach DecentCEM finds the global optimum much more consistently than the centralized CEM approaches that use either a single or a mixture of Gaussian distributions . Also , we show that DecentCEM is theoretically sound . Further , we extend the decentralized approach to sequential decision-making problems where we show in several continuous control benchmark environments that it provides an effective mechanism to improve the performance of CEM algorithms , under the same sample budget for planning . 1 INTRODUCTION . Model-based reinforcement learning ( MBRL ) uses a model as a proxy of the environment for planning actions in multiple steps . This paper studies planning in MBRL with a specific focus on the Cross-Entropy Method ( CEM ) ( De Boer et al. , 2005 ; Mannor et al. , 2003 ) , which is popular in MBRL due to its ease of use and strong empirical performance ( Chua et al. , 2018 ; Hafner et al. , 2019 ; Wang & Ba , 2020 ; Zhang et al. , 2021 ; Yang et al. , 2020 ) . CEM is a stochastic , derivativefree optimization method . It uses a sampling distribution to generate imaginary trajectories of environment-agent interactions with the model . These trajectories are then ranked based on their returns computed from the rewards given by the model . The sampling distribution is updated to increase the likelihood of producing the top-k trajectories with higher returns . These steps are iterated and eventually yield an improved distribution over the action sequences to guide the action execution in the real environment . Despite the strong empirical performance of CEM for planning , it is prone to two problems : ( 1 ) lower sample efficiency as the dimensionality of solution space increases , and ( 2 ) the Gaussian distribution that is commonly used for sampling may cause the optimization to get stuck in local optima of multi-modal solution spaces commonly seen in real-world problems . Previous works addressing these problems either add gradient-based updates of the samples to optimize the parameters of CEM , or adopt more expressive sampling distributions , such as using Gaussian Mixture Model ( Okada & Taniguchi , 2020 ) or masked auto-regressive neural network ( Hakhamaneshi et al. , 2020 ) . Nevertheless , all CEM implementations to date are limited to a centralized formulation where the ranking step involves all samples . As analyzed below and in Section 3 , such a centralized design makes CEM vulnerable to local optima and impairs its sample efficiency . We propose Decentralized CEM ( DecentCEM ) to address the above problems . Rather than ranking all samples , as in the centralized design , our method distribute the sampling budget across an ensemble of CEM instances . These instances run independently from one another , and each performs a local improvement of its own sampling distribution based on the ranking of its generated samples . The best action is then aggregated by taking an arg max among the solution of the instances . It recovers the conventional CEM when the number of instance is one . We hypothesize that by shifting to this decentralized design , CEM can be less susceptible to premature convergence caused by the centralized ranking step . As illustrated in Fig . 1 , the centralized sampling distribution exhibits a bias toward the sub-optimal solutions near top right , due to the global top-k ranking . This bias would occur regardless of the family of distributions used . In comparison , a decentralized approach could maintain enough diversity thanks to its local top-k ranking in each sampling instance . Through a one-dimensional multi-modal optimization problem in Section 3 , we show that DecentCEM empirically finds the global optimum more consistently than centralized CEM approaches that use either a single Gaussian or a mixture of Gaussian distributions . Also we show that DecentCEM is theoretically sound that it converges almost surely to a local optimum . We further apply DecentCEM to sequential decision making problems and use neural networks to parameterize the sampling distribution in each CEM instance . Empirical results in several continuous control benchmarks suggest that DecentCEM offers an effective mechanism to improve the sample efficiency over the baseline CEM methods under the same sample budget for planning . 2 PRELIMINARIES . We consider a Markov Decision Process ( MDP ) specified by ( S , A , R , P , γ , d0 , T ) . S ⊂ Rds is the state space , A ⊂ Rda is the action space . R : S × A → R is the reward function that maps a state and action pair to a real-valued reward . P ( s′|s , a ) : S × A × S → R+ is the transition probability from a state and action pair s , a to the next state s′ . γ ∈ [ 0 , 1 ] is the discount factor . d0 denotes the distribution of the initial state s0 . At time step t , the agent receives a state st 1 and takes an action at according to a policy π ( ·|s ) that maps the state to a probability distribution over the action space . The environment transitions to the next state st+1 ∼ P ( ·|st , at ) and gives a reward rt = R ( st , at ) to the agent 2 . The return Gt = ∑T i=0 γ irt+i , is the sum of discounted reward within an episode length of T . The agent aims to find a policy π that maximizes the expected return . We denote the learned model in MBRL as fω ( ·|s , a ) , which is parameterized by ω and approximates P ( ·|s , a ) . Planning with the Cross Entropy Method Planning in MBRL is about leveraging the model to find the best action in terms of its return . Model-Predictive-Control ( MPC ) performs online planning at each time step up to a horizon to find the optimal action sequence : πMPC ( st ) = arg max at : t+H−1 E [ ΣH−1i=0 γ ir ( st+i , at+i ) + γ HV ( sH ) ] ( 1 ) whereH is the planning horizon , at : t+H−1 denotes the action sequence from time step t to t+H−1 , and V ( sH ) is the terminal value function at the end of the planning horizon . The first action in this sequence is executed and the rest are discarded . The agent then re-plans at the next time step . The Cross-Entropy Method ( CEM ) is a gradient-free optimization method that can be used for solving Eq . ( 1 ) . The workflow is shown in Fig . 2 . CEM planning starts by generating N samples { τj } Nj=1 = { ( âj,0 , âj,1 , · · · , âj , H−1 ) } Nj=1 from an initial sampling distribution gφ ( τ ) parameterized 1We assume full observability , i.e. , we assume that the agent has access to the state . 2We assume that the agent receives the true reward . This makes the problem easier but is unfair to MBRL methods that do not assume this . Thus , we will limit comparison to methods that also make this assumption . by φ , where each sample τj is an action sequence from the current time step up to the planning horizon H . The domain of gφ ( τ ) has a dimension of dτ = daH . Using a model f , CEM generates imaginary rollouts based on the action sequence { τj } ( in the case of a stochastic model ) and estimate the associated value v ( τj ) = E [ ΣH−1i=0 γir ( sj , i , aj , i ) ] where sj,0 is the current state s and sj , i+1 ∼ f ( sj , i , aj , i ) . The terminal value γHV ( sj , H ) is omitted here following convention in the CEM planning literature but the MPC performance can be further improved if paired with an accurate value predictor ( Bertsekas , 2005 ; Lowrey et al. , 2019 ) . The sampling distribution is then updated by fitting to the current top-k samples in terms of their value estimates v ( τj ) , using the Maximum Likelihood Estimation ( MLE ) which solves : φ′ = arg max φ N∑ j=1 1 ( v ( τj ) ≥ vth ) log gφ ( τj ) ( 2 ) where vth is the threshold equal to the value of the k-th best sample and 1 ( · ) is the indicator function . In practice , the update to the distribution parameters are smoothed by φl+1 = αφ′+ ( 1−α ) φl where α ∈ [ 0 , 1 ] is a smoothing parameter that balances between the solution to Eq . ( 2 ) and the parameter at the current internal iteration l. CEM repeats this process of sampling and distribution update in an inner-loop , until it reaches the stopping condition . In practice , it is stopped when either a maximum number of iterations has been reached or the parameters have not changed for a few iterations . The output of CEM is an action sequence , typically set as the expectation3 of the most recent sampling distribution for uni-modal distributions such as Gaussians µ̂ = E ( gφ ) = ( â0 , â1 , · · · , âH−1 ) . Choices of Sampling Distributions in CEM A common choice of the sampling distribution is a multivariate Gaussian distribution under which Eq . ( 2 ) has a straight-forward analytical solution . But the uni-modal nature of Gaussian makes it inadequate in solving multi-modal optimization that often occur in MBRL . To increase the capacity of the distribution , a Gaussian Mixture Model ( GMM ) can be used ( Okada & Taniguchi , 2020 ) . We denote such an approach as CEM-GMM . Going forward , we use CEM to refer to the vanilla version that uses a Gaussian distribution . Computationally , the major difference between CEM and CEM-GMM is that the distribution update in CEM-GMM involves solving for more parameters . Detailed steps can be found in Okada & Taniguchi ( 2020 ) . 3 DECENTRALIZED CEM . In this section , we first introduce the formulation of the proposed decentralized approach called the Decentralized CEM ( DecentCEM ) . Then we illustrate the intuition behind the proposed approach using a one-dimensional synthetic multi-modal optimization example where we show the issues of the existing CEM methods and how they can be addressed by DecentCEM . Formulation of DecentCEM DecentCEM is composed of an ensemble of multiple CEM instances indexed by i , each having its own sampling distributions gφi . They can be described by a set of distribution parameters Φ = { φi } Mi=1 . Each instance i manages its own sampling and distribution update by the steps described in Section 2 , independently from other instances . Note that the number of samples and elites are evenly split among the M instances . The top- kM sample sets are decentralized and managed by each instance independently whereas the centralized approach only keeps one set of top-k samples regardless of the distribution family used . After the stopping 3Other options are discussed in Appendix A.2 condition is reached for all instances , the final sampling distribution is taken as the best distribution in the set Φ according to ( the arg max uses a deterministic tie-breaking ) : φDecentCEM = arg max φi∈Φ Eφi [ v ( x ) ] ≈ arg max φi∈Φ N M∑ j=1 v ( τi , j ) ( 3 ) where Eφi [ v ( x ) ] denotes the expectation with respect to the distribution gφi , approximated by the sample mean . When M = 1 , it recovers the conventional CEM method . Motivational Example Consider a one dimensional multi-modal optimization problem shown in Fig.3 ( Left ) . There are eight local optima , including one global optimum f ( x∗ ) = −1.9 where x∗ = 5.146 . This objective function mimics the RL value landscape that has many local optima , as shown by Wang & Ba ( 2020 ) . This optimization problem is “ easy ” in the sense that a grid search over the domain can get us a solution close to the global optimum . However , only our proposed DecentCEM method successfully converges to the global optimum consistently under varying population size ( i.e. , number of samples ) and random runs , as shown in Fig.3 ( Right ) 4 . Both CEM-GMM and the proposed DecentCEM are equipped with multiple sampling distributions . The fact that CEM-GMM is outperformed by DecentCEM may appear surprising . To gain some insights , we illustrate in Fig . 4 how the sampling distribution evolves during the iterative update ( more details in Fig . 9 in Appendix ) . CEM updated the unimodal distribution toward a local optimum despite seeing the global optimum . CEM-GMM appears to have a similar issue . During MLE on the top-k samples , it moved most distribution components towards the same local optimum which quickly lead to mode collapse . On the contrary , DecentCEM successfully escaped the local optima thanks to its independent distribution update over decentralized top-k samples and was able to maintain a decent diversity among the distributions . GMM suits density estimation problems like distribution-based clustering where the samples are drawn from a fixed true distribution that can be represented by multi-modal Gaussians . However , 4For a fair comparison , hyperparameter search has been conducted on all three methods for each population size ( Appendix A ) . in CEM for optimization , exploration is coupled with density estimation : the sampling distribution in CEM is not fixed but rather gets updated iteratively toward the top-k samples . And the “ true ” distribution in optimization puts uniform non-zero densities to the global optima and zero densities everywhere else . When there is a unique global optimum , it degenerates into a Dirac measure that assigns the entire density to the optimum . Density estimation of such a distribution only needs one Gaussian but the exploration is challenging . In other words , the conditions for GMM to work well are not necessarily met when used as the sampling distribution in CEM . CEM-GMM is subject to mode collapse during the iterative top-k greedification , causing premature convergence , as observed in Fig 4 . In comparison , our proposed decentralized approach takes care of the exploration aspect by running multiple CEM instances independently , each performing its own local improvement . This is shown to be effective from this optimization example and the benchmark results in Section 6 . CEM-GMM only consistently converge to the global optimum when we increase the population size to the maximum 1,000 which causes expensive computations . Our proposed DecentCEM runs more than 100 times faster than CEM-GMM at this population size , shown in Table A.3 in Appendix . Convergence of DecentCEM We state the convergence result of DecentCEM in Theorem 3.1 . We show that the previous convergence result of CEM ( Hu et al. , 2011 ) applies to DecentCEM under the same sample budget . The key observation is that the convergence property of each CEM instance still holds since the number of samples in each instance is only changed by a constant factor ( the number of instances ) . We leave the detailed proof to appendix H. Theorem 3.1 ( Convergence of DecentCEM ) . If Assumptions 1-5 hold for a CEM instance described in Algorithm 3 and we decentralize it by evenly dividing its sample sizeNk intoM CEM instances in DecentCEM algorithm that satisfies Assumption 6 , then the sequence of iterates { ηi , k } generated by each CEM instance indexed by i converges almost surely to an internally chain recurrent set ( Hirsch et al. , 2001 ) of Equation 7 . Furthermore , the solution of DecentCEM { ηo , k } converges almost surely to the best solution of the individual instances in terms of the expected value of Em−1 ( η ) [ V ( x ) ] . | The paper proposes DecentCEM which uses parallel instances of CEM to learn optimal policies for problems that contain multi-modal optimal actions. Instead of using a single policy as sampling distribution and optimizing the actions in the vicinity of this action trajectory, the DecentCEM method uses parallel with multiple policies and cem optimizers. Therefore, the proposed algorithm can learn multi-modal actions and should improve sample efficiency. The algorithm is evaluated on the standard OpenAI benchmark tasks. | SP:91fb34076c936364379e33e7579b5daeccc5c8e9 |
An Unconstrained Layer-Peeled Perspective on Neural Collapse | 1 INTRODUCTION . Deep learning has achieved state-of-the-art performance in various applications ( LeCun et al. , 2015 ) , such as computer vision ( Krizhevsky et al. , 2012 ) , natural language processing ( Brown et al. , 2020 ) , and scientific discovery ( Long et al. , 2018 ; Zhang et al. , 2018 ) . Despite the empirical success of deep learning , how gradient descent or its variants lead deep neural networks to be biased towards solutions with good generalization performance on the test set is still a major open question . To develop a theoretical foundation for deep learning , many studies have investigated the implicit bias of gradient descent in different settings ( Li et al. , 2018 ; Amari et al. , 2020 ; Vaswani et al. , 2020 ; Soudry et al. , 2018 ; Lyu & Li , 2019 ; Arora et al. , 2019 ) . It is well acknowledged that well-trained end-to-end deep architectures can effectively extract features relevant to a given label . Although theoretical analysis of deep learning has been successful in recent years ( Arora et al . ; Goldblum et al. , 2019 ) , most of the studies that aim to analyze the properties of the final output function fail to understand the features learned by neural networks . Recently , in Papyan et al . ( 2020 ) , the authors observed that the features in the same class will collapse to their mean and the mean will converge to an equiangular tight frame ( ETF ) during the terminal phase of training , that is , the stage after achieving zero training error . This phenomenon , namely , neural collapse ( Papyan et al. , 2020 ) , provides a clear view of how the last-layer features in the neural network evolve after interpolation and enables us to understand the benefit of training after achieving zero training error to achieve better performance in terms of generalization and robustness . To theoretically analyze the neural collapse phenomenon , Fang et al . ( 2021 ) proposed the layer-peeled model ( LPM ) as a simple surrogate for neural networks , where the last-layer features are modeled as free optimization variables . In particular , in a balanced K-class classification problem using a neural network with d neurons in the last hidden layer , the LPM takes the following form : min W , H 1 n n∑ i=1 L ( Whi , yi ) , s.t . 1 2 ||W ||2F ≤ C1 , 1 2 ||H||2F ≤ C2 , ( 1.1 ) where C1 , C2 are positive constants . Here , W = [ w1 , w2 , · · · , wK ] > ∈ RK×d is the weight of the final linear classifier , H = [ h1 , h2 , · · · , hn ] ∈ Rd×n is the feature of the last layer and yi is the corresponding label . The intuition behind the LPM is that modern deep networks are often highly over-parameterized , with the capacity to learn any representations of the input data . It has been shown that an equiangular tight frame ( ETF ) , i.e. , feature with neural collapse , is the only global optimum of the LPM objective ( 1.1 ) ( Fang et al. , 2021 ; Lu & Steinerberger , 2020 ; Wojtowytsch & E , 2020 ; Zhu et al. , 2021 ) . However , feature constraints in LPMs are not equivalent to weight decay used in practice . In this study , we directly deal with the unconstrained model and show that gradient flow can find those neural collapse solutions without the help of explicit constraints and regularization . To do this , we build a connection between the neural collapse and recent theories on max-margin implicit regularization ( Lyu & Li , 2019 ; Wei et al. , 2018 ) , and use it to provide a convergence result to the first-order stationary point of a minimum-norm separation problem . Furthermore , we illustrate that the crossentropy loss enjoys a benign global landscape where all the critical points are strict saddles in the tangent space , except for the only global minimizers that exhibit the neural collapse phenomenon . Finally , we verify our insights via empirical experiments . In contrast to previous theoretical works on neural collapse , our analysis does not incorporate any explicit regularization or constraint on features . A comparison with other results can be found in Table 1 and we defer a detailed discussion to Section 5.2 . The reasons we investigate the unregularized objective are summarized as follows : 1 . Feature regularization or constrain is still not equivalent to weight decay used in practice . However , previous studies have justified that neural networks continue to perform well without any regularization or constraint ( Zhang et al. , 2021 ) . Moreover , it is proved that SGD with exponential learning rate on unconstrained objective is equivalent to SGD with weight decay . ( Li & Arora , 2019 ) . 2 . As shown in this study , neural collapse exists even under an unconstrained setting , which implies the emergence of neural collapse should be attributed to gradient descent and cross-entropy loss rather than explicit regularization . 3 . Regularization or constraint feature constraint can be barriers for existing theories of neural networks ( Jacot et al. , 2018 ; Lyu & Li , 2019 ) . By allowing features to be totally free , we hope our results can inspire further analysis to plug in a realistic neural network . 1.1 CONTRIBUTIONS . The contributions of the present study can be summarized as follows . • We build a relationship between the max-margin analysis ( Soudry et al. , 2018 ; Nacson et al. , 2019b ; Lyu & Li , 2019 ) and the neural collapse and provide the implicit bias analysis to the feature rather than the output function . Although both parameters and features diverge to infinity , we prove that the convergent direction is along the direction of the minimum-norm separation problem . • Previous works ( Lyu & Li , 2019 ; Ji et al. , 2020 ) only prove that gradient flow on homogeneous neural networks will converge to the KKT point of the corresponding minimum-norm separation problem . However , the minimum-norm separation problem remains a highly non-convex problem and a local KKT point may not be the neural collapse solution . In this study , we perform a more detailed characterization of the convergence direction via landscape analysis . • Previous analysis about neural collapse relies on the explicit regularization or constraint . In this study , we show that the implicit regularization effect of gradient flow is sufficient to lead to a neural collapse solution . The emergence of neural collapse should be attributed to gradient descent and loss function , rather than explicit regularization or constraint . We put detailed discussion in Section 5.2 . 1.2 RELATED WORKS . Implicit Bias of Gradient Descent : To understand how gradient descent or its variants helps deep learning to find solutions with good generalization performance on the test set , a recent line of research have studied the implicit bias of gradient descent in different settings . For example , gradient descent is biased toward solutions with smaller weights under ` 2 loss ( Li et al. , 2018 ; Amari et al. , 2020 ; Vaswani et al. , 2020 ) and will converge to large margin solution while using logistic loss ( Soudry et al. , 2018 ; Nacson et al. , 2019b ; Lyu & Li , 2019 ; Chizat & Bach , 2020 ; Ji et al. , 2020 ) . For linear networks , Arora et al . ( 2019 ) ; Razin & Cohen ( 2020 ) ; Gidel et al . ( 2019 ) have shown that gradient descent determines a low-rank approximation . Loss Landscape Analysis : Although the practical optimization problems encountered in machine learning are often nonconvex , recent works have shown the landscape can enjoy benign properties which allow further analysis . In particular , these landscapes do not exhibit spurious local minimizers or flat saddles and can be easily optimized via gradient-based methods ( Ge et al. , 2015 ) . Examples include phase retrieval ( Sun et al. , 2018 ) , low-rank matrix recovery ( Ge et al. , 2016 ; 2015 ) , dictionary learning ( Sun et al. , 2016 ; Qu et al. , 2019 ; Laurent & Brecht , 2018 ) and blind deconvolution ( Lau et al. , 2019 ) . 2 PRELIMINARIES AND PROBLEM SETUP . In this paper , || · ||F denotes the Frobenius norm , ‖ · ‖2 denotes the matrix spectral norm , ‖ · ‖∗ denotes the nuclear norm , ‖ · ‖ denotes the vector l2 norm and tr ( · ) is the trace of matrices . We use [ K ] : = { 1 , 2 , · · · , K } to denote the set of indices up to K . 2.1 PRELIMINARIES . We consider a balanced dataset with K classes ⋃K k=1 { xk , i } ni=1 . A standard fully connected neural network can be represented as : f ( x ; Wfull ) = bL + WLσ ( bL−1 + WL−1σ ( · · ·σ ( b1 + W1x ) ) ) . ( 2.1 ) Here Wfull = ( W1 , W2 , · · · , WL ) denote the weight matrices in each layer , ( b1 , b2 , · · · , bL ) denote the bias terms , and σ ( · ) denotes the nonlinear activation function , for example , ReLU or sigmoid . Let hk , i = σ ( bL−1 + WL−1σ ( · · ·σ ( b1 + W1xk , i ) ) ) ∈ Rd denote the last layer feature for data xk , i and h̄k = 1n ∑n i=1 hk , i denotes the feature mean within the k-th class . To provide a formal definition of neural collapse , we first introduce the concept of a simplex equiangular tight frame ( ETF ) : Definition 2.1 ( Simplex ETF ) . A symmetric matrix M ∈ RK×K is said to be a simplex equiangular tight frame ( ETF ) if M = √ K K − 1 Q ( IK − 1 K 1K1 > K ) . ( 2.2 ) Where Q ∈ Rd×K is a matrix with orthogonal columns . Let W ∈ RK×d = WL = [ w1 , w2 , · · · , wK ] > be the weight of the final layer classifier , the four criteria of neural collapse can be formulated precisely as : • ( NC1 ) Variability collapse : As training progresses , the within-class variation of the activation becomes negligible as these activation collapse to their class mean h̄k = 1n ∑n i=1 hk , i . ||hk , i − h̄k|| = 0 , 1 ≤ k ≤ K. • ( NC2 ) Convergence to Simplex ETF : The vectors of the class-means ( after centering by their global-mean ) converge to having equal length , forming equal-size angles between any given pair , and being the maximally pairwise-distanced configuration constrained to the previous two properties . cos ( h̄k , h̄j ) = − 1 K − 1 , ||h̄k|| = ||h̄j || , k 6= j . • ( NC3 ) Convergence to self-duality : The linear classifiers and class-means will converge to align with each other , up to appropriate rescaling , that is , there exist a universal constant C > 0 such that wk = Ch̄k , k ∈ [ K ] . • ( NC4 ) Simplification to Nearest Class-Center For a given deepnet activation : h = σ ( bL−1 + WL−1σ ( · · ·σ ( b1 + W1x ) ) ) ∈ Rd , the network classifier converges to choose whichever class has the nearest train class-mean arg min k 〈wk , h〉 → arg min k ∥∥h− h̄k∥∥ , In this paper , we say that a point W ∈ RK×d , H ∈ Rd×nK satisfies the neural collapse conditions or is a neural collapse solution if the above four criteria are all satisfied for ( W , H ) . | This paper analyzes the phenomenon of neural collapse from the simplified perspective of an unconstrained features models, whereby the only two optimization variables in the model are the last layer classifier and features, which are fit to some labels by minimizing the cross entropy loss. The authors leverage their observation that maximizing the margin results in a model achieving neural collapse, and then study the corresponding problem of minimum-norm classifier, and show that gradient flow converges directionally to the neural collapse solution. The authors then show that the optimization landscape is benign, in that all critical points that are not global minimum have a decreasing direction in the tangent space. | SP:89b85b963a0f6f156f21ae313d5b5c58db082a14 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.