Add files using upload-large-folder tool

md/train/BfPzZSype5M/BfPzZSype5M.md

@@ -0,0 +1,262 @@
+# RMM: Reinforced Memory Management for Class-Incremental Learning
+
+Yaoyao Liu1 Bernt Schiele1 Qianru Sun2
+
+1Max Planck Institute for Informatics, Saarland Informatics Campus 2School of Computing and Information Systems, Singapore Management University {yaoyao.liu, schiele}@mpi-inf.mpg.de qianrusun@smu.edu.sg
+
+# Abstract
+
+Class-Incremental Learning (CIL) [40] trains classifiers under a strict memory budget: in each incremental phase, learning is done for new data, most of which is abandoned to free space for the next phase. The preserved data are exemplars used for replaying. However, existing methods use a static and ad hoc strategy for memory allocation, which is often sub-optimal. In this work, we propose a dynamic memory management strategy that is optimized for the incremental phases and different object classes. We call our method reinforced memory management (RMM), leveraging reinforcement learning. RMM training is not naturally compatible with CIL as the past, and future data are strictly non-accessible during the incremental phases. We solve this by training the policy function of RMM on pseudo CIL tasks, e.g., the tasks built on the data of the 0-th phase, and then applying it to target tasks. RMM propagates two levels of actions: Level-1 determines how to split the memory between old and new classes, and Level-2 allocates memory for each specific class. In essence, it is an optimizable and general method for memory management that can be used in any replaying-based CIL method. For evaluation, we plug RMM into two top-performing baselines (LUCIR $^ +$ AANets and POD $+ .$ AANets [30]) and conduct experiments on three benchmarks (CIFAR-100, ImageNet-Subset, and ImageNet-Full). Our results show clear improvements, e.g., boosting POD $+ .$ AANets by $3 . 6 \%$ , $4 . 4 \%$ , and $1 . 9 \%$ in the 25-Phase settings of the above benchmarks, respectively. The code is available at https://class-il.mpi-inf.mpg.de/rmm/.
+
+# 1 Introduction
+
+Ideally, AI systems should be adaptive to ever-changing environments—where the data are continuously observed by sensors. Their models should be capable of learning new concepts from data while maintaining the ability to recognize previous ones. In practice, the systems often have constrained memory budgets because of which most of the historical data have to be abandoned [20]. However, deep-learning-based AI systems, when continuously updated using new data and limited historical data, often suffer from catastrophic forgetting, as the updates can override knowledge acquired from previous data [33, 34, 39].
+
+To encourage research on the forgetting problem, Rebuffi et al. [40] defined a standard protocol of class-incremental learning (CIL) for image classification, where the training data of different object classes come in phases. In each phase, the classifier is evaluated on all classes observed so far. As the total memory size is limited [40], CIL systems abandon the majority of the data and only preserve a small number of exemplars, e.g., 20 exemplars per class, which will be used for replaying in subsequent phases. Replaying usually happens for multiple epochs [13, 18, 30, 40], so both the old class exemplars and new class data need to be stored in the limited memory. Existing CIL methods allocate memory between the old and new classes in an arbitrary and static fashion, e.g., 20 per old class vs. 1, 300 per new class for the ImageNet-Full dataset. This causes a serious imbalance between the old and new classes and can exacerbate the problem of catastrophic forgetting.
+
+![](images/fb925de9131e5e29d0397072250f83a2fbcecb9ae91b493cab1ae5477fb7b21f.jpg)  
+Figure 1: (a) Existing CIL methods [18, 30, 40] allocate memory between old and new classes in an arbitrary and frozen way, causing the data imbalance between old and new classes and exacerbating the catastrophic forgetting of old knowledge in the learned model. (b) Our proposed method— Reinforced Memory Management (RMM)—is able to learn the optimal and class-specific memory sizes in different incremental phases. Please note we use orange, blue, and green dots to denote the samples observed in the (i-1)-th, $i$ -th, and $( i { + } 1 )$ -th phases, respectively.
+
+To address this, we propose to learn an optimal memory management policy for each incremental phase with continuously reinforced model performance and call our method reinforced memory management (RMM). Detailed actions include 1) allocating the memory between the existing (old) and the coming (new) data for each phase, and 2) specifying the memory for each old class according to its recognition difficulty before abandoning any of its data. To this end, we leverage reinforcement learning [26–28, 51, 59] and design a new policy function to contain two sub-functions that propagate two levels of actions in a hierarchical way. Level-1 function determines how to split memory between the old and new data. Its output action is then inputted into the Level-2 function to determine how to allocate memory for each old class. The overall objective of the function is to maximize the cumulative evaluation accuracy across all incremental phases. However, this is not naturally compatible with the standard protocol of CIL [40] where neither past nor future data are accessible for evaluation. To tackle this issue, we propose to pre-train the function on pseudo CIL tasks and then adopt it in the learning process of our target task. In principle, we can build such pseudo tasks using any available categorical data, e.g., the data in the 0-th phase of the target CIL task or the data from another dataset. Even though this is a non-stationary reinforcement learning problem, we can regard the pseudo and target CIL tasks as a sequence of stationary tasks and train the policy function to exploit the dependencies between these consecutive tasks. Such continuous adaptation in non-stationary environments is feasible based on the empirical analysis given in [2].
+
+Technically, we propose the following method to guarantee the transferability of policy functions between pseudo and target CIL tasks. We take a Level-1 action based on the ratio of the number of new classes to the total number of classes observed so far. A lower (higher) ratio will result in weakening the stability (plasticity) of the classification model. Then, we take a Level-2 action for each individual class conditioned on both the Level-1 action and the training entropy of that class. A higher entropy denotes a more difficult class, leading to more memory allocated to the class. For evaluation, we conduct extensive CIL experiments by plugging RMM into two top-performing methods (LUCIR $+ .$ AANets, POD $^ { + }$ AANets) and testing them on three benchmarks (CIFAR-100, ImageNet-Subset, and ImageNet-Full). Our results show the clear and consistent superiority of RMM, e.g., it boosts the state-of-the-art POD $+$ AANets by $3 . 6 \%$ , $4 . 4 \%$ , and $1 . 9 \%$ in the 25-Phase settings of the above benchmarks, respectively.
+
+Our technical contribution is three-fold. 1) A hierarchical reinforcement learning algorithm called RMM to manage the memory in a way that can be conveniently modified through incremental phases and for different classes. 2) A pseudo task generation strategy that requires only in-domain available data (small-scale) or cross-domain datasets (large-scale), relieving the data incompatibility between reinforcement learning and class-incremental learning. 3) Extensive experiments, visualization, and interpretation for RMM in three CIL benchmarks and using two top models as baselines.
+
+# 2 Related Work
+
+Incremental Learning [22, 36, 48, 53, 58] continuously updates the model using data coming in a sequence of phases. Similar tasks are also referred to as continual learning [12, 32] and lifelong learning [3, 9]. Recent papers are either task-incremental learning—each phase corresponds to a task (dataset) that contains new data of all seen classes [7, 10, 19, 29, 43, 47, 57], or classincremental learning (CIL)—each phase contains data of a new set of classes, i.e., classes are unseen [4, 6, 18, 25, 31, 37, 40, 41, 49, 52, 55–57]. This paper is concerned with CIL. The key challenge of CIL is the forgetting problem—older classes are forgotten in later phases. Existing methods tackling this can be divided into three categories: memory-based, regularization-based, and network-architecture-based [11, 35]. Memory-based methods preserved a small subset of the old class data (exemplars) to replay the model on them (together with the new class data), in order to relieve the forgetting of the old classes. Some work [18, 40] proposed heuristic strategies to select more representative exemplars from the old class data, and others [31, 47] tried to generate exemplars in optimizable frameworks. None of them changed the allocation of memory for different classes, i.e., all used an arbitrary and static scheme for memory allocation. Regularization-based methods introduce regularization terms in the loss function to consolidate previous knowledge when training the model on new data. The key idea is to enforce predicted label logits [29, 40], features maps [13, 18], or the topology in the feature space [49] of the new model to be close to that of the previous model. Network-architecture-based methods aim to design “incremental network architectures”. Some work [45, 54] gradually extended the network capacity for new data, while others proposed to freeze partial network parameters [1, 30] to preserve the knowledge of the old classes.
+
+Reinforcement Learning defines an agent that needs to decide its actions in an unknown environment by maximizing the expected cumulative reward. It has been widely applied to many optimization problems, e.g., neural architecture search [54, 59] and neural machine translation [38, 46]. Reinforcement learning has also been introduced to solve incremental learning problems. Xu et al. [54] proposed to increase convolution filters once a new task arrives and optimize the increased number by reinforcement learning. Gao et al. [14] proposed an improved version that makes the minimal expansion of the network, reducing memory and computing overheads. Veniat et al. [50] introduced a modular architecture, where each module represents a different atomic skill, and used the REINFORCE algorithm [51] to optimize it. Huang et al. [21] combined reinforcement learning with Net2Net [8] and designed a NAS-based CIL method. In our work, we also use the REINFORCE algorithm [51], but differ in three aspects. First, we are the first to optimize memory allocation for CIL in a reinforced way. Second, we learn the policy functions on generated pseudo CIL tasks, where we can access both past, and future data (for each incremental phase) and thus are able to compute the cross-phase (long-term) rewards. In contrast, the related work [14, 54] could use only current-phase data to estimate a short-term reward. Third, our reinforcement learning has a hierarchical structure that specially fits the nature of the data stream in the CIL settings.
+
+# 3 Preliminaries
+
+Class-Incremental Learning (CIL) usually assumes $( N { + } 1 )$ learning phases: an initial phase and $N$ incremental phases during which the number of classes gradually increases till the maximum [13, 18, 20, 31]. We assume that total memory $\mathcal { M }$ is bounded and fixed for all incremental phases [40]. $\mathcal { M }$ is used to store the exemplars and new coming data as both kinds of data need to be loaded repeatedly during training epochs. In the initial (0-th) phase, data $\mathcal { D } _ { 0 }$ , containing the training samples of $\mathcal { C } _ { 0 }$ classes, are used to learn the initial classification model $\Theta _ { 0 }$ . In the $i$ -th incremental phase, we split $\mathcal { M }$ into two dynamic partitions: the exemplar memory $\mathcal { M } _ { \mathrm { o l d } }$ and new data memory $M _ { \mathrm { n e w } }$ . We select $\mathcal { E } _ { t }$ as representative samples of the data seen in the $t$ -th phase, and denote total exemplars $\mathcal { E } _ { 0 } \sim \mathcal { E } _ { i - 1 }$ shortly as $\mathcal { E } _ { 0 : i - 1 }$ . We save $\mathcal { E } _ { 0 : i - 1 }$ into $\mathcal { M } _ { \mathrm { o l d } }$ and free $M _ { \mathrm { n e w } }$ . Then, we observe new data that contain $\mathcal { C } _ { i }$ new classes. We randomly load new data into $M _ { \mathrm { n e w } }$ until $M _ { \mathrm { n e w } }$ is full, and all the other new data are discarded. We denote the loaded new data as $\mathcal { D } _ { i }$ . Then, we initialize $\Theta _ { i }$ with $\Theta _ { i - 1 }$ , and train it using $\mathcal { E } _ { 0 : i - 1 } \cup \mathcal { D } _ { i }$ . The resulting model $\Theta _ { i }$ will be evaluated with a test set containing all classes observed so far. We repeat this training and testing, and report the average accuracy across all phases.
+
+Reinforcement Learning $\mathbf { \left( R L \right) }$ aims to learn an optimal policy function $\pi$ for an agent interacting in an unknown environment [51, 54, 59]. In the CIL scenario, in each incremental phase, the agent observes the current state $s _ { i }$ from the environment, and then takes an action $a _ { i }$ (how to allocate memory) according to the policy function $\pi ( a _ { i } | s _ { i } )$ . Subsequently, the environment is updated to a new state $s _ { i + 1 }$ and the reward $r _ { i }$ is calculated to optimize the parameters of $\pi ( a _ { i } | s _ { i } )$ through cumulative reward back-propagation. Specifically, the learning objective of $\begin{array} { r } { R _ { i } ^ { ' } = \sum _ { t = i } ^ { \infty } \dot { \gamma } ^ { t - i } r _ { t } } \end{array}$ , where $\gamma \in [ 0 , 1 )$ i i is a discounting factor that determines the $\pi ( a _ { i } | s _ { i } )$ is to maximize the expected weights of future rewards. Please note that in our case, theproblem [15, 59], so we remove the discounting factor and $( N { + } 1 )$ $\textstyle R = \sum _ { t = 0 } ^ { N } r _ { t }$ task is a finite horizon, which is actually the cumulative validation accuracy of all training CIL tasks. In Section 4, we discuss the proposed RL algorithm for memory allocation and how to generate pseudo tasks for training its policy function.
+
+# 4 Reinforced Memory Management (RMM)
+
+Our RMM approach learns policy functions that propagate two levels of actions in a hierarchical way, specially designed for CIL. As illustrated in Figure 1 (b), Level-1 determines the memory split between exemplars and new data, and Level-2 allocates the memory for each individual class. We motivate and introduce the formulation of RMM, including the definitions of states, actions, rewards, and hierarchical policy functions in Section 4.1. In Section 4.2, we detail the steps of creating pseudo CIL tasks on which we learn the policy functions. In Section 4.3, we summarize the algorithm.
+
+# 4.1 Formulation
+
+In the $i$ -th incremental phase CIL, we manage the memory for two kinds of data: exemplars $\mathcal { E } _ { 0 : i - 1 }$ and new data $\mathcal { D } _ { i }$ . For the former, we have access to their images and labels so we can allocate a different memory size to a different class, e.g., based on its recognition difficulty. For the latter, we do not have such access before loading the data (otherwise, causing a violation to the CIL protocol), so we are only able to learn a total memory size, i.e., the memory size for all new classes (and then split it evenly for each individual class). Therefore, the memory management in CIL settings is inherently hierarchical: 1) coarse memory allocation between exemplars and new data; and then 2) fine-grained memory allocation among specific classes. To this end, we modify the standard reinforcement learning into a hierarchical structure.
+
+As illustrated in Figure 2 (a), in the $i$ -th incremental phase of CIL (i.e., the environment), the argent receives a state value $s _ { i }$ . Level-1 policy $\pi _ { \eta }$ takes $s _ { i }$ as the input to produce an action $a _ { i } ^ { [ 1 ] } \sim \pi _ { \eta } ( s _ { i } )$ $a _ { i } ^ { [ 1 ] }$ determines how to split memory between the exemplars and new data. After that, Level-2 policy $\pi _ { \phi }$ takes $s _ { i }$ and $a _ { i } ^ { [ 1 ] }$ as inputs to produce the second action $a _ { i } ^ { [ 2 ] } \sim \pi _ { \phi } ( s _ { i } , a _ { i } ^ { [ 1 ] } )$ that distributes the exemplar memory for each individual class.
+
+States, defined for our CIL settings, should have two properties. 1) Being transferable between CIL tasks, e.g., from a small-scale CIL task including 50 classes (in total) to a large one including 100 classes. The reason is that we need to transfer the policy functions learned from pseudo CIL tasks (defined in Section 4.2) to the target task. The states, the inputs of policy functions, should also be transferable. 2) Being distinct in each incremental phase. This is to enable the state variable to represent a specific forgetting or data imbalance degree at each different learning phase of the CIL model. To fulfill these properties, we formulate the state in the $i$ -th phase as $\begin{array} { r } { s _ { i } = \left( \frac { \mathcal { C } _ { i } } { \sum _ { t = 0 } ^ { i - 1 } \mathcal { C } _ { t } } , \frac { | \mathcal { M } _ { \mathrm { o l d } } | } { | \mathcal { M } | } \right) } \end{array}$ , where $\mathcal { C } _ { i }$ denotes the number of classes in $\mathcal { D } _ { i }$ , $\mathcal { M } _ { \mathrm { o l d } }$ denotes the memory allocated to exemplars $\mathcal { E } _ { 0 : i - 1 }$ , and $\mathcal { M }$ is the total memory.
+
+Level-1 Actions. In the 1-st incremental phase, our Level-1 policy function produces an action to allocate the memory for exemplars ${ \mathcal { E } } _ { 0 }$ and new data $\mathcal { D } _ { 1 }$ . We denote this action as $a _ { 1 } ^ { [ 1 ] }$ and assign its value with the ratio of the number of the exemplars $a _ { 1 } ^ { [ 1 ] } \in ( 0 , 1 )$ . In the $i$ -th phase $( i \geq 2 )$ ), the definition of $| \mathcal { E } _ { 0 } |$ $a _ { i } ^ { [ 1 ] }$ to the memory size is different to $a _ { 1 } ^ { [ 1 ] }$ as it is a relative , so we have change over $a _ { i - 1 } ^ { [ 1 ] }$ . Specifically, $a _ { i } ^ { [ 1 ] }$ is the ratio of increased (if its value is positive) or decreased (if negative) memory size of $\mathcal { M } _ { \mathrm { o l d } }$ compared to the (i-1)-th phase. Using this definition aims for smooth and continuous memory management. In the formulation, the memory sizes of exemplars $\mathcal { E } _ { 0 : i - 1 }$ and new data $\mathcal { D } _ { i }$ are, respectively,
+
+![](images/886c2faf44a43d3c90d5359b5aec1dfe02040e79327a3ff62ea2f7be2ca8882c.jpg)  
+Figure 2: (a) In the $i$ -th phase of the $k$ -th pseudo CIL task, Level-1 policy $\pi _ { \eta }$ takes $s _ { i }$ as the input, and produces action $a _ { i } ^ { [ 1 ] }$ . Level-2 policy $\pi _ { \phi }$ takes $s _ { i }$ and $a _ { i } ^ { [ 1 ] }$ as the inputs, then produces action $a _ { i } ^ { [ 2 ] }$ . (b) For the $k$ -th pseudo CIL task, we allocate memory for $N$ times (i.e., in $N$ phases) using the policies $\pi _ { \eta }$ and $\pi _ { \phi }$ , and compute the cumulative reward $R$ .
+
+$$
+| \mathcal { M } _ { \mathrm { o l d } } | = | \mathcal { E } _ { 0 : i - 1 } | = \sum _ { t = 1 } ^ { i } a _ { t } ^ { [ 1 ] } | \mathcal { M } | , \quad | \mathcal { M } _ { \mathrm { n e w } } | = | \mathcal { D } _ { i } | = \left( 1 - \sum _ { t = 1 } ^ { i } a _ { t } ^ { [ 1 ] } \right) | \mathcal { M } | .
+$$
+
+We set a constrain $a _ { i } ^ { [ 1 ] } \in [ - 0 . 1 , 0 . 1 ]$ for $i \geq 2$ . Otherwise, if $a _ { i } ^ { [ 1 ] }$ is too big, there are not enough exemplars to fill the memory, as most old-class data has been abandoned. If $a _ { i } ^ { [ 1 ] }$ is too small, many exemplars will be permanently deleted in this phase, making it hard or even impossible to adjust $\mathcal { M } _ { \mathrm { o l d } }$ back to a high value in the future phases. If $\textstyle \sum _ { t = 1 } ^ { i } a _ { t } ^ { [ 1 ] } > 1$ , $M _ { \mathrm { n e w } }$ will be negative. So, we force Pit=1 a[1]t $\textstyle \sum _ { t = 1 } ^ { i } a _ { t } ^ { [ 1 ] } \leq 1$ by rejection sampling [5], i.e., using $\pi _ { \eta }$ to output another action until it is feasible to execute. Note that this situation rarely happens in real training, because when $M _ { \mathrm { n e w } }$ becomes very low, $\pi _ { \eta }$ tends to produce an action to increase it.
+
+Level-2 Actions. Here, we elaborate on how to get class-specific memory allocation. In the $( i - 1 )$ -th phase, we split the classes for $\mathcal { D } _ { i - 1 }$ into two groups evenly according to training entropy values: classes with higher values (difficult classes) are in one group and the rest in the other group. Therefore, Level-2 action $a _ { i } ^ { [ 2 ] } \in ( 0 , 1 )$ determines how to split memories between harder and easier classes. During initial experiments, we observed that using two groups already yields improved results and using more groups causes a decrease.
+
+Let $\mathcal { M } _ { j } ^ { A }$ and $\mathcal { M } _ { j } ^ { B }$ denote the memory allocated for the high-entropy and low-entropy groups, respectively, in the $j$ -th phase $( j \le i )$ :
+
+$$
+| \mathcal { M } _ { j } ^ { A } | = a _ { j + 1 } ^ { [ 2 ] } | \mathcal { E } _ { j } | = \frac { a _ { j + 1 } ^ { [ 2 ] } \mathcal { C } _ { j } } { \sum _ { t = 1 } ^ { i } \mathcal { C } _ { t } } | \mathcal { M } _ { \mathrm { o l d } } | , | \mathcal { M } _ { j } ^ { B } | = ( 1 - a _ { j + 1 } ^ { [ 2 ] } ) | \mathcal { E } _ { j } | = \frac { ( 1 - a _ { j + 1 } ^ { [ 2 ] } ) \mathcal { C } _ { j } } { \sum _ { t = 1 } ^ { i } \mathcal { C } _ { t } } | \mathcal { M } _ { \mathrm { o l d } } | .
+$$
+
+Then, we allocate memory evenly to the classes within the group, e.g., if the high-entropy group has 10 classes, each class will have a memory size of $\frac { 1 } { 1 0 } | \mathcal { M } _ { j } ^ { A } |$ .
+
+Rewards. The objective of CIL is that the trained model (in any phase) should be efficient to recognize all classes seen so far. It is intuitive and convenient to use the validation accuracy as the reward in each phase. In the $i$ -th phase, the objective of RMM is to maximize the expected cumulative reward, i.e., $\textstyle R = \sum _ { i = 0 } ^ { N } r _ { i }$ , where $r _ { i }$ denotes the validation accuracy in the $i$ -th phase.
+
+# 4.2 Optimization
+
+In the CIL protocol, it is impossible to see past or future data in any incremental phase. It is thus not intuitive how to compute cumulative rewards till the last phase. We propose to solve the issue by generating pseudo CIL tasks (where all data are accessible).
+
+Pseudo CIL Tasks should meet two requirements: 1) their training and validation data are fully accessible for computing cumulative rewards, and 2) they have the same format (e.g., the same number of phases) of the target CIL task. Data Sources: For requirement 1, an intuitive solution is to use $\mathcal { D } _ { 0 }$ (available in the 0-th phase). Based on the CIL protocol [13, 18, 20, 30], $\mathcal { D } _ { 0 }$ contains half of the classes of the whole dataset, e.g., 50 classes on CIFAR-100, which supplies enough data to build downsized CIL tasks. When building the tasks, we randomly choose $1 0 \%$ training samples of each class (from $\mathcal { D } _ { 0 }$ ) to compose a pseudo validation set (note that we are not allowed to use the original validation set in training). When aiming for larger-scale data in CIL, we can leverage smaller datasets. For example, the pseudo tasks for ImageNet-Subset can be built on the data of CIFAR-100. This is also meaningful to evaluate the transferability of RMM policy functions (discussed in the Ablation Study). Task Generation Protocol is based on requirement 2. If using another dataset, we simply follow its original CIL protocol. If using the data accessed in the 0-th phase (i.e., $\mathcal { D } _ { 0 }$ ), we can reduce the number of classes (in each phase) by half. For example, for CIFAR-100, we use 50-class $\mathcal { D } _ { 0 }$ to generate a 5-phase pseudo CIL task as follows: loading 25 classes in the 0-th phase, and after that, five classes per phase. To generate another pseudo task, we simply change the order of classes.
+
+![](images/2676b7321df9fb589fa15a01c9e469e5666e2b81aca84cfb2d226b35f2b252cb.jpg)  
+Figure 3: Updating $\eta$ and $\phi$ in one epoch. To get stable gradients for $J ( \eta , \phi )$ , we create $K$ different pseudo CIL tasks, and run each task for $Z$ times.
+
+Training. We elaborate the steps of learning Level-1 policy $\pi _ { \eta }$ and Level-2 policy $\pi _ { \phi }$ in the following. The goal is to optimize the parameters $\eta$ and $\phi$ by maximizing the expected cumulative reward $J ( \eta , \phi )$ . We denote any pseudo CIL task and its cumulative reward as $\tau$ and $R$ , respectively, and have,
+
+$$
+J ( \eta , \phi ) = \mathbb { E } _ { T } \mathbb { E } _ { \pi _ { \eta } , \pi _ { \phi } } [ R ] .
+$$
+
+Policy Gradient Estimation. According to the policy gradient theorem [51], we can compute the gradients for $J ( \eta , \phi )$ as follows,
+
+$$
+\nabla _ { \eta , \phi } J ( \eta , \phi ) = \mathbb { E } _ { T } \left[ \sum _ { i = 1 } ^ { N } \mathbb { E } _ { \pi _ { \eta } , \pi _ { \phi } } \big [ \nabla _ { \eta , \phi } \log ( \pi _ { \eta } ( a _ { i } ^ { [ 1 ] } \vert s _ { i } ) \pi _ { \phi } ( a _ { i } ^ { [ 2 ] } \vert s _ { i } , a _ { i } ^ { [ 1 ] } ) ) R \big ] \right] .
+$$
+
+Following the REINFORCE algorithm [51], we replace the expectations $\mathbb { E } \tau [ \cdot ]$ and $\mathbb { E } _ { \pi _ { \eta } , \pi _ { \phi } } [ \cdot ]$ with sample averages using the Monte Carlo method [16]. Specifically, in each epoch, we create $K$ pseudo tasks and run each task for $Z$ times, as shown in Figure 3. Thus we can derive the empirical approximation of $\nabla _ { \eta , \phi } J ( \eta , \phi )$ as,
+
+$$
+\nabla _ { \eta , \phi } J ( \eta , \phi ) = \frac { 1 } { Z K } \sum _ { k = 1 } ^ { K } \sum _ { z = 1 } ^ { Z } \sum _ { i = 1 } ^ { N } \nabla _ { \eta , \phi } \log ( \pi _ { \eta } ( a _ { i } ^ { [ 1 ] } | s _ { i } ) \pi _ { \phi } ( a _ { i } ^ { [ 2 ] } | s _ { i } , a _ { i } ^ { [ 1 ] } ) ) ( R _ { z } ^ { k } - b ) ,
+$$
+
+where $R _ { z } ^ { k }$ denotes the $z$ -th reward for the $k$ -th pseudo task $\mathcal { T } _ { k }$ , and $b$ denotes the baseline function— the moving average of previous rewards. Using this baseline function is a common trick in RL to reduce the variance of estimated policy gradients [23, 42, 59].
+
+Updating Parameters. We update $\eta$ and $\phi$ in each epoch according to the gradient ascent rule [54, 59]:
+
+$$
+\eta : = \eta + \beta _ { 1 } \nabla _ { \eta } J ( \eta , \phi ) , \phi : = \phi + \beta _ { 2 } \nabla _ { \phi } J ( \eta , \phi ) ,
+$$
+
+where $\beta _ { 1 }$ and $\beta _ { 2 }$ are the learning rates. We iterate this update for $m$ epochs in total.
+
+# 4.3 Algorithm
+
+Algorithm 1 summarizes the overall training steps of the proposed RMM. There are four loops in the algorithm: 1) we train the RMM agent for $m$ epochs; 2) we create $K$ pseudo CIL tasks in each epoch; 3) we run each pseudo CIL task for $Z$ times; and 4) there are $N { + 1 }$ learning phases each time. Specifically, Line 3 initializes the parameters of policy functions. Line 6 creates the $k$ -th pseudo CIL task. Line 8 initializes the classification model. Lines 10-16 allocate the memory according to the actions produced by RMM policy. Line 17 loads new data. Lines 18-19 train the classification model and compute the accuracy. Line 20 estimates the $z$ -th cumulative reward. Lines 21-22 compute the gradients and update policy functions.
+
+# 5 Experiments
+
+We evaluate the proposed RMM method on three CIL benchmarks: CIFAR-100 [24], ImageNet-Subset [40], and ImageNet-Full [44], and use two top performing methods LUCIR $+$ AANets and POD $+$ AANets [30] as baselines. Below we introduce the datasets
+
+1: Input: Data $\mathcal { D }$ for generating pseudo CIL tasks.   
+2: Output: Policy functions $\pi _ { \eta } , \pi _ { \phi }$ .   
+3: Initialize $\eta$ and $\phi$ ;   
+4: for $m$ epochs do   
+5: for $k$ in $1 , . . . , K$ do   
+6: Create a new pseudo task $\mathcal { T } _ { k }$ using $\mathcal { D }$ ;   
+7: for z in 1, ..., Z do   
+8: Initialize classification model $\Theta _ { 0 }$ ;   
+9: for $_ i$ in 0, ..., N do   
+10: if $i \geq 1$ do   
+11: Observe $s _ { i }$ and produce $a _ { i } ^ { [ 1 ] } \sim \pi _ { \eta } ( s _ { i } )$ ;   
+12: Allocate $\mathcal { M } _ { \mathrm { o l d } }$ and $\mathcal { M } _ { \mathrm { n e w } }$ using Eq. 1;   
+13: Produce $a _ { i } ^ { [ 2 ] } \sim \pi _ { \phi } ( a _ { i } ^ { [ 1 ] } , s _ { i } )$ ;   
+14: Allocate $\{ \mathcal { M } _ { j } ^ { A } \} _ { j = 0 } ^ { i }$ and $\{ \mathcal { M } _ { j } ^ { B } \} _ { j = 0 } ^ { i }$ using Eq. 2;   
+15: Update $\mathcal { E } _ { 0 : i - 1 }$ using herding [40];   
+16: Save $\mathcal { E } _ { 0 : i - 1 }$ in $\mathcal { M } _ { \mathrm { o l d } }$ and free $\mathcal { M } _ { \mathrm { n e w } }$ ;   
+17: Observe new data and load $\mathcal { D } _ { i }$ into $\mathcal { M } _ { \mathrm { n e w } }$ randomly;   
+18: Initialize $\Theta _ { i }$ with $\Theta _ { i - 1 }$ and train it using $\mathcal { E } _ { 0 : i - 1 } \cup \mathcal { D } _ { i }$ ;   
+19: Compute validation accuracy $r _ { i }$ ;   
+20: Compute $\begin{array} { r } { R _ { z } ^ { k } = \sum _ { i = 0 } ^ { N } r _ { i } } \end{array}$ and update $b$ ;   
+21: Compute $\nabla _ { \eta , \phi } J ( \eta , \phi )$ using Eq. 5;   
+22: Update $\eta$ and $\phi$ using Eq. 6.
+
+and implementation details (Section 5.1), followed by the experimental results and analyses (Section 5.2).
+
+# 5.1 Datasets and Implementation Details
+
+Datasets. We use three benchmarks based on two datasets, CIFAR-100 [24] and ImageNet [44], following common settings [13, 18, 40, 30]. CIFAR-100 [24] contains 60, 000 samples of $3 2 \times 3 2$ color images from 100 classes. There are 500 training and 100 test samples for each class. ImageNet (ILSVRC 2012) [44] contains around 1.3 million samples of $2 2 4 \times 2 2 4$ color images from 1, 000 classes. There are about 1, 300 training and 50 test samples for each class. ImageNet has two CIL settings: ImageNet-Subset is based on a subset of 100 classes; and ImageNet-Full uses the full set of 1, 000 classes. The 100-class data for the ImageNet-Subset are sampled from ImageNet. For the experiments on PODNet [13] and POD-AANets [30], we use the same class orders and hyperparameters as [13]. For the experiments on LUCIR [18] and LUCIR-AANets [30], we use the same class orders and hyperparameters as [18].
+
+Benchmarks. We follow the benchmark protocol used in [13, 18, 30, 31]. Given a dataset, the initial (the 0-th phase) model is trained on the data of half of the classes. Then, it learns the remaining classes evenly in the subsequent $N$ phases. Assume there is an initial phase and $N$ incremental phases in the CIL system. The total number of incremental phases $N$ is set to be 5, 10 or 25 (for each the setting is called “ $N$ -phase” setting). At the end of each individual phase, the learned model in each phase is evaluated on the test set containing all seen classes. In the tables, we report average accuracy over all phases and the last-phase accuracy, where the latter indicates the degree of forgetting.
+
+Network Architectures. Following [18, 30, 40, 52], we use a 32-layer ResNet [40] for CIFAR-100 and an 18-layer ResNet [17] for ImageNet. Please note that it is standard to use a shallower ResNet for ImageNet. The 32-layer ResNet consists of an initial convolution layer and three residual blocks (in a single branch). Each block has ten convolution layers with $3 \times 3$ kernels. The number of filters starts from 16 and is doubled every next block. After these three blocks, there is an average-pooling layer to compress the output feature maps to a feature embedding. The 18-layer ResNet follows the standard settings in [17]. We deploy AANets using the same parameters as its original paper [30].
+
+Table 1: Average accuracies $( \% )$ across all phases using two state-of-the-art methods (LUCIR $+$ AANets and POD $+ .$ AANets [30]) $w /$ and $w / o$ our RMM plugged in. The upper block is for recent CIL methods. For fair comparison, we re-implement these methods using our strict memory budget (see “Memory Budget” in Section 5.1) based on the public code. The results of using another common budget setting and the detailed numbers (confidence intervals and last-phase accuracies) are provided in the supplementary materials.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="3">CIFAR-100</td><td colspan="3">ImageNet-Subset</td><td colspan="3">ImageNet-Full</td></tr><tr><td>N=5</td><td>10</td><td>25</td><td>5</td><td>10</td><td>25</td><td>5</td><td>10</td><td>25</td></tr><tr><td>LwF[29]</td><td>56.79</td><td>53.05</td><td>50.44</td><td>58.83</td><td>53.60</td><td>50.16</td><td>52.00</td><td>47.87</td><td>47.49</td></tr><tr><td>iCaRL [40]</td><td>60.48</td><td>56.04</td><td>52.07</td><td>67.33</td><td>62.42</td><td>57.04</td><td>50.57</td><td>48.27</td><td>49.44</td></tr><tr><td>LUCIR [18]</td><td>63.34</td><td>62.47</td><td>59.69</td><td>71.21</td><td>68.21</td><td>64.15</td><td>65.16</td><td>62.34</td><td>57.37</td></tr><tr><td>Mnemonics [31]</td><td>64.59</td><td>62.59</td><td>61.02</td><td>72.60</td><td>71.66</td><td>70.52</td><td>65.40</td><td>64.02</td><td>62.05</td></tr><tr><td>PODNet [13]</td><td>64.60</td><td>63.13</td><td>61.96</td><td>76.45</td><td>74.66</td><td>70.15</td><td>66.80</td><td>64.89</td><td>60.28</td></tr><tr><td>LUCIR-AANets [30]</td><td>66.88</td><td>65.53</td><td>63.92</td><td>72.80</td><td>69.71</td><td>68.07</td><td>65.31</td><td>62.99</td><td>61.21</td></tr><tr><td>w/ RMM (ours)</td><td>68.42</td><td>67.17</td><td>64.56</td><td>73.58</td><td>72.83</td><td>72.30</td><td>65.81</td><td>64.10</td><td>62.23</td></tr><tr><td>POD-AANets [30]</td><td>66.61</td><td>64.61</td><td>62.63</td><td>77.36</td><td>75.83</td><td>72.18</td><td>67.97</td><td>65.03</td><td>62.03</td></tr><tr><td>w/ RMM (ours)</td><td>68.86</td><td>67.61</td><td>66.21</td><td>79.52</td><td>78.47</td><td>76.54</td><td>69.21</td><td> 67.45</td><td>63.93</td></tr></table>
+
+For policy functions $\pi _ { \eta }$ and $\pi _ { \phi }$ , we use two-layer FC networks. All actions are discretized at 0.1 intervals to reduce the search space and get a tolerable training overhead.
+
+Hyperparameters and Configuration. The training of the classification model $\Theta$ exactly follows the uniform setting in [13, 18, 30, 31]. On CIFAR-100 (ImageNet-Subset/Full), we train it for 160 (90) epochs in each phase, and divide the learning rate by 10 after 80 (30) and then after 120 (60) epochs. Then, we fine-tune the model for 20 epochs using only exemplars (including the preserved exemplars of the new data to be used in future phases). We use an SGD optimizer and an ADAM optimizer for the classification model and policy functions, respectively. More details are given in the supplementary.
+
+Memory Budget. There are two popular settings about memory budget in related work. One uses a bounded memory budget with a fixed capacity for all phases [18, 31, 40]. Another one allows the memory budget to grow along with phases [18, 20, 49]. The first one is more strict and thus used as the major setting in our paper (note that the results and analyses using the second setting are given in the supplementary materials). In every benchmark, the total budget of memory depends on the phase number $N$ . For example, on CIFAR-100, the total memory budget is set as 7, 000 samples when $N { = } 5$ (7, 000 samples $= 1 0$ classes/phase $\times 5 0 0$ samples/class $+ ~ 2$ , 000 samples). Please note that 2, 000 is a bounded memory budget allocated since the 0-th phase for saving exemplars. More clarifications about memory budget are given in the supplementary. For fair comparison, we re-implement related methods and report the results in Table 1 if their original results (in the respective papers) were obtained in a different setting of memory budget.
+
+# 5.2 Results and Analyses
+
+Table 1 presents the results of two state-of-the-art methods (LUCIR $+$ AANets and POD $+$ AANets [30]) w/ and $w / o$ our RMM plugged in, and some recent CIL work [13, 18, 29, 31, 40]. Table 2 shows the ablation study in 6 settings. Figure 4 plots the changes of the average number of exemplars per old/new class for the incremental phases.
+
+Comparing to the State-of-the-Art. From Table 1, we make the following observations. 1) Our RMM consistently improves the two top baselines LUCIR $^ +$ AANets and POD $^ +$ AANets [30] in all settings. E.g., LUCIR-AANets $w /$ RMM and POD-AANets w/ RMM respectively get $2 . 7 \%$ and $3 . 1 \%$ average improvements on the ImageNet-Subset. 2) Our POD-AANets $w /$ RMM achieves the best performances. Interestingly, we find that our RMM can boost performance more when the number of phases is larger. For example, when $N { = } 2 5$ , RMM improves POD-AANets by $3 . 6 \%$ and $4 . 4 \%$ on CIFAR-100 and ImageNet-Subset, respectively. These two numbers are $2 . 3 \%$ and $2 . 1 \%$ when $N { = } 5$
+
+<table><tr><td rowspan="3">Ablation Setting</td><td colspan="4">CIFAR-100</td><td colspan="4">ImagNet-Subset</td></tr><tr><td>N=5</td><td></td><td>10</td><td>25</td><td></td><td>5</td><td>10</td><td>25</td></tr><tr><td>Avg</td><td>Last</td><td>Avg Last</td><td>Avg</td><td>Last</td><td>Avg Last</td><td>Avg Last</td><td>Avg</td><td>Last</td></tr><tr><td>1 BaseRow</td><td>66.61</td><td>57.81</td><td>64.61 55.70</td><td>62.63</td><td>52.53</td><td>77.36 70.02</td><td>75.83</td><td>68.97</td><td>72.18 63.89</td></tr><tr><td>2 One-level RL</td><td>67.92 58.61</td><td></td><td>66.94 58.31</td><td></td><td>65.95 56.44</td><td>78.50 72.00</td><td></td><td>78.15 71.00</td><td>75.47 67.47</td></tr><tr><td>3 Two-level RL (Used) 68.86 59.00</td><td></td><td></td><td>67.61 59.03</td><td></td><td>66.21 56.50</td><td>79.52 73.80</td><td></td><td>78.47 71.40</td><td>76.54 68.84</td></tr><tr><td>margin</td><td>+2.3</td><td>+1.2</td><td>+3 +3.3</td><td>+3.6</td><td>+4</td><td>+2.1</td><td>+3.8 +2.6</td><td>+2.4</td><td>+4.4 +5</td></tr><tr><td>4 Two-level RL (T.P.) margin</td><td>68.62 59.40</td><td></td><td>67.22 58.20</td><td></td><td>65.82 56.20</td><td>78.81 72.42</td><td></td><td>77.68 70.77</td><td>75.29 68.81</td></tr><tr><td>5 UpperBound RL</td><td>+2</td><td>+1.6</td><td>+2.6+2.5</td><td></td><td>+3.2 +3.7</td><td>+1.5+2.4</td><td></td><td>+1.9 +1.8</td><td>+3.1 +4.9</td></tr><tr><td>6 Cross Val Fixed</td><td>70.00 61.12</td><td></td><td>68.36 60.00</td><td></td><td>66.56 56.74 65.73 55.51</td><td>80.01 74.31 77.96 70.31</td><td></td><td>78.95 71.97</td><td>76.99 69.14</td></tr><tr><td></td><td>67.50 58.48</td><td></td><td>66.69 57.19</td><td></td><td></td><td></td><td></td><td>76.70 69.08</td><td>74.18 66.10</td></tr></table>
+
+Table 2: The evaluation results in the ablation study $( \% )$ . “T.P.” denotes our results using the Policy functions Transferred from another dataset. “Avg”, “Last”, and “Used” denote the average accuracy over all phases, the last-phase accuracy, and the results used as ours in Table 1, respectively. BaseRow is from the sota method POD-AANets [30]. Row 2 is for learning Level-1 policy. Row 3 is for learning Level-1 and Level-2 policies in a hierarchical way. Row 4 is for using Transferred Policies (from the other dataset in the table), when RL is costly or impossible on target CIL tasks. The bottom lines are two oracles: training the RL model on the target CIL task (Row 5) and using cross-validation to find the best fixed memory allocation between old and new classes (Row 6).
+
+This indicates that the superiority of our RMM is more obvious in challenging settings (where the forgetting problem is more serious due to the more frequent model re-training through phases).
+
+Ablation Settings. Table 2 shows the results of our ablation study. Row 1 is for the baseline method POD-AANets [30]. Row 2 is for learning only Level-1 policy $\pi _ { \eta }$ (where each class gets an even split of the memory). Row 3 is for learning both Level-1 policy $\pi _ { \eta }$ and Level-2 policy $\pi _ { \phi }$ in our proposed hierarchical method, and its results are used in Table 1 as “ours”. Row 4 is for using Policy functions Transferred from another dataset (T.P.), which means on the target CIL dataset there is no training of RMM. Here, for CIFAR-100, we use the policy functions learned on ImageNet-Subset, and vice versa. On the last two rows, we show two oracle settings. Row 5 is the upper bound that assumes all past and future data are accessible during training RMM on the target CIL dataset. Row 6 is for using cross-validation (i.e., all past, future, and validation data are accessible) to find the best fixed memory split between old and new class data, e.g., $\textstyle \mathrm { \frac { o l d } { n e w } } = 0 . 7$ is chosen and then used in all phases. The details of chosen split rates are given in the supplementary materials.
+
+Ablation Results. Hierarchical: In Table 2, when comparing Row 2 to Row 1, it is clear that leveraging reinforcement learning yields better results as it can derive adaptive memory allocation between old and new data. Using class-specific memory management further increases the model performance (i.e., comparing Row 3 to Row 2), even though we divide the classes into only two groups. T.P. (Transferred Policy functions): Comparing Row 4 to Row 3, we can see that using transferred policy functions (trained on another dataset) achieves comparable performance, and Row 4 does not require any reinforcement learning on the target CIL dataset. Oracle: Comparing Row 3 to Row 5, we see that learning RMM on pseudo CIL tasks is comparable to the upper bound case where all training and validate data are accessible, given the fact that the latter needs higher computational overhead and violates the standard CIL protocol. Row 6 results are consistently lower than ours in Row 3, although cross-validation has access to all past, future, and validation data.
+
+Allocated Memory. Figure 4 shows the change of the average number of samples per class in three ablative settings. Solid and dashed lines represent old and new classes, respectively. From the plots, we have two observations. 1) Learning RMM on the pseudo or target CIL tasks (green and orange lines), we can obtain similar memory management results (i.e., actions). This means the learned policy is transferrable in non-stationary continuous environments. This matches the conclusion of continuous adaptation in [2]. 2) Using our RMM method achieved more balanced memory sizes between exemplars and new data. For example, in the 1-st phase of the 5-phase setting, “UpperBound
+
+![](images/70170b079fa509f7fe9e447e26b1993b1d5aef6ac3af3e5c866ecabdd6dd20c7.jpg)  
+Figure 4: The memory allocated for “Old” and “New” across different phases on CIFAR-100. The second and fourth plots are enlarged versions of the first and third plots, respectively. Solid and phase (N=5)dashed lines denote old and new classes, respectively. The baseline is POD-AANets [30]. “Two-level RL” and “UpperBound RL” correspond to Row 3 and Row 5 in Table 2, respectively.
+
+RL” and “Two-level RL” allocate around 100 samples for both exemplars and new data. While the baseline setting has 40 and 500 samples for them, respectively. It thus addresses the data imbalance problem for CIL in a learnable way.
+
+# 6 Conclusions
+
+We propose the reinforced memory management (RMM) method specially for tackling CIL tasks. The hierarchical reinforcement learning (RL) framework (two levels) in RMM is capable of making more adaptive memory allocation actions than using standard RL (one level). Using the generated pseudo tasks in RMM solves the issue of data incompatibility between CIL and RL. Corresponding experimental results show that the policy trained on these pseudo tasks can be directly applied to target tasks without any computational overhead. Our overall method of RMM is generic, and its trained policy (with or without using an in-domain dataset) can be easily incorporated into exemplar replaying-based CIL methods to boost performance.
+
+# Limitations and Societal Impact
+
+We analyse the limitations and potential negative societal impact in the following three aspects.
+
+• Complexity. Training RMM takes an additional time cost. According to Algorithm 1, the cost is $O ( m K Z )$ times higher than the time used for the target CIL task. However, the training of RMM policy is offline and can use a different dataset (see Table 2) — RMM pre-learns a robust policy from synthesized pseudo tasks and can be directly applied for memory management in real CIL tasks. The overhead of applying this policy is very little, e.g., $0 . 6 3 \%$ and $1 . 1 2 \%$ of the total training time respectively on CIFAR-100 and ImageNet (Subset and Full), taking $\mathrm { P O D + }$ AANets as the baseline.
+
+• Technical assumptions. We build the framework of RMM based on a series of technical assumptions, which might not directly hold for all real-world continual-learning applications. When applying our method to mission-critical problems, particular care is required when modeling the system.
+
+• Privacy issues. Keeping the old class exemplars has the issue of data privacy. This calls for future research that explicitly forgets or mitigates the identifiable feature of the data.
+
+# Acknowledgments and Disclosure of Funding
+
+This research was supported by $\mathbf { A } { ^ { * } \mathbf { S } } \mathbf { T } \mathbf { A } \mathbf { R }$ under its AME YIRG Grant (Project No. A20E6c0101), Alibaba Innovative Research (AIR) programme, and Max Planck Institute for Informatics.
+
+# References
+
+[1] Davide Abati, Jakub Tomczak, Tijmen Blankevoort, Simone Calderara, Rita Cucchiara, and Babak Ehteshami Bejnordi. Conditional channel gated networks for task-aware continual learning. In CVPR, pages 3931–3940, 2020.   
+[2] Maruan Al-Shedivat, Trapit Bansal, Yura Burda, Ilya Sutskever, Igor Mordatch, and Pieter Abbeel. Continuous adaptation via meta-learning in nonstationary and competitive environments. In ICLR, 2018.   
+[3] Rahaf Aljundi, Punarjay Chakravarty, and Tinne Tuytelaars. Expert gate: Lifelong learning with a network of experts. In CVPR, pages 3366–3375, 2017.   
+[4] Eden Belouadah and Adrian Popescu. Il2m: Class incremental learning with dual memory. In CVPR, pages 583–592, 2019.   
+[5] Christopher M Bishop. Pattern recognition and machine learning. springer, 2006.   
+[6] Francisco M. Castro, Manuel J. Marín-Jiménez, Nicolás Guil, Cordelia Schmid, and Karteek Alahari. End-to-end incremental learning. In ECCV, pages 241–257, 2018.   
+[7] Arslan Chaudhry, Marc’Aurelio Ranzato, Marcus Rohrbach, and Mohamed Elhoseiny. Efficient lifelong learning with a-gem. In ICLR, 2019.   
+[8] Tianqi Chen, Ian J. Goodfellow, and Jonathon Shlens. Net2net: Accelerating learning via knowledge transfer. In Yoshua Bengio and Yann LeCun, editors, ICLR, 2016.   
+[9] Zhiyuan Chen and Bing Liu. Lifelong machine learning. Synthesis Lectures on Artificial Intelligence and Machine Learning, 12(3):1–207, 2018.   
+[10] Guy Davidson and Michael C Mozer. Sequential mastery of multiple visual tasks: Networks naturally learn to learn and forget to forget. In CVPR, pages 9282–9293, 2020.   
+[11] Matthias De Lange, Rahaf Aljundi, Marc Masana, Sarah Parisot, Xu Jia, Ales Leonardis, Gregory Slabaugh, and Tinne Tuytelaars. Continual learning: A comparative study on how to defy forgetting in classification tasks. arXiv, 1909.08383, 2019.   
+[12] Matthias De Lange, Rahaf Aljundi, Marc Masana, Sarah Parisot, Xu Jia, Aleš Leonardis, Gregory Slabaugh, and Tinne Tuytelaars. A continual learning survey: Defying forgetting in classification tasks. arXiv, 1909.08383, 2019.   
+[13] Arthur Douillard, Matthieu Cord, Charles Ollion, Thomas Robert, and Eduardo Valle. Podnet: Pooled outputs distillation for small-tasks incremental learning. In ECCV, 2020.   
+[14] Qiang Gao, Zhipeng Luo, and Diego Klabjan. Efficient architecture search for continual learning. arXiv preprint arXiv:2006.04027, 2020.   
+[15] Pierre Yves Glorennec. Reinforcement learning: An overview. In Proceedings European Symposium on Intelligent Techniques (ESIT-00), Aachen, Germany, pages 14–15. Citeseer, 2000.   
+[16] John Hammersley. Monte carlo methods. Springer Science & Business Media, 2013.   
+[17] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pages 770–778, 2016.   
+[18] Saihui Hou, Xinyu Pan, Chen Change Loy, Zilei Wang, and Dahua Lin. Learning a unified classifier incrementally via rebalancing. In CVPR, pages 831–839, 2019.   
+[19] Wenpeng Hu, Zhou Lin, Bing Liu, Chongyang Tao, Zhengwei Tao, Jinwen Ma, Dongyan Zhao, and Rui Yan. Overcoming catastrophic forgetting for continual learning via model adaptation. In ICLR, 2019.   
+[20] Xinting Hu, Kaihua Tang, Chunyan Miao, Xian-Sheng Hua, and Hanwang Zhang. Distilling causal effect of data in class-incremental learning. In CVPR, 2021.   
+[21] Shenyang Huang, Vincent François-Lavet, and Guillaume Rabusseau. Neural architecture search for class-incremental learning. arXiv preprint arXiv:1909.06686, 2019.   
+[22] Ahmet Iscen, Jeffrey Zhang, Svetlana Lazebnik, and Cordelia Schmid. Memory-efficient incremental learning through feature adaptation. In ECCV, pages 699–715, 2020.   
+[23] Wouter Kool, Herke van Hoof, and Max Welling. Buy 4 reinforce samples, get a baseline for free! In ICLR Workshops, 2019.   
+[24] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.   
+[25] Anna Kukleva, Hilde Kuehne, and Bernt Schiele. Generalized and incremental few-shot learning by explicit learning and calibration without forgetting. In ICCV, pages 9020–9029, 2021.   
+[26] Yingying Li, Xin Chen, and Na Li. Online optimal control with linear dynamics and predictions: Algorithms and regret analysis. In NeurIPS, pages 14858–14870, 2019.   
+[27] Yingying Li and Na Li. Online learning for markov decision processes in nonstationary environments: A dynamic regret analysis. In ACC, pages 1232–1237. IEEE, 2019.   
+[28] Yingying Li, Aoxiao Zhong, Guannan Qu, and Na Li. Online markov decision processes with time-varying transition probabilities and rewards. In ICML workshop on Real-world Sequential Decision Making, 2019.   
+[29] Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE Transactions on Pattern Analysis and Machine Intelligence, 40(12):2935–2947, 2018.   
+[30] Yaoyao Liu, Bernt Schiele, and Qianru Sun. Adaptive aggregation networks for classincremental learning. In CVPR, 2021.   
+[31] Yaoyao Liu, Yuting Su, An-An Liu, Bernt Schiele, and Qianru Sun. Mnemonics training: Multi-class incremental learning without forgetting. In CVPR, pages 12245–12254, 2020.   
+[32] David Lopez-Paz and Marc’Aurelio Ranzato. Gradient episodic memory for continual learning. In NIPS, pages 6467–6476, 2017.   
+[33] Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of Learning and Motivation, volume 24, pages 109–165. Elsevier, 1989.   
+[34] K. McRae and P. Hetherington. Catastrophic interference is eliminated in pre-trained networks. In CogSci, 1993.   
+[35] Ameya Prabhu, Philip HS Torr, and Puneet K Dokania. Gdumb: A simple approach that questions our progress in continual learning. In ECCV, 2020.   
+[36] Jathushan Rajasegaran, Munawar Hayat, Salman Khan, Fahad Shahbaz Khan, and Ling Shao. Random path selection for incremental learning. NeurIPS, 2019.   
+[37] Jathushan Rajasegaran, Salman Khan, Munawar Hayat, Fahad Shahbaz Khan, and Mubarak Shah. itaml: An incremental task-agnostic meta-learning approach. In CVPR, pages 13588– 13597, 2020.   
+[38] Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level training with recurrent neural networks. In Yoshua Bengio and Yann LeCun, editors, ICLR, 2016.   
+[39] R. Ratcliff. Connectionist models of recognition memory: Constraints imposed by learning and forgetting functions. Psychological Review, 97:285–308, 1990.   
+[40] Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert. iCaRL: Incremental classifier and representation learning. In CVPR, pages 5533–5542, 2017.   
+[41] Mengye Ren, Renjie Liao, Ethan Fetaya, and Richard S Zemel. Incremental few-shot learning with attention attractor networks. In NeurIPS, pages 5276–5286, 2019.   
+[42] Steven J Rennie, Etienne Marcheret, Youssef Mroueh, Jerret Ross, and Vaibhava Goel. Selfcritical sequence training for image captioning. In CVPR, pages 7008–7024, 2017.   
+[43] Matthew Riemer, Ignacio Cases, Robert Ajemian, Miao Liu, Irina Rish, Yuhai Tu, and Gerald Tesauro. Learning to learn without forgetting by maximizing transfer and minimizing interference. In ICLR, 2019.   
+[44] Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.   
+[45] Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv, 1606.04671, 2016.   
+[46] Shiqi Shen, Yong Cheng, Zhongjun He, Wei He, Hua Wu, Maosong Sun, and Yang Liu. Minimum risk training for neural machine translation. In ACL, 2016.   
+[47] Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. In NIPS, pages 2990–2999, 2017.   
+[48] Christian Simon, Piotr Koniusz, and Mehrtash Harandi. On learning the geodesic path for incremental learning. In CVPR, pages 1591–1600, 2021.   
+[49] Xiaoyu Tao, Xinyuan Chang, Xiaopeng Hong, Xing Wei, and Yihong Gong. Topologypreserving class-incremental learning. In ECCV, 2020.   
+[50] Tom Veniat, Ludovic Denoyer, and Marc’Aurelio Ranzato. Efficient continual learning with modular networks and task-driven priors. In ICLR, 2021.   
+[51] Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992.   
+[52] Yue Wu, Yinpeng Chen, Lijuan Wang, Yuancheng Ye, Zicheng Liu, Yandong Guo, and Yun Fu. Large scale incremental learning. In CVPR, pages 374–382, 2019.   
+[53] Ziyang Wu, Christina Baek, Chong You, and Yi Ma. Incremental learning via rate reduction. In CVPR, pages 1125–1133, 2021.   
+[54] Ju Xu and Zhanxing Zhu. Reinforced continual learning. In NeurIPS, pages 899–908, 2018.   
+[55] Lu Yu, Bartlomiej Twardowski, Xialei Liu, Luis Herranz, Kai Wang, Yongmei Cheng, Shangling Jui, and Joost van de Weijer. Semantic drift compensation for class-incremental learning. In CVPR, pages 6982–6991, 2020.   
+[56] Chi Zhang, Nan Song, Guosheng Lin, Yun Zheng, Pan Pan, and Yinghui Xu. Few-shot incremental learning with continually evolved classifiers. In CVPR, pages 12455–12464, 2021.   
+[57] Bowen Zhao, Xi Xiao, Guojun Gan, Bin Zhang, and Shu-Tao Xia. Maintaining discrimination and fairness in class incremental learning. In CVPR, pages 13208–13217, 2020.   
+[58] Fei Zhu, Xu-Yao Zhang, Chuang Wang, Fei Yin, and Cheng-Lin Liu. Prototype augmentation and self-supervision for incremental learning. In CVPR, pages 5871–5880, 2021.   
+[59] Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. In ICLR, 2017.

md/train/KIfbqntFnOc/KIfbqntFnOc.md

@@ -0,0 +1,245 @@
+# ROBUST ENSEMBLES OF NEURAL NETWORKS USING ITOˆ PROCESSES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Residual neural networks (ResNets) can be modeled as dynamical systems where the evolution of dynamical systems represents the inference in ResNets. We exploit this connection and the theory of stochastic dynamical systems to construct a novel ensemble of Ito processes as a new deep learning representation ˆ that is more robust than classical residual networks. An Ito process obtained by ˆ solving a suitably-formulated stochastic differential equation derived from a residual network has a probability density function that is not readily perturbed by small changes in the neural network’s inputs. Our robust stochastic Itoˆ ensemble of neural networks achieve an accuracy of $7 3 . 9 1 \%$ on the CIFAR-10 dataset against the PGD attack with $\epsilon \ : = \ : 2 . 0$ under the $L _ { 2 }$ norm, while the accuracy of Madry’s robustness toolbox on the same attack is $1 8 . 5 9 \%$ . Similarly, our stochastic Ito ensemble of neural networks achieves an accuracy of ˆ $7 9 . 6 6 \%$ on PGD attack with $\epsilon = 1 6 / 2 5 5$ under the $L _ { \infty }$ norm, while the accuracy of Madry’s robustness toolbox on the same attack is $1 8 . 1 3 \%$ . The Ito ensemble ˆ trained on ImageNet achieves an accuracy of $2 8 . 5 3 \%$ against PGD attacks under the $L _ { \infty }$ norm with $\epsilon = 1 6 / 2 5 5$ and accuracy of $6 5 . 7 4 \%$ under the $L _ { 2 }$ norm with $\epsilon = 3 . 0$ , respectively. This significantly improves state-of-the-art accuracy of $5 \%$ and $3 5 . 1 6 \%$ for Madry’s robustness tool against the same PGD attacks under the $L _ { \infty }$ and $L _ { 2 }$ norms, respectively. Further, our approach achieves these high robustness values without any explicit adversarial training or a significant loss of accuracy on benign inputs.
+
+# 1 INTRODUCTION
+
+Deep neural networks (DNNs) have emerged as a very effective learning representation achieving near human-level performance in many domains such as computer vision (Gkioxari et al., 2015), natural language processing (Majumder et al., 2017), and speech recognition (Hannun et al., 2014). Despite this success, the use of deep learning models in high-assurance systems with safety and security requirements such as autonomous vehicles (Bojarski et al., 2016) and medical diagnoses (De Fauw et al., 2018) faces a trust deficit. The lack of robustness of these models and their susceptibility to adversarial attacks (Kurakin et al., 2016; Szegedy et al., 2013) that can change the prediction of a deep neural network via small imperceptible perturbations make deep learning models less trustworthy. This limitation is further aggravated by deep neural networks generally exhibiting very high confidence on incorrect predictions (Guo et al., 2017a; Hendrycks & Gimpel, 2016). Consequently, this lack of robustness hinders their deployment in safety-critical applications. There is a pressing need for a principled approach to learning robust deep learning models that are resilient to adversarial attacks and can abstain from making decisions on inputs for which they are likely to make a wrong prediction.
+
+A number of approaches have been recently proposed to increase the robustness of deep learning models. Adversarial training (Tramer et al., 2017; Engstrom et al., 2020) uses adversarial samples \` in the training phase to make the models more robust. Another set of alternative approaches use the projection of inputs to data manifold (Lamb et al., 2018; Ilyas et al., 2017; Jang et al., 2020) or other preprocessing methods (Xie et al., 2019; Guo et al., 2017b). These approaches are robust to existing attack methods but their use of adversarial samples or predefined transformations (often achieved via another deep neural network such as autonecoders) makes these approaches susceptible to newer attack strategies. Certifiable-defense approaches (Wong et al., 2018; Dvijotham et al., 2018;
+
+Raghunathan et al., 2018; Dutta et al., 2018) have also been recently proposed to make deep learning models robust against worst-case input over a defined range of perturbations. These theoretical guarantees on worst-case inputs hold only for small perturbations; consequently, their use is limited in practice and their performance is typically inferior to approaches based on adversarial training, particularly for high-dimensional inputs.
+
+In this paper, we address this challenge of robust and trustworthy deep learning using a new representation that exploits the connection between dynamical systems and residual neural networks (ResNets), and uses the theory of stochastic dynamical systems. Dynamical systems can model ResNets where the inference in the network is represented by the evolution of the dynamical system (Chen et al., 2015; Chang et al., 2017; Sonoda & Murata, 2017; Chen et al., 2018; Lu et al., 2018). We construct a novel deep ensemble using a special class of stochastic dynamical systems, namely the Ito drift-diffusion process with suitably bounded diffusion term. It ˆ o process is the sum ˆ of the integral of a process over time and of another process over a Brownian motion. The drift over time models the typical inference in a ResNet and the diffusion Brownian motion models the added stochastic noise that makes the model robust to adversarial perturbations. We form an ensemble of these Ito processes by considering multiple such models and multiple inferences over the same model. If a majority of the ensemble agrees on a particular prediction, Ito ensemble ˆ makes that prediction; otherwise, it abstains from making a decision.
+
+<table><tr><td>Robustness Approach</td><td>Accuracy (%)</td><td rowspan="2">Benchmark</td><td rowspan="2">Norm</td><td colspan="2">Accuracy (%)</td></tr><tr><td>Ito Ensemble</td><td>84.60</td><td>Ito Ensemble</td><td>Madry toolbox</td></tr><tr><td>Engstrom et al. (2020)</td><td>53.49</td><td>CIFAR-10</td><td>L2</td><td>73.91</td><td>18.59</td></tr><tr><td>Balunovic &amp; Vechev (2020)</td><td>46.2</td><td>ImageNet</td><td>L2</td><td>69.51</td><td>43.04</td></tr><tr><td>Zhang et al. (2019)</td><td>40.5</td><td>CIFAR-10</td><td>L</td><td>79.66</td><td>18.13</td></tr><tr><td>Pang et al. (2019) (∈=0.01)</td><td>48.4</td><td>ImageNet</td><td>L8</td><td>28.53</td><td>5.00</td></tr></table>
+
+Table 1: (left) Our Ito ensemble approach outperforms SOTA defenses for the PGD attack on ˆ CIFAR-10 with $\epsilon = 8 / 2 5 5$ unless specified otherwise. (right) Ito ensemble outperforms Madry ˆ toolbox (Engstrom et al., 2020) under PGD attack with $L _ { 2 }$ norm, $\epsilon = 2 . 0$ , and $L _ { \infty }$ norm $\epsilon = 1 6 / 2 5 5$
+
+We highlight a few results demonstrating the robustness of Ito process ensembles in Table 1. Our It ˆ oˆ ensemble approach has higher accuracy compared to several state-of-the-art robustness approaches. The accuracy of our approach is $8 4 . 6 0 \%$ on CIFAR-10 against the PGD attack in $L _ { \infty }$ norm with $\epsilon = 8 / 2 5 5$ and the next best approach is Engstrom et al. (2020) (Madry toolbox) with an accuracy of $5 3 . 4 9 \%$ . On CIFAR-10 and ImageNet benchmarks, our Ito ensemble approach is significantly more ˆ robust than Engstrom et al. (2020) (Madry toolbox) against PGD attacks in both $L _ { 2 }$ and $L _ { \infty }$ norms for different values of attack strength $\epsilon$ . Thus, our Ito ensembles exhibit remarkable robustness ˆ against adversarial attacks without any explicit adversarial training.
+
+![](images/ee651e75a7ef35f0c3b36ce537787418b8143175e1fba6412c1b4db6a90edb24.jpg)  
+Figure 1: Examples of benign images on which our approach using Ito processes abstains from ˆ making a decision while the original ResNet model makes a decision despite high uncertainty. The first image is found by Ito process ensemble to be confusing between ˆ binoculars and cannon, the second between a radiator and a projector, the third between a trench-coat and bicycle, and the last one between stove and coffee-pot. This uncertainty in Ito ensemble resembles human judgement. ˆ
+
+Our approach using Ito ensembles can abstain from making decisions on a confusing input. In ˆ Section 4, we demonstrate that abstentions further improve the robustness of the Ito ensembles ˆ to adversarial examples compared to the state-of-the-art approaches. Further, we notice that Itoˆ ensembles abstain even on benign data inputs where manual inspection demonstrates high aleatoric or epistemic uncertainty as shown in Figure 1. Our experiments show that this new approach of using Ito ensembles achieves high robustness without significant loss in accuracy on benign inputs. ˆ
+
+# 2 RELATED WORK
+
+Residual neural networks are a common neural network architecture that learn only the residuals not learned by the previous layers. ResNets (He et al., 2016) are residual neural networks where residual learning is adopted for every few stacked neural network layers and such building blocks are used to design the complete residual neural network. The dynamics of ResNets and other similar neural networks can be described using ordinary and partial differential equations (Chen et al., 2015; Chang et al., 2017; Sonoda & Murata, 2017; Weinan, 2017; Chen et al., 2018; Lu et al., 2018). One timestep of the dynamics models each building block of the ResNets. Such a dynamical model enables memory efficiency in training and adaptive inference. In contrast, we use stochastic differential equations (Ito processes) and demonstrate their robustness to adversarial attacks. ˆ
+
+A number of adversarial attacks on deep neural networks have been proposed in literature and shown to be effective across different architectures. Attacks such as the fast gradient sign method (FGSM) (Szegedy et al., 2013), the projected gradient decent (PGD) (Madry et al., 2017) and other approaches (Nicolae et al., 2018) have demonstrated the fragility of deep neural networks to small perturbations in their inputs. The most effective state-of-art defenses use adversarial training (Tramer et al., 2017; Engstrom et al., 2020) or some projection or transformation of \` inputs (Lamb et al., 2018; Ilyas et al., 2017; Jang et al., 2020; Xie et al., 2019; Guo et al., 2017b). The use of adversarial examples or predefined transformations makes these approaches vulnerable to new attacks. In contrast, our approach using Ito process does not need adversarial examples. ˆ
+
+Our use of stochastic dynamical systems is inspired by their presence in biological systems (Kitano, 2004; Bressloff, 2014; Allen, 2010) where they impart robustness to external perturbations. As an example, (Arkin et al., 1998) study gene expression using Gillespie’s stochastic formulation of chemical kinetics and show that protein numbers can vary markedly from one cell to another with important consequences for biological robustness (Gonze et al., 2002).
+
+# 3 ROBUST LEARNING USING ITOˆ ENSEMBLES
+
+Residual networks (ResNets) can be modeled as dynamical systems where the evolution of the dynamical system represents the inference in ResNets (Chen et al., 2015; Chang et al., 2017; Sonoda & Murata, 2017; Chen et al., 2018; Lu et al., 2018). We connect this view to the theory of stochastic differential equations and construct an ensemble using a class of Ito processes with suitably bounded ˆ diffusion term. This Ito process ensemble exhibits remarkable robustness against adversarial attacks ˆ without any explicit adversarial training.
+
+# FROM RESNETS TO STOCHASTIC ITOˆ PROCESSES
+
+A building block of a residual neural network (He et al., 2016) with the residual mapping $\mathcal { F } ( \mathbf { x } ( i ) , \bar { \mathbf { W } } ( i ) )$ can be described using the following equation: $\mathbf { x } ( i + 1 ) = \mathcal { F } ( \mathbf { x } ( i ) , \mathbf { W } ( i ) ) + \bar { \mathbf { x } } ( i )$ . Here, ${ \bf x } ( i )$ is the input to the $i ^ { t h }$ residual network building block and $\mathbf { x } ( i + 1 )$ is the corresponding output that serves as an input to the next building block. The weights of the neural network layers in this ResNet building block are denoted by $\mathbf { W } ( i )$ .
+
+After taking suitable limits, the evolution of the ResNet can be described by the ResNet ordinary differential equation (ODE): $\begin{array} { r } { \frac { d \mathbf { x } ( t ) } { d t } = \mathcal { G } ( \mathbf { x } ( t ) , \mathbf { W } ( t ) ) } \end{array}$ . Here, $\begin{array} { r } { \mathcal { G } ( \mathbf { x } ( t ) , \mathbf { W } ( t ) ) = \operatorname* { l i m } _ { \delta t  0 } \frac { \mathcal { F } ( \mathbf { x } ( t ) , \mathbf { W } ( t ) ) } { \delta t } } \end{array}$ and ${ \bf x } ( 0 )$ is the input to the neural network. The ResNet ODE can be naturally generalized into an Ito process by using a Brownian motion term with diffusion coefficient ˆ $\Sigma ( t ) \dot { = } \overline { { ( \sigma _ { i j } ( t ) ) } }$ : $d { \bf x } ( t ) =$ $\mathcal { G } ( \bar { \mathbf { x } } ( t ) , \mathbf { W } ( t ) ) ~ d t + \bar { \Sigma } ( t ) ~ d B ( t )$ . There are two competing objectives here:
+
+• Very large values of the diffusion term $\Sigma ( t )$ can completely overshadow the drift term $\mathcal { G } ( \mathbf { x } ( t ) , \mathbf { W } ( t ) )$ leading to a poor accuracy even on benign inputs. When the diffusion term is very large, the paths of the Ito process can completely diverge from the solution of the ˆ original ResNet from which the Ito process was obtained. ˆ   
+Very small values of $\Sigma ( t )$ make the model closer to the original ResNet and equally non-robust. $\Sigma ( t ) = 0$ reproduces the original non-stochastic ResNet with no additional robustness. As we increase the diffusion term, the robustness of the neural network increases; this is experimentally demonstrated in Section 4.
+
+So, a natural question to ask is: How do we select the diffusion term $\Sigma ( t )$ such that the Ito process ˆ satisfies these two competing objectives of accuracy and robustness?
+
+At one hand, the generated Ito process must retain similar accuracy on benign models as the original ˆ ResNet, that is, its solutions are determined mainly by the term $\mathcal { G } ( \mathbf { \dot { x } } ( t ) , \mathbf { W } ( \bar { t } ) )$ and Brownian motion noise does not make it diverge significantly. On the other hand, the choice of added diffusion term $\Sigma ( t )$ must make the model robust enough to be resilient to adversarial perturbations on the inputs.
+
+ROBUSTNESS OF STOCHASTIC ITOˆ RESNET ENSEMBLES
+
+Given the Ito process ˆ ${ \bf x } ( t )$ satisfying the stochastic differential equation $d \mathbf { x } ( t ) = { \mathcal { G } } ( \mathbf { x } ( t ) , \mathbf { W } ( t ) ) d t + \Sigma ( t ) d { \dot { B } } ( t )$ , it is known (Oksendal, 1992) that the probability density $\boldsymbol { p } ( \mathbf { x } , t )$ can be mathematically characterized by the following equation:
+
+$$
+\frac { \mathrm { \partial } p ( \mathbf { x } , t ) } { \partial t } + \mathcal { G } ( \mathbf { x } , \mathbf { W } ) \nabla p ( \mathbf { x } , t ) = - p ( \mathbf { x } , t ) \sum _ { i } \frac { \partial \mathcal { G } } { \partial \mathbf { x } _ { i } } + \frac { 1 } { 2 } \sum _ { i } \sum _ { j } \frac { \partial ^ { 2 } } { \partial \mathbf { x } _ { i } \partial \mathbf { x } _ { j } } \left( ( \sum _ { k } \sigma _ { i k } ( t ) \sigma _ { j k } ( t ) ) p ( \mathbf { x } , t ) \right)
+$$
+
+map itself, that is For robust networks, the rate of change of the residual learning map is much smaller than the residual $\begin{array} { r } { \sum _ { i } \frac { \partial \mathcal { G } } { \partial \mathbf { x } _ { i } } < \eta _ { 1 } \mathcal { G } ( \mathbf { \bar { x } } , \mathbf { W } ) \frac { \nabla p ( \mathbf { x } , t ) } { p ( \mathbf { x } , t ) } } \end{array}$ for some small $\eta _ { 1 }  0$ . Hence, the probability density $\boldsymbol { p } ( \mathbf { x } , t )$ can be simplified to the following equation:
+
+$$
+\frac { \partial p ( { \bf x } , t ) } { \partial t } + ( 1 + \eta _ { 1 } ) \mathcal { G } ( { \bf x } , { \bf W } ) \nabla p ( { \bf x } , t ) = \frac { 1 } { 2 } \sum _ { i } \sum _ { j } \frac { \partial ^ { 2 } } { \partial { \bf x } _ { i } \partial { \bf x } _ { j } } \left( \left( \sum _ { k } \sigma _ { i k } ( t ) \sigma _ { j k } ( t ) \right) p ( { \bf x } , t ) \right)
+$$
+
+Using the fact that the double derivative of the probability density for robust neural networks is much smaller thfor some small an the re tself, that is 12 Pi Pj ∂2∂xi∂xj sidual map i, we choose $\begin{array} { r } { \frac { 1 } { 2 } \sum _ { i } \sum _ { j } \frac { \partial ^ { 2 } } { \partial \mathbf { x } _ { i } \partial \mathbf { x } _ { j } } \left( p ( \mathbf { x } , t ) \right) < \eta _ { 2 } \mathcal { G } ( \mathbf { x } , \mathbf { W } ) \frac { \nabla p ( \mathbf { x } , t ) } { p ( \mathbf { x } , t ) } } \end{array}$ $\eta _ { 2 }  0$ $\textstyle \sigma _ { i j } ( t ) \leq { \frac { \omega } { 1 + t } }$ $\omega$ probability density function of a ResNet with $n$ -dimensional inputs can be further simplified as
+
+$$
+\frac { \partial p ( { \bf x } , t ) } { \partial t } + ( 1 + \eta _ { 1 } - n \omega ^ { 2 } \eta _ { 2 } ) \mathcal { G } ( { \bf x } , { \bf W } ) \nabla p ( { \bf x } , t ) = 0
+$$
+
+As $\eta _ { 1 }  0$ and $\eta _ { 2 }  0$ for robust neural networks, our choice of $\textstyle \sigma _ { i j } ( t ) \leq { \frac { \omega } { 1 + t } }$ for a constant $\omega$ reduces the equation describing the probability density function to ∂p(x,t)∂t + G(x, W)∇p(x, t) = 0. Interpreting p(x, t) as a function that is constant along the trajectories of a ordinary differential equation i.e. dp(x,t)dt = 0, p(x, t) corresponds to the following differential equation: $\begin{array} { r } { \frac { d \mathbf { x } ( t ) } { d t } \ = \ \mathcal { G } ( \mathbf { x } ( t ) , \mathbf { W } ( t ) ) } \end{array}$ . Hence, under our choice of $\textstyle \sigma _ { i j } ( t ) \leq { \frac { \omega } { 1 + t } }$ for a constant $\omega$ , the solution to the stochastic differential equation agrees with the ResNet ODE for robust neural networks. Our implementation of the stochastic robust Ito ensemble of residual ˆ neural network is formed by discretizing the stochastic differential equation dx(t) = G(x(t), W(t)) dt + Σ(t) dB(t) with the constraint that σij (t) = ω1+t .
+
+# 4 RESULTS
+
+We train stochastic Ito ensembles of residual neural networks using both CIFAR-10 (Krizhevsky ˆ et al., 2014) and ImageNet (Deng et al., 2009) benchmarks. We evaluate the robustness of our stochastic Ito ensembles against two popular adversarial attacks: the fast gradient sign method ˆ (FGSM) (Szegedy et al., 2013) and the projected gradient descent (PGD) (Kurakin et al., 2016) under both $L _ { 2 }$ and $L _ { \infty }$ norms. We use the conformance in prediction of our Ito ensemble to exploit ˆ their robustness. If a majority of residual network models in our ensemble predict the same label for a given data item, the ensemble makes a prediction as this majority label. Otherwise, the stochastic Ito ensemble assigns no label and abstains from making any decision on the given input ˆ data. Our experiments indicate that this capability of the Ito ensemble to abstain from making ˆ decisions on non-conforming inputs not only helps defend the model against adversarial attacks, it also decreases incorrect predictions on benign data.
+
+# CIFAR-10 RESULTS
+
+Our experiments are performed on a 40-core 256GB RAM server with 4 NVIDIA V100 GPUs
+
+# Question 1: Does the Ito ensemble achieve competitive accuracy on benign inputs? ˆ
+
+We train the standard ResNet models on benign data and compare their accuracy with the accuracy of our stochastic Ito ensembles on benign data. We obtain the stochastic ResNet models in the ˆ stochastic Ito ensemble by starting with the weights of a standard ResNet model and training them ˆ for 40 epochs with a learning rate of 0.0001 using the Adam optimizer. Table 2 compares the accuracy of the standard model with Ito ensembles. ˆ
+
+<table><tr><td>Architecture</td><td colspan="2">Accuracy (%)</td><td colspan="2">Incorrect Prediction (%)</td><td rowspan="2">Correct + Abstention (%) Ito Ensemble (%)</td></tr><tr><td></td><td>Original</td><td>Ito Ensemble</td><td>Original</td><td>Itó Ensemble</td></tr><tr><td>ResNet-18</td><td>93.33</td><td>91.51</td><td>6.67</td><td>5.72</td><td>94.28</td></tr><tr><td>ResNet-34</td><td>92.92</td><td>91.33</td><td>7.08</td><td>5.80</td><td>94.20</td></tr><tr><td>ResNet-50</td><td>93.86</td><td>91.59</td><td>6.14</td><td>4.64</td><td>95.29</td></tr></table>
+
+Table 2: Our stochastic Ito ensembles and the standard ResNet neural network architectures haveˆ similar accuracy on CIFAR-10 test data. Because of its ability to abstain from assigning a label when majority of predictions do not conform, the fraction of data where the Ito ensemble predicts ˆ an incorrect label is lower that the fraction of data where the original ResNet model is incorrect.
+
+Our stochastic Ito ensembles ofˆ 20 models in Table 2 are trained using a diffusion term corresponding to $\omega ~ = ~ 0 . 2$ . 20 inferences are obtained from each stochastic model in our Itoˆ ensemble. The accuracy of the stochastic Ito ensembles on CIFAR-10 test data is comparable to ˆ that of the standard models on three ResNet architectures: ResNet-18, ResNet-34, and ResNet-50. Our stochastic Ito ensemble abstains when a majority of the ensemble models do not agree on a ˆ single prediction. This lowers the incorrect predictions of Ito ensemble compared to the original ˆ model. As shown in Figure 1, some of the correct predictions by original ResNet are on images with high aleatoric uncertainty on which Ito ensemble correctly abstains. ˆ
+
+# Question 2: Is the stochastic Ito ensemble robust against adversarial attacks? ˆ
+
+We train stochastic Ito ensembles of 20 ResNet-50 models on CIFAR-10 data with diffusion terms ˆ corresponding to $\omega = 0 . 2$ and $\omega = 0 . 4$ . 20 independent inferences are drawn from each stochastic model in the Ito ensemble. We evaluate the robustness of our stochastic It ˆ o ensemble against FGSM ˆ and PGD under both $L _ { 2 }$ and $L _ { \infty }$ norms. We compare the accuracy of predictions from our stochastic Ito ensembles with that of Madry’s robustness toolbox (Engstrom et al., 2020). ˆ
+
+<table><tr><td>E</td><td>Accuracy for PGD (%)</td><td>Correct + Abstention for PGD (%)</td><td>Accuracy for FGSM (%)</td><td>Correct + Abstention for FGSM (%)</td></tr><tr><td>0.2</td><td>91.34</td><td>94.83</td><td>91.41</td><td>94.93</td></tr><tr><td>0.5</td><td>90.37</td><td>94.53</td><td>90.78</td><td>94.87</td></tr><tr><td>1.0</td><td>86.39</td><td>91.41</td><td>89.22</td><td>93.82</td></tr><tr><td>2.0</td><td>73.91</td><td>79.80</td><td>83.31</td><td>89.41</td></tr></table>
+
+Table 3: The accuracy of our stochastic Ito ensemble with diffusion term corresponding to ˆ $\omega = 0 . 2$ on the PGD attack for different values of $\epsilon$ under the $L _ { 2 }$ norm.
+
+Robustness under the $L _ { 2 }$ norm. The accuracy of our stochastic Ito ensembles on the fast gradient ˆ sign method (FGSM) (Szegedy et al., 2013) and the projected gradient descent (PGD) (Kurakin et al., 2016) under the $L _ { 2 }$ norm is shown in Table 3. Our stochastic Ito ensembles use the ResNet-50 ˆ architecture with the diffusion term corresponding to $\omega = 0 . 2$ .
+
+Our stochastic Ito ensemble approach with a diffusion terms corresponding to ˆ $\omega = 0 . 2$ shows an accuracy of $7 3 . 9 1 \%$ against the PGD attack with $\epsilon = 2 . 0$ under the $L _ { 2 }$ norm. This compare favorably with the $1 8 . 5 9 \%$ accuracy of Madry’s robustness toolbox on the same PGD attack. The accuracy of our stochastic Ito ensemble approach improves to ˆ $7 9 . 0 7 \%$ when the diffusion term corresponds to $\omega = 0 . 4$ . Further, the sum of correct labels and abstentions from our Ito ensemble approach is ˆ $8 8 . 4 3 \%$ against the PGD attack with $\epsilon = 2 . 0$ under the $L _ { 2 }$ norm.
+
+![](images/73db714b5b8a9637033c38ef79b706340e1d993d9ff32a9950e1ff1232084cfa.jpg)  
+Figure 2: The accuracy of our stochastic Ito ensemble with a diffusion term corresponding to ˆ $\omega =$ 0.2 (left) and $\omega = 0 . 4$ (right) on CIFAR-10 compares favorably with Madry’s Robustness Toolbox using the $L _ { 2 }$ norm for different values of $\epsilon$ .
+
+Figure 2 shows the accuracy of our Ito ensemble approach and compares it with the accuracy of ˆ Madry’s robustness toolbox (Engstrom et al., 2020) on CIFAR-10 test data. Both our stochastic Ito ensembles with ˆ $\omega = 0 . 2$ and $\omega = 0 . 4$ have higher accuracy on benign data and their accuracy remains higher than Madry’s robustness toolbox for all values of $\epsilon$ under the $L _ { 2 }$ norm. The accuracy of the Ito ensemble degrades more gracefully as the value of ˆ $\epsilon$ increases under the $L _ { 2 }$ norm.
+
+Robustness under the $L _ { \infty }$ norm. We investigate the accuracy of our stochastic Ito ensemble ˆ approach under the $L _ { \infty }$ norm and compare it to the accuracy of Madry’s robustness toolbox. Table 4 shows the accuracy of our Ito ensemble with diffusion term corresponding to ˆ $\omega = 0 . 2$ .
+
+<table><tr><td>E</td><td>Accuracy for PGD (%)</td><td>Correct + Abstention for PGD (%)</td><td>Accuracy for FGSM (%)</td><td>Correct + Abstention for FGSM (%)</td></tr><tr><td>4 255</td><td>85.82</td><td>92.91</td><td>86.02</td><td>93.00</td></tr><tr><td>8 255</td><td>84.60</td><td>92.48</td><td>85.24</td><td>92.84</td></tr><tr><td>16 255</td><td>79.66</td><td>89.06</td><td>82.74</td><td>91.20</td></tr><tr><td>32 255</td><td>62.97</td><td>74.05</td><td>72.49</td><td>84.08</td></tr></table>
+
+Table 4: The accuracy of our stochastic Ito ensemble with diffusion term corresponding to ˆ $\omega = 0 . 2$ on the PGD attack for different values of $\epsilon$ under the $L _ { \infty }$ norm.
+
+We study the performance of our stochastic Ito ensemble on PGD and FGSM and attacks of varying ˆ magnitudes under the $L _ { \infty }$ norm, and determine that our stochastic Ito ensemble is robust against ˆ adversarial noise. Figure 3 shows the accuracy of Madry’s robustness toolbox and our Ito ensemble ˆ on adversarial images under the PGD attack. The accuracy of our stochastic Ito ensemble with ˆ diffusion term corresponding to $\omega = 0 . 4$ is higher than that of the model from Madry’s toolbox for both the original unperturbed images and PGD adversarial images with $\epsilon = 8 / 2 5 5$ and $\epsilon = 1 6 / 2 5 5$ .
+
+# Question 3: How does the robustness of the stochastic Ito ensemble approach change with the ˆ number of models in the ensemble and the number of inferences?
+
+The Ito ensemble has two sources of diversity - different stochastic models and multiple inferences ˆ on the same model. We investigate the accuracy of our Ito ensemble with different number of ˆ stochastic models and different number of inferences from each stochastic model. Figure 4 (left) illustrates the results of our investigations. A significant increase of $5 . 1 \%$ is observed for the sum of correct outcomes and abstentions by increasing the number of stochastic models from 3 to 20 and the number of sampled independent inferences for each stochastic model from 3 to 20. Increasing the number of stochastic models in the ensemble has more significant influence on the performance of the Ito ensemble than increasing the number of independent inferences from each stochastic model. ˆ
+
+![](images/8e6fb227444f94e631b31f923b7f994419a2350bbea61dae1d1b4df91709e6e0.jpg)  
+Figure 3: The accuracy of our stochastic Ito ensemble on CIFAR-10 compares favorably withˆ Madry’s Robustness Toolbox using the $L _ { \infty }$ norm. (left) $\omega = 0 . 2$ (right) $\omega = 0 . 4$ .
+
+![](images/069a158f9f8721be1248155639fd870d1b9c30fb5fa3bdb99692a524a67895e6.jpg)  
+Figure 4: (left) The impact of the number of models and inferences on the sum of correct outcomes and abstentions for our stochastic Ito ensemble with ˆ $\omega = 0 . 4$ . (right) Diffusion with different values of $\omega$ in stochastic Ito ensemble vs. PGD accuracy under the ˆ $L _ { \infty }$ norm.
+
+# Question 4: How can we control the diffusion term $\omega$ to trade-off robustness and accuracy?
+
+Figure 4 (right) shows the effect of varying diffusion terms with different $\omega$ on the accuracy of the stochastic Ito ensemble under the ˆ $L _ { \infty }$ norm for PGD attacks with $\epsilon = 8 / 2 5 5 , 1 6 / 2 5 5$ and 32/255. The accuracy of the stochastic Ito ensemble first increases as the value ofˆ $\omega$ increases and then starts decreasing for any given value of $\omega$ . This shows a tradeoff between the accuracy of the neural network on benign data and its ability to be robust to large adversarial perturbations.
+
+# IMAGENET RESULTS
+
+These experiments are performed on a 92-core 480GB RAM server with 8 NVIDIA V100 GPUs.
+
+# Question 1: Does the Ito ensemble achieve competitive accuracy on benign inputs? ˆ
+
+We study the accuracy of our Ito ensemble of 5 ResNet-50 models with 20 independent inferences ˆ per model for different values of $\omega$ and associated diffusion terms. As shown in Table 5, small values of $\omega$ do not significantly reduce the accuracy of the Ito ensemble on benign data. ˆ
+
+# Question 2: Is the Ito ensemble approach robust against adversarial attacks? ˆ
+
+Figure 5 shows the accuracy of our stochastic Ito ensemble approach on ImageNet against the PGD ˆ attack with various values of $\epsilon$ under $L _ { 2 }$ as well as $L _ { \infty }$ norms. The accuracy of our Ito ensemble ˆ compares favorably with the results from Madry’s robustness toolbox Engstrom et al. (2020).
+
+Table 5: Accuracy of Ito ensembles on benign data with diffusion corresponding to different ˆ $\omega$   
+
+<table><tr><td>Diffusion Term w</td><td>Original Accuracy</td><td>Itó Ensemble Accuracy</td><td>% Decrease in Accuracy</td><td>Correct + Abstentions (%)</td></tr><tr><td>0.1</td><td>76.13</td><td>76.04</td><td>0.09</td><td>77.87</td></tr><tr><td>0.2</td><td>76.13</td><td>73.59</td><td>2.54</td><td>78.29</td></tr><tr><td>0.3</td><td>76.13</td><td>67.79</td><td>8.34</td><td>76.40</td></tr><tr><td>0.4</td><td>76.13</td><td>61.66</td><td>14.47</td><td>76.42</td></tr></table>
+
+![](images/21162b88fb4ee53ccc2c070dd16b40f76e3af9b8a9bd3276f4cb2b4c88ffdb94.jpg)  
+Figure 5: The accuracy of our stochastic Ito ensemble with ˆ $\omega { = } 0 . 2$ on ImageNet compares favorably with Robustness Toolbox using the $L _ { 2 }$ norm (left) and the $L _ { \infty }$ norm (right) for different values of $\epsilon$
+
+# Question 3: How can we control the diffusion term $\omega$ to trade-off robustness and accuracy?
+
+Table 5 and Table 6 show that the diffusion parameter $\omega$ can be used to establish a desired trade-off between robustness and benign accuracy for the ImageNet data set.   
+
+<table><tr><td>Diffusion Term w</td><td>Ito Ensemble Benign Accuracy (%)</td><td>Ito Ensemble PGD Accuracy (%)</td><td>Correct + Abstentions (%)</td></tr><tr><td>0.1</td><td>76.04</td><td>26.23</td><td>27.89</td></tr><tr><td>0.2</td><td>73.59</td><td>53.42</td><td>61.32</td></tr><tr><td>0.3</td><td>67.79</td><td>60.11</td><td>70.01</td></tr><tr><td>0.4</td><td>61.66</td><td>58.57</td><td>73.55</td></tr></table>
+
+Table 6: Accuracy of our Ito ensemble approach on PGD attack ˆ $( \epsilon = 8 / 2 5 5 )$ with different diffusion parameters $\omega$ . Higher values of $\omega$ lead to more robust models.
+
+# 5 CONCLUSION
+
+We have shown that ensembles of neural networks corresponding to a class of Ito processes are ˆ more robust than classical residual networks. An Ito process obtained by solving a ˆ suitably-formulated stochastic differential equation derived from a residual network has a probability density function that is robust to adversarial input perturbations. Further, the achieved robustness does not require any explicit adversarial training; hence, it is likely to generalize to unforeseen attacks. We empirically evaluated the robustness of our Ito ensembles and demonstrated ˆ that they achieve higher accuracy under FGSM/PGD attacks over the $L _ { 2 } / L _ { \infty }$ norm compared to state-of-the-art methods. This robustness is attained without significantly sacrificing accuracy on benign data. Further, Ito ensemble abstains on benign inputs with high uncertainty reflecting ˆ uncertainty-aware learning. Our paper is a step towards the use of Ito processes and stochastic ˆ differential equation models to build robust ensembles in deep learning. This will aid the adoption of deep learning in safety-critical applications.
+
+# REFERENCES
+
+Linda JS Allen. An introduction to stochastic processes with applications to biology. CRC Press, 2010.
+
+Adam Arkin, John Ross, and Harley H McAdams. Stochastic kinetic analysis of developmental pathway bifurcation in phage $\lambda$ -infected escherichia coli cells. Genetics, 149(4):1633–1648, 1998.
+
+Mislav Balunovic and Martin Vechev. Adversarial training and provable defenses: Bridging the gap. In International Conference on Learning Representations, 2020.
+
+Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, et al. End to end learning for self-driving cars. arXiv preprint arXiv:1604.07316, 2016.
+
+Paul C Bressloff. Stochastic processes in cell biology, volume 41. Springer, 2014.
+
+Bo Chang, Lili Meng, Eldad Haber, Frederick Tung, and David Begert. Multi-level residual networks from dynamical systems view. arXiv preprint arXiv:1710.10348, 2017.
+
+Ricky TQ Chen, Yulia Rubanova, Jesse Bettencourt, and David K Duvenaud. Neural ordinary differential equations. In Neural information processing systems, pp. 6571–6583, 2018.
+
+Yunjin Chen, Wei Yu, and Thomas Pock. On learning optimized reaction diffusion processes for effective image restoration. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 5261–5269, 2015.
+
+Jeffrey De Fauw, Joseph R Ledsam, Bernardino Romera-Paredes, Stanislav Nikolov, Nenad Tomasev, Sam Blackwell, Harry Askham, Xavier Glorot, Brendan O’Donoghue, Daniel Visentin, et al. Clinically applicable deep learning for diagnosis and referral in retinal disease. Nature medicine, 24(9):1342–1350, 2018.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A largescale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009.
+
+Souradeep Dutta, Susmit Jha, Sriram Sankaranarayanan, and Ashish Tiwari. Output range analysis for deep feedforward neural networks. In NASA Formal Methods Symposium, pp. 121–138. Springer, 2018.
+
+Krishnamurthy Dvijotham, Robert Stanforth, Sven Gowal, Timothy A Mann, and Pushmeet Kohli. A dual approach to scalable verification of deep networks. In UAI, volume 1, pp. 2, 2018.
+
+Logan Engstrom, Andrew Ilyas, Hadi Salman, Shibani Santurkar, and Dimitris Tsipras. Robustness: A library for experimenting with, training and evaluating neural networks, with a focus on adversarial robustness., 2020. URL https://github.com/MadryLab/robustness.
+
+Georgia Gkioxari, Ross Girshick, and Jitendra Malik. Contextual action recognition with $\mathbf { r } ^ { * }$ cnn. In Proceedings of the IEEE international conference on computer vision, pp. 1080–1088, 2015.
+
+Didier Gonze, Jose Halloy, and Albert Goldbeter. Deterministic versus stochastic models for ´ circadian rhythms. Journal of biological physics, 28(4):637–653, 2002.
+
+Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On calibration of modern neural networks. arXiv preprint arXiv:1706.04599, 2017a.
+
+Chuan Guo, Mayank Rana, Moustapha Cisse, and Laurens Van Der Maaten. Countering adversarial images using input transformations. arXiv preprint arXiv:1711.00117, 2017b.
+
+Awni Hannun, Carl Case, Jared Casper, Bryan Catanzaro, Greg Diamos, Erich Elsen, Ryan Prenger, Sanjeev Satheesh, Shubho Sengupta, Adam Coates, et al. Deep speech: Scaling up end-to-end speech recognition. arXiv preprint arXiv:1412.5567, 2014.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pp. 770–778, 2016.
+
+Dan Hendrycks and Kevin Gimpel. A baseline for detecting misclassified and out-of-distribution examples in neural networks. arXiv preprint arXiv:1610.02136, 2016.
+
+Andrew Ilyas, Ajil Jalal, Eirini Asteri, Constantinos Daskalakis, and Alexandros G Dimakis. The robust manifold defense: Adversarial training using generative models. arXiv preprint arXiv:1712.09196, 2017.
+
+Uyeong Jang, Susmit Jha, and Somesh Jha. On the need for topology-aware generative models for manifold-based defenses. In International Conference on Learning Representations, 2020.
+
+Hiroaki Kitano. Biological robustness. Nature Reviews Genetics, 5(11):826–837, 2004.
+
+Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. The CIFAR-10 dataset. online: http://www. cs. toronto. edu/kriz/cifar. html, 55, 2014.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016.
+
+Alex Lamb, Jonathan Binas, Anirudh Goyal, Dmitriy Serdyuk, Sandeep Subramanian, Ioannis Mitliagkas, and Yoshua Bengio. Fortified networks: Improving the robustness of deep networks by modeling the manifold of hidden representations. arXiv preprint arXiv:1804.02485, 2018.
+
+Yiping Lu, Aoxiao Zhong, Quanzheng Li, and Bin Dong. Beyond finite layer neural networks: Bridging deep architectures and numerical differential equations. In International Conference on Machine Learning, pp. 3276–3285. PMLR, 2018.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Navonil Majumder, Soujanya Poria, Alexander Gelbukh, and Erik Cambria. Deep learning-based document modeling for personality detection from text. IEEE Intelligent Systems, 32(2):74–79, 2017.
+
+Maria-Irina Nicolae, Mathieu Sinn, Minh Ngoc Tran, Beat Buesser, Ambrish Rawat, Martin Wistuba, Valentina Zantedeschi, Nathalie Baracaldo, Bryant Chen, Heiko Ludwig, et al. Adversarial robustness toolbox v1. 0.0. arXiv preprint arXiv:1807.01069, 2018.
+
+Bernt Oksendal. Stochastic Differential Equations (3rd Ed.): An Introduction with Applications. Springer-Verlag, Berlin, Heidelberg, 1992. ISBN 3387533354.
+
+Tianyu Pang, Kun Xu, Chao Du, Ning Chen, and Jun Zhu. Improving adversarial robustness via promoting ensemble diversity. volume 97 of Proceedings of Machine Learning Research, pp. 4970–4979, Long Beach, California, USA, 09–15 Jun 2019. PMLR. URL http:// proceedings.mlr.press/v97/pang19a.html.
+
+Aditi Raghunathan, Jacob Steinhardt, and Percy Liang. Certified defenses against adversarial examples. arXiv preprint arXiv:1801.09344, 2018.
+
+Sho Sonoda and Noboru Murata. Double continuum limit of deep neural networks. In ICML Workshop Principled Approaches to Deep Learning, volume 1740, 2017.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Florian Tramer, Alexey Kurakin, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick\` McDaniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017.
+
+E Weinan. A proposal on machine learning via dynamical systems. Communications in Mathematics and Statistics, 5(1):1–11, 2017.
+
+Eric Wong, Frank Schmidt, Jan Hendrik Metzen, and J Zico Kolter. Scaling provable adversarial defenses. In Advances in Neural Information Processing Systems, pp. 8400–8409, 2018.
+
+Cihang Xie, Yuxin Wu, Laurens van der Maaten, Alan L Yuille, and Kaiming He. Feature denoising for improving adversarial robustness. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 501–509, 2019.
+
+Huan Zhang, Hongge Chen, Chaowei Xiao, Sven Gowal, Robert Stanforth, Bo Li, Duane Boning, and Cho-Jui Hsieh. Towards stable and efficient training of verifiably robust neural networks. arXiv preprint arXiv:1906.06316, 2019.

md/train/LwyBkw8Nh6Y1J/LwyBkw8Nh6Y1J.md

@@ -0,0 +1,212 @@
+# Unit Tests for Stochastic Optimization
+
+# Tom Schaul
+
+# Ioannis Antonoglou
+
+David Silver
+
+DeepMind Technologies 130 Fenchurch Street, London, UK {tom,ioannis,david}@deepmind.com
+
+# Abstract
+
+Optimization by stochastic gradient descent is an important component of many large-scale machine learning algorithms. A wide variety of such optimization algorithms have been devised; however, it is unclear whether these algorithms are robust and widely applicable across many different optimization landscapes. In this paper we develop a collection of unit tests for stochastic optimization. Each unit test rapidly evaluates an optimization algorithm on a small-scale, isolated, and well-understood difficulty, rather than in real-world scenarios where many such issues are entangled. Passing these unit tests is not sufficient, but absolutely necessary for any algorithms with claims to generality or robustness. We give initial quantitative and qualitative results on numerous established algorithms. The testing framework is open-source, extensible, and easy to apply to new algorithms.
+
+# 1 Introduction
+
+Stochastic optimization [1] is among the most widely used components in large-scale machine learning, thanks to its linear complexity, efficient data usage, and often superior generalization [2, 3, 4]. In this context, numerous variants of stochastic gradient descent have been proposed, in order to improve performance, robustness, or reduce tuning effort [5, 6, 7, 8, 9]. These algorithms may derive from simplifying assumptions on the optimization landscape [10], but in practice, they tend to be used as general-purpose tools, often outside of the space of assumptions their designers intended. The troublesome conclusion is that practitioners find it difficult to discern where potential weaknesses of new (or old) algorithms may lie [11], and when they are applicable – an issue that is separate from raw performance. This results in essentially a trial-and-error procedure for finding the appropriate algorithm variant and hyper-parameter settings, every time that the dataset, loss function, regularization parameters, or model architecture change [12].
+
+The objective of this paper is to establish a collection of benchmarks to evaluate stochastic optimization algorithms and guide algorithm design toward robust variants. Our approach is akin to unit testing, in that it evaluates algorithms on a very broad range of small-scale, isolated, and wellunderstood difficulties, rather than in real-world scenarios where many such issues are entangled. Passing these unit tests is not sufficient, but absolutely necessary for any algorithms with claims to generality or robustness. This is a similar approach to the very fruitful one taken by the black-box optimization community [13, 14].
+
+The core assumption we make is that stochastic optimization algorithms are acting locally, that is, they aim for a short-term reduction in loss given the current noisy gradient information, and possibly some internal variables that capture local properties of the optimization landscape. These local actions include both approaching nearby optima, and navigating slopes, valleys or plateaus that are far from an optimum. The locality property stems from computational efficiency concerns, but it has the additional benefits of minimizing initialization bias and allowing for non-stationary optimization, because properties of the obervation surface observed earlier in the process (and their conseuences for the algorithm state) are quickly forgotten. We therefore concentrate on building local unit tests, that investigate algorithm dynamics on a broad range of local scenarios, because we expect that detecting local failure modes will flag an algorithm as unlikely to be robust on more complex tasks – and as a first approximation, optimization on such a complex task can be seen as a sequence of many smaller optimization problems (many of which will not have local optima).
+
+![](images/f14b3d6f0db7c2017f3921391274b02737a8918629e982e60ebf7c0f55b07c7b.jpg)  
+Figure 1: Some one-dimensional shape prototypes. The first six example shapes are atomic prototypes: a quadratic bowl, an absolute value, a cliff with a non differential point after which the derivative increases by a factor ten, a rectified linear shape followed by a bend, an inverse Gaussian, an inverse Laplacian. The next six example shapes are concatenations of atomic prototypes: a sigmoid as a concatenation of a non convex Gaussian a line and an exponential, a quadratic bowl followed by a cliff and then by an exponential function, a quadratic bowl followed by a cliff and another quadratic bowl, a sinusoid as a concatenation of quadratic bowls, a line followed by a Gaussian bowl, a quadratic bowl and a cliff and finally, a Laplace bowl followed by a cliff and another Laplace bowl.
+
+Our divide-and-conquer approach consists of disentangling potential difficulties and testing them in isolation or in simple couplings. Given that our unit tests are small and quick to evaluate, we can have a much larger collection of them, testing hundreds of qualitatively different aspects in less time than it would take to optimize a single traditional benchmark to convergence, thus allowing us to spot and address potential weaknesses early.
+
+Our main contribution is a testing framework, with unit tests designed to test aspects such as: discontinuous or non-differentiable surfaces, curvature scales, various noise conditions and outliers, saddle-points and plateaus, cliffs and asymmetry, and curl and bootstrapping. It also allows test cases to be concatenated by chaining them in a temporal series, or by combining them into multidimensional unit tests (with or without variable coupling). We give initial quantitative and qualitative results on a number of established algorithms.
+
+We do not expect this to replace traditional benchmark domains that are closer to the real-world, but to complement it in terms of breadth and robustness. We have tried to keep the framework general and extendable, in the hope it will further grow in diversity, and help others in doing robust algorithm design.
+
+# 2 Unit test Construction
+
+Our testing framework is an open-source library containing a collection of unit tests and visualization tools. Each unit test is defined by a prototype function to be optimized, a prototypical scale, a noise prototype, and optionally a non-stationarity prototype. A prototype function is the concatenation of one or more local shape prototypes. A multi-dimensional unit test is a composition of onedimensional unit tests, optionally with a rotation prototype or curl prototype.
+
+# 2.1 Shape Prototypes
+
+Shape prototypes are functions defined on an interval, and our collection includes linear slopes (zero curvature), quadratic curves (fixed curvature), convex or concave curves (varying curvature), and curves with exponentially increasing or decreasing slope. Further, there are a number of nondifferentiable local shape prototypes (absolute value, rectified-linear, cliff). All of these occur in realistic learning scenarios, for example in logistic regression the loss surface is part concave and part convex, an MSE loss is the prototypical quadratic bowl, but then regularization such as L1 introduces non-differentiable bends (as do rectified-linear or maxout units in deep learning [15, 16]). Steep cliffs in the loss surface are a common occurrence when training recurrent neural networks, as discussed in [11]. See the top rows of Figure 1 for some examples of shape prototypes.
+
+# 2.2 One-dimensional Concatenation
+
+In our framework, we can chain together a number of shape prototypes, in such a way that the resulting function is continuous and differentiable at all junction points. We can thus produce many prototype functions that closely mimic existing functions, e.g., the Laplace function, sinusoids, saddlepoints, step-functions, etc. See the bottom rows of Figure 1 for some examples.
+
+A single scale parameter determines the scaling of a concatenated function across all its shapes using the junction constraints. Varying the scales is an important aspect of testing robustness because it is not possible to guarantee well-scaled gradients without substantial overhead. In many learning problems, effort is put into proper normalization [17], but that is insufficient to guarantee homogeneous scaling, for example throughout all the layers of a deep neural network.
+
+# 2.3 Noise Prototypes
+
+The distinguishing feature of stochastic gradient optimization (compared to batch methods) is that it relies on sample gradients (coming from a subset of even a single element of the dataset) which are inherently noisy. In out unit tests, we model this by four types of stochasticity:
+
+• Scale-independent additive Gaussian noise on the gradients, which is equivalent to random translations of inputs in a linear model with MSE loss. Note that this type of noise flips the sign of the gradient near the optimum and makes it difficult to approach precisely. Multiplicative (scale-dependent) Gaussian noise on the gradients, which multiplies the gradients by a positive random number (signs are preserved). This corresponds to a learning scenario where the loss curvature is different for different samples near the current point. • Additive zero-median Cauchy noise, mimicking the presence of outliers in the dataset. • Mask-out noise, which zeros the gradient (independently for each dimension) with a certain probability. This mimics both training with drop-out [18], and scenarios with rectified linear units where a unit will be inactive for some input samples, but not for others.
+
+For the first three, we can vary the noise scale, while for mask-out we pick a drop-out frequency. This noise is not necessarily unbiased (as in the Cauchy case), breaking common assumptions made in algorithm design (but the modifications in section 2.5 are even worse). See Figure 2 for an illustration of the first two noise prototypes. Noise prototypes and prototype functions can be combined independently into one-dimensional unit tests.
+
+![](images/506088503700b5806cf79203f514873534687e1c86ed16c5d3bb931076328867.jpg)  
+Figure 2: Examples of noise applied on prototype functions, green dashed are typical sample gradients, and the standard deviation range is the blue area. The upper two subplots depict Gaussian additive noise, while the lower two show Gaussian multiplicative noise. In the left column, the noise is applied to the gradients of a quadratic bowl prototype (note how the multiplicative noise goes to zero around the optimum in the middle), and on the right it is applied to a concatenation of prototypes.
+
+# 2.4 Multi-dimensional Composition
+
+A whole range of difficulties for optimization only exist in higher dimensional parameter spaces (e.g., saddle points, conditoning, correlation). Therefore, we build high-dimensional unit tests by composing together one-dimensional unit tests. For example for two one-dimensional prototype shapes $\mathcal { L } _ { a }$ and $\mathcal { L } _ { b }$ combined with a $p$ -norm, the composition is $\begin{array} { r } { \mathcal { L } _ { ( a , b ) } ( \theta ) = ( \mathcal { L } _ { a } ( \theta _ { 1 } ) ^ { p } + \mathcal { L } _ { b } ( \theta _ { 2 } ) ^ { p } ) ^ { \frac { 1 } { p } } } \end{array}$ . Noise prototypes are composed independently of shape prototypes. While they may be composed of concatenated one-dimensional prototypes, higher-dimensional prototypes are not concatenated themselves. Various levels of conditioning can be achieved by having dramatically different scales in different component dimensions.
+
+In addition to the choice of prototypes to be combined, and their scale, we permit a rotation in input space, which couples the dimensions together and avoids axis-alignment. These rotations are particularly important for testing diagonal/element-wise optimization algorithms.
+
+# 2.5 Curl
+
+In reinforcement learning a value function (the expected discounted reward for each state) can be learned using temporal-difference learning (TD), an update procedure that uses bootstrapping: i.e. it pulls the value of the current state towards the value of its successor state [19]. These stochastic update directions are not proper gradients of any scalar energy field [20], but they still form a (more general) vector field with non-zero curl, where the objective for the optimization algorithm is to converge to its fixed-point(s). See Figure 4 for a detailed example. We implemented this aspect by allowing different amounts of curl to be added on top of a multi-dimensional vector field in our unit tests, which is done by rotating the produced gradient vectors using a fixed rotation matrix. This is reasonably realistic; in fact, for the TD example in Figure 4, the resulting vector field is exactly the gradient field of a quadratic combined with a (small-angle) rotation.
+
+# 2.6 Non-stationarity
+
+In many settings it is necessary to optimize a non-stationary objective function. This may typically occur in a non-stationary task where the problem to be solved changes over time. However, nonstationary optimization can even be important in large stationary tasks (with temporal structure in the samples), when the algorithm chooses to track a particular dynamic aspect of the problem, rather than attempting to converge to a global but static solution of the problem [21]. In addition, reinforcement learning (RL) tasks often involve non-stationary optimization. For example, many RL algorithms proceed by evaluating the value function using the TD algorithm described in the previous section. This results in two sources of non-stationarity: the target value changes at every step (resulting in the previously described curl); and also the state distribution changes as the value function improves and better actions are selected. These scenarios can be therefore be viewed as non-stationary loss functions, but whose optimum moves as a function of the current parameter values.
+
+![](images/c499d54b95076dc38072d7c065a7038b4b38eedd8e01116bcdf75e6a5820c2b2.jpg)  
+Figure 3: Examples of multivariate prototypes. The first subplot depicts an asymmetric quadratic bowl with correlated dimensions, the second a surface with a saddle point, the third a sharp valley surface, the fourth a half-pipe surface where the first dimension is a line and the second one a quadratic bowl. The fifth subplot depicts a surface with an ill conditioned minimum in the point where the two canyons overlap. The surface in the last subplot is the composition of a quadratic bowl in the first dimension and of a cliff in the second.
+
+![](images/fc0c8ec15c37bd504b5686efed19778eab13973e72bbbf0e0ed2f67eb8467687.jpg)  
+Figure 4: Here, we consider a very simple Markov process, with two states and stochastic transitions between them, and a reward of 0 in the first and of 1 in the second state. Consider the parameters of our optimization $\theta$ to be the two state values. Each TD update changes one of them, depending on the stochastic transition observed. In this figure, we plot the vector field of expected update directions (blue arrows) as a function of $\theta$ , as well as one sampled trajectory of the TD algorithm. Note how this vector field is not actually a gradient field, but instead has substantial curl, making it a challenging stochastic optimization task.
+
+We test non-stationarity in three different ways. We let the location of the optimum move smoothly, via random translations of the parameter space, or we let the the scale of the shape prototype vary randomly (on average by $10 \%$ in each direction), or, on noisy unit tests, we let the scale of the noise vary randomly. Currently, these changes happen once every 10 steps. A type of non-stationarity that involves more abrupt switching is discussed in section 4.1.
+
+# 3 Experiments
+
+# 3.1 Setup and Algorithms
+
+For our experiments, we test the candidate algorithms on over 3000 unit tests, with up to 10 parameter dimensions. Each algorithm-unit test pairing is repeated 10 times, but with reusing the same 10 random seeds across all algorithms and setups. For eat the parameter value reached after 100 update steps $k$ te the true expected loss. $\mathcal { L } ^ { ( k ) } = \mathbb { E } \left[ \mathcal { L } \left( \theta _ { 1 0 0 } ^ { ( k ) } \right) \right]$
+
+The algorithms evaluated are SGD with fixed learning rate $\eta _ { 0 } \in [ 1 0 ^ { - 6 } , 1 0 ]$ , SGD with annealing with decay factor in $[ 1 0 ^ { - 2 } , 1 ]$ and initial rates $\eta _ { 0 }$ , SGD with momentum (regular or Nesterov’s variant [22]) [0.1, 0.999] and initial rates $\eta _ { 0 }$ , SGD with parameter averaging $[ ]$ with decay term in $[ 1 0 ^ { - 4 } , 0 . 5 ]$ and exponent in $\left\{ { \frac { 1 } { 2 } } , { \frac { 3 } { 4 } } , 1 \right\}$ , ADAGRAD [10] with initial rates $\eta _ { 0 }$ , ADADELTA [23] with decay parameter $( 1 - \gamma ) \in [ 1 0 ^ { - 4 } , 0 . 5 ]$ and regularizer in $[ 1 0 ^ { - 6 } , 1 0 ^ { - 2 }$ , the incremental delta-bardelta algorithm (IDBD [24]), RPROP [25] with initial stepsizes $\eta _ { 0 }$ , RMSprop [26] with minimal learning rates $\eta _ { 0 }$ , maximal learning rates in $[ 1 0 , 1 0 ^ { 3 } ]$ and decay parameter $\gamma$ , as well as conjugate gradients. For the hyper-parameters ranges, we always consider one value per order of magnitude, and exhaustively sweep all combinations.
+
+# 3.2 Reference performance
+
+Each unit test is associated with a reference performance $\mathcal { L } _ { s g d }$ , and a corresponding reference learning rate $\eta _ { b e s t }$ that is determined by doing a parameter sweep over all fixed learning rates for SGD (34 values log-uniform between $1 \dot { 0 } ^ { - 1 0 }$ and 10) and retaining the best-performing one.
+
+In our aggregate plots, unit tests are sorted (per group) by their reference learning rate, i.e., those that require small steps on the left, and those where large steps are best on the right. Algorithm setups are sorted as well, on the vertical axis, by their median performance on a reference unit test (quadratic, additive noise).
+
+# 3.3 Qualitative Evaluation
+
+The algorithm performance $\mathcal { L } ^ { ( k ) }$ is converted to a normalized value $\begin{array} { r } { \mathcal { L } _ { n o r m } ^ { ( k ) } = \frac { \mathcal { L } ^ { ( k ) } - \mathcal { L } _ { i n i t } } { \mathcal { L } _ { s g d } - \mathcal { L } _ { i n i t } } } \end{array}$ where ${ \mathcal { L } } _ { i n i t } = \mathbb { E } [ { \mathcal { L } } ( \theta _ { 0 } ) ]$ is the expected loss value at the initial point, similar to the approach taken in [27], but even more condensed. In other words, a normalized value near zero corresponds to no progress, negative denotes divergence, and a value near one is equivalent to the best SGD. Based on these results, we assign a qualitative color value to the performance of each algorithm setup on each unit test, to able to represent it in a single pixel in the resulting figures:
+
+• Red: Divergence or numerical instability in all run.   
+• Violet: Divergence or numerical instability in at least one run.   
+• Orange: Insufficient progress: median $( \mathcal { L } _ { n o r m } ) < 0 . 1$   
+• Yellow: Good progress: median $( \mathcal { L } _ { n o r m } ) > 0 . 1$ and high variability: $\mathcal { L } _ { n o r m } < 0 . 1$ for at least $\textstyle { \frac { 1 } { 4 } }$ of the runs.   
+• Green: Good progress: median $( \mathcal { L } _ { n o r m } ) > 0 . 1$ and low variability: $\mathcal { L } _ { n o r m } < 0 . 1$ for at most $\textstyle { \frac { 1 } { 4 } }$ of the runs.   
+• Blue: Excellent progress: median $( { \mathcal { L } } _ { n o r m } ) > 2$ .
+
+# 3.4 Results
+
+Figures 5 and 6 shows the qualitative results of all algorithm variants on all the unit tests. There is a wealth of information in these visualizations. For example the relatively scarce amount of blue indicate that it is difficult to substantially beat well-tuned SGD in performance on most unit tests. Another unsurprising conclusion is that hyper-parameter tuning matters much less for the adaptive algorithms (ADAGRAD, ADADELTA, RPROP, RMSprop) than for the non-adaptive SGD variants. Also, while some unit tests are more tricky than others on average, there is quite some diversity in the sense that some algorithms may outdo SGD on a unit test where other algorithms fail (especially on the non-differentiable functions).
+
+# 4 Realism and Future Work
+
+We do not expect to replace real-world benchmark domains, but rather to complement them with our suite of unit tests. Still, it is important to have sufficient coverage of the types of potential difficulties encountered in realistic settings. To a much lesser degree, we may not want to clutter the test suite with unit tests that measure issues which never occur in realistic problems.
+
+It is not straightforward to map very high-dimensional real-world loss functions down to lowdimensional prototype shapes, but it is not impossible. For example, in Figure 8 we show some random projections in parameter space of the loss function in an MNIST classification task with an MLP [28]. We defer a fuller investigation of this type, namely obtaining statistics on how commonly different prototypes are occurring, to future work.
+
+However, the unit tests capture the properties of some examples that can be analyzed. One of them was discussed in section 2.5, another one is the simple loss function of a one-dimensional autoencoder:
+
+$$
+\mathcal { L } _ { \boldsymbol { \theta } } ( \boldsymbol { x } ) = \left( \boldsymbol { x } + \boldsymbol { \theta } _ { 2 } \cdot \boldsymbol { \sigma } ( \boldsymbol { x } \cdot \boldsymbol { \theta } _ { 1 } ) \right) ^ { 2 }
+$$
+
+where $\sigma$ is the sigmoid function. Even in the absence of noise, this minimal scenario has a saddlepoint near $\theta = ( 0 , 0 )$ , a plateau shape away from the axes, a cliff shape near the vertical axis, and a correlated valley near $\bar { \theta } = ( 1 , 1 )$ , as illustrated in Figure 7. All of these prototypical shapes are included in our set of unit tests.
+
+An alternative approach is predictive: if the performance on the unit tests is highly predictive of an algorithm’s performance on a some real-world task, then those unit tests must be capturing the essential aspects of the task. Again, building such a predictor is an objective for future work.
+
+# 4.1 Algorithm Dynamics
+
+Our long-term objective is to be able to do systematic testing and a full investigation of the optimization dynamics for a given algorithm. Of course, it is not possible to test it exhaustively on all possible loss functions (because there are infinitely many), but a divide-and-conquer approach may be the next best thing. For this, we introduce the notion of algorithm state, which is changing during optimization (e.g., the current stepsize or momentum). Now, a long optimization process can be seen as the chaining of a number of unit tests, while preserving the algorithm state in-between them. Our hypothesis is that the set of all possible chains of unit tests in our collection covers most of the qualitatively different (stationary or non-stationary) loss functions an optimization algorithm may encounter.
+
+To evaluate an algorithm’s robustness (rather than its expected performance), we can assume that an adversary picks the worst-case unit tests at each step in the sequence. An algorithm is only truly robust if it does not diverge under any sequence of unit tests. Besides the worst-case, we may also want to study typical expected behavior, namely whether the dynamics have an attractor in the algorithm’s state space. If an attractor exists where the algorithm is stable, then it becomes useful to look at the secondary criterion for the algorithm, namely its expected (normalized) performance.
+
+![](images/f60e1f785661b9849aa84b85d25b947a590f3c6bdf6a36b49373dae75c361235.jpg)
+
+![](images/4d1f5a08230b342b05198e8f1a2cc85b5d7a53c1de436297e41279c35d686aa8.jpg)
+
+![](images/f720ad6d5f34d39e18934886609bf2dd1270a688327fb4bfe2138e161fbba508.jpg)  
+Figure 7: Illustration of the loss surface of a one-dimensional auto-encoder, as defined in the text, where the darkest blue corresponds to the lowest loss. Left: from the zoomed-out perspective if appears to be roughly a vertical valley, leading an optimizer toward the y-axis from almost anywhere in the space. Center: the zoomed-in perspective around the origin, which is looking like a prototypical saddle point. Right: the shape of the valley in the lower left quadrant, the walls of which become steeper the more the search progresses.
+
+![](images/26cc29179b3ead1060589ded203c34d428470b0640c1be4f01cb06c98778ea4f.jpg)  
+Figure 8: Left: collection of 64 random projections into two dimensions of the MNIST loss surface (based on one randomly sampled digit for each column). The projections are centered around the weights learned after one epoch of training, and different projections are plotted on scales between 0.05 (top row) and 0.5 (bottom row). Right: the same as on the left, but with axis-aligned projections.
+
+We conjecture that this analysis may lead to novel insights into how to design robust and adaptive optimization algorithms.
+
+# 5 Conclusion
+
+This paper established a large collection of simple comparative benchmarks to evaluate stochastic optimization algorithms, on a broad range of small-scale, isolated, and well-understood difficulties. This approach helps disentangle issues that tend to be confounded in real-world scenarios, while retaining realistic properties. Our initial results on a dozen established algorithms (under a variety of different hyperparameter settings) show that robustness is non-trivial, and that different algorithms struggle on different unit tests. The testing framework is open-source, extensible to new function classes, and easy to use for evaluating the robustness of new algorithms.
+
+The full source code (see also Appendix A) is available under BSD license at:
+
+https://github.com/IoannisAntonoglou/optimBench
+
+# Acknowledgements
+
+We thank the anonymous ICLR reviewers for their many constructive comments.
+
+# References
+
+[1] H. Robbins and S. Monro. A stochastic approximation method. Annals of Mathematical Statistics, 22:400–407, 1951.   
+[2] Leon Bottou. Online Algorithms and Stochastic Approximations. In David Saad, editor, ´ Online Learning and Neural Networks. Cambridge University Press, Cambridge, UK, 1998.   
+[3] Leon Bottou and Yann LeCun. Large Scale Online Learning. In Sebastian Thrun, Lawrence ´ Saul, and Bernhard Scholkopf, editors, ¨ Advances in Neural Information Processing Systems 16. MIT Press, Cambridge, MA, 2004.   
+[4] Leon Bottou and Olivier Bousquet. The Tradeoffs of Large Scale Learning. In J.C. Platt, ´ D. Koller, Y. Singer, and S. Roweis, editors, Advances in Neural Information Processing Systems, volume 20, pages 161–168. NIPS Foundation (http://books.nips.cc), 2008.   
+[5] A. Benveniste, M. Metivier, and P. Priouret. Adaptive Algorithms and Stochastic Approximations. Springer Verlag, Berlin, New York, 1990.   
+[6] N. Le Roux, P.A. Manzagol, and Y. Bengio. Topmoumoute online natural gradient algorithm, 2008.   
+[7] Antoine Bordes, Leon Bottou, and Patrick Gallinari. SGD-QN: Careful Quasi-Newton ´ Stochastic Gradient Descent. Journal of Machine Learning Research, 10:1737–1754, July 2009. [8] Wei Xu. Towards Optimal One Pass Large Scale Learning with Averaged Stochastic Gradient Descent. ArXiv-CoRR, abs/1107.2490, 2011.   
+[9] Tom Schaul, Sixin Zhang, and Yann LeCun. No More Pesky Learning Rates. In International Conference on Machine Learning (ICML), 2013.   
+[10] John C. Duchi, Elad Hazan, and Yoram Singer. Adaptive Subgradient Methods for Online Learning and Stochastic Optimization. 2010.   
+[11] Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. Understanding the exploding gradient problem. arXiv preprint arXiv:1211.5063, 2012.   
+[12] X. Glorot and Y. Bengio. Understanding the difficulty of training deep feedforward neural networks. In G. Orr and Muller K., editors, Proceedings of the International Conference on Artificial Intelligence and Statistics (AISTATS), pages 249–256. Society for Artificial Intelligence and Statistics, 2010.   
+[13] Nikolaus Hansen, Anne Auger, Steffen Finck, Raymond Ros, et al. Real-parameter black-box optimization benchmarking 2010: Experimental setup. 2010.   
+[14] Nikolaus Hansen, Anne Auger, Raymond Ros, Steffen Finck, and Petr Posˇ´ık. Comparing results of 31 algorithms from the black-box optimization benchmarking BBOB-2009. In Proceedings of the 12th annual conference companion on Genetic and evolutionary computation, pages 1689–1696. ACM, 2010.   
+[15] Alex Krizhevsky, Ilya Sutskever, and Geoff Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems 25, pages 1106–1114, 2012.   
+[16] Ian J Goodfellow, David Warde-Farley, Mehdi Mirza, Aaron Courville, and Yoshua Bengio. Maxout networks. arXiv preprint arXiv:1302.4389, 2013.   
+[17] Y. LeCun, L. Bottou, G. Orr, and K. Muller. Efficient BackProp. In G. Orr and Muller K., editors, Neural Networks: Tricks of the trade. Springer, 1998.   
+[18] Geoffrey E Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012.   
+[19] R.S. Sutton and A.G. Barto. Reinforcement Learning: An Introduction. IEEE Transactions on Neural Networks, 9(5):1054–1054, Sep 1998.   
+[20] Etienne Barnard. Temporal-difference methods and Markov models. IEEE Transactions on Systems, Man, and Cybernetics, 23(2):357–365, 1993.   
+[21] Richard S. Sutton, Anna Koop, and David Silver. On the role of tracking in stationary environments. In Proceedings of the Twenty-Fourth International Conference on Machine Learning (ICML 2007, pages 871–878. ACM Press, 2007.   
+[22] Yurii Nesterov and Arkadii Semenovich Nemirovskii. Interior-point polynomial algorithms in convex programming, volume 13. SIAM, 1994.   
+[23] Matthew D Zeiler. ADADELTA: An Adaptive Learning Rate Method. arXiv preprint arXiv:1212.5701, 2012.   
+[24] Richard S Sutton. Adapting bias by gradient descent: An incremental version of delta-bardelta. In AAAI, pages 171–176, 1992.   
+[25] Martin Riedmiller and Heinrich Braun. A direct adaptive method for faster backpropagation learning: The RPROP algorithm. In Neural Networks, 1993., IEEE International Conference on, pages 586–591. IEEE, 1993.   
+[26] T Tieleman and G Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012.   
+[27] Tom Schaul and Yann LeCun. Adaptive learning rates and parallelization for stochastic, sparse, non-smooth gradients. In International Conference on Learning Representations, Scottsdale, AZ, 2013.   
+[28] Yann LeCun and Corinna Cortes. The MNIST dataset of handwritten digits. 1998. http://yann.lecun.com/exdb/mnist/.
+
+# A Appendix: Framework Software
+
+As part of this work a software framework was developed for the computing and managing all the results obtained for all the different configurations of function prototypes and algorithms. The main component of the system is a database where all the results are stored and can be easily retrieved by querying the database accordingly. The building blocks of this database are the individual experiments, where each experiment is associated to a unit test and an algorithm with fixed parameters. An instance of an experiment database can either be loaded from the disk, or it can be created on the fly by running the associated experiments as needed. The code below creates a database and runs all the experiments for all the readily available algorithms and default unit tests, and then saves them to disk:
+
+require ’experiment’ local db $=$ experimentsDB() db:runExperiments() db:save(’experimentsDB’)
+
+This database now can be loaded from the disk, and the user can query it in order to retrieve specific experiments, using filters. An example is shown below:
+
+local db $=$ experimentsDB()   
+db:load(’experimentsDB’)   
+local experiments $=$ db:filter({fun ${ } = { }$ {’quad’, ’line’}, $\mathsf { a l g o } \mathrm { = } \{ \mathsf { \Omega } ^ { \prime } \mathsf { s g d } ^ { \prime } \mathsf { \Omega } \}$ , learningRat $\scriptstyle \mathtt { e } = 1 \in - 4 \ \}$ )
+
+The code above loads an experiment database from the disk and it retrieves all the experiments for all the quadratic and line prototype shapes, for all different types of noise and all scales, further selecting the subset of experiments to those optimized using SGD with learningRate equal to 1e4. The user can rerun the extracted experiments or have access to the associated results, i.e., the expected value of the function in different optimization steps, along with the associated parameters values. In order to qualitatively assess the results the following code can be used:
+
+The code above computes the reference expected values for each prototype function, it removes the experiments for which no reference value is available, then it qualitatively assesses the performance of all the available experiments and finally it plots the results given the color configuration described in section 3.3. It is really easy to add a new algorithm in the database in order to evaluate its robustness. The code below illustrates a simple example:
+
+db:addAlgorithm(algoname, algofun, opt) db:testAlgorithm(algoname) db:plotExperiments({}, {algoname})
+
+Here a new algorithm with name algoname, function instance algo (which should satisfy the optim interface), and a table of different parameter configurations opt is added to the database and it is tested under all available functions prototypes. Finally, the last line plots a graph with all the results for this algorithm.
+
+It is also possible to add a set of new unit tests to the database, and subsequently run a set of experiments associated with them. There are different parameters to be defined for the creation of a set of unit tests (that allow wildcard specification too):
+
+1. the concatenated shape prototypes for each dimension,   
+2. the noise prototype to be applied to each dimension,   
+3. the scale of each dimension of the function,   
+4. in case of multivariate unit tests, a parameter specifies which $p$ -norm is used for the com  
+bination,   
+5. a rotation parameter that induces correlation of the different parameter dimensions, and   
+6. a curl parameter that changes the vector field of a multivariate function.

md/train/SJl47yBYPS/SJl47yBYPS.md

@@ -0,0 +1,415 @@
+# TOWARDS SIMPLICITY IN DEEP REINFORCEMENT LEARNING: STREAMLINED OFF-POLICY LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+The field of Deep Reinforcement Learning (DRL) has recently seen a surge in the popularity of maximum entropy reinforcement learning algorithms. Their popularity stems from the intuitive interpretation of the maximum entropy objective and their superior sample efficiency on standard benchmarks. In this paper, we seek to understand the primary contribution of the entropy term to the performance of maximum entropy algorithms. For the Mujoco benchmark, we demonstrate that the entropy term in Soft Actor Critic (SAC) principally addresses the bounded nature of the action spaces. With this insight, we show how streamlined algorithms without entropy maximization can match the performance of SAC. We also propose a simple non-uniform sampling method for selecting transitions from the replay buffer during training. We further show that the streamlined algorithm with the simple non-uniform sampling scheme outperforms SAC and achieves state-of-the-art performance on challenging continuous control tasks.
+
+# 1 INTRODUCTION
+
+Off-policy Deep Reinforcement Learning (RL) algorithms aim to improve sample efficiency by reusing past experience. Recently a number of new off-policy Deep Reinforcement Learning algorithms have been proposed for control tasks with continuous state and action spaces, including Deep Deterministic Policy Gradient (DDPG) and Twin Delayed DDPG (TD3) (Lillicrap et al., 2015; Fujimoto et al., 2018). TD3, which introduced clipped double-Q learning, delayed policy updates and target policy smoothing, has been shown to be significantly more sample efficient than popular on-policy methods for a wide range of Mujoco benchmarks.
+
+The field of Deep Reinforcement Learning (DRL) has also recently seen a surge in the popularity of maximum entropy RL algorithms. Their popularity stems from the intuitive interpretation of the maximum entropy objective and their superior sample efficiency on standard benchmarks. In particular, Soft Actor Critic (SAC), which combines off-policy learning with maximum-entropy RL, not only has many attractive theoretical properties, but can also give superior performance on a wide-range of Mujoco environments, including on the high-dimensional environment Humanoid for which both DDPG and TD3 perform poorly (Haarnoja et al., 2018a;b; Langlois et al., 2019). SAC has a similar structure to TD3, but also employs maximum entropy reinforcement learning.
+
+In this paper, we first seek to understand the primary contribution of the entropy term to the performance of maximum entropy algorithms. For the Mujoco benchmark, we demonstrate that when using the standard objective without entropy along with standard additive noise exploration, there is often insufficient exploration due to the bounded nature of the action spaces. Specifically, the outputs of the policy network are often way outside the bounds of the action space, so that they need to be squashed to fit within the action space. The squashing results in actions persistently taking on their maximal values, so that there is insufficient exploration. In contrast, the entropy term in the SAC objective forces the outputs to have sensible values, so that even with squashing, exploration is maintained. We conclude that the entropy term in the objective for Soft Actor Critic principally addresses the bounded nature of the action spaces in the Mujoco environments.
+
+With this insight, we propose Streamlined Off Policy (SOP), a streamlined algorithm using the standard objective without the entropy term. SOP employs a simple normalization scheme to address the bounded nature of the action spaces, allowing satisfactory exploration throughout training. We also consider replacing the aforementioned normalization scheme with inverting gradients (IG)
+
+Hausknecht & Stone (2015). Our results show that SOP and IG match the sample-efficiency and robustness performance of SAC, including on the more challenging Ant and Humanoid environments. This demonstrates a need to revisit the importance of entropy maximization in DRL.
+
+Keeping with the theme of simplicity with the goal of meeting Occam’s principle, we also propose a simple non-uniform sampling method for selecting transitions from the replay buffer during training. In vanilla SOP (as well as in DDPG, TD3, and SAC), samples from the replay buffer are chosen uniformly at random during training. Our method, called Emphasizing Recent Experience (ERE), samples more aggressively recent experience while not neglecting past experience. Unlike Priority Experience Replay (PER) (Schaul et al., 2015), a popular non-uniform sampling scheme for the Atari environments, ERE is only a few lines of code and does not rely on any sophisticated data structures. We show that SOP combined with ERE out-performs SAC and provides state of the art performance. For example, for Ant and Humanoid, it improves over SAC by $2 1 \%$ and $2 4 \%$ , respectively, with one million samples. Furthermore, we also investigate combining SOP with PER, and show SOP+ERE also out-performs the more complicated SOP $+$ PER scheme.
+
+The contributions of this paper are thus threefold. First, we uncover the primary contribution of the entropy term of maximum entropy RL algorithms when the environments have bounded action spaces. Second, we propose a streamlined algorithm which do not employ entropy maximization but nevertheless matches the sampling efficiency and robustness performance of SAC for the Mujoco benchmarks. And third, we combine our streamlined algorithms with a simple non-uniform sampling scheme to achieve state-of-the art performance for the Mujoco benchmarks. We provide anonymized code for reproducibility 1.
+
+# 2 PRELIMINARIES
+
+We represent an environment as a Markov Decision Process (MDP) which is defined by the tuple $( S , { \mathcal { A } } , r , p , \gamma )$ , where $s$ and $\mathcal { A }$ are continuous multi-dimensional state and action spaces, $r ( s , a )$ is a bounded reward function, $p ( s ^ { \prime } | s , a )$ is a transition function, and $\gamma$ is the discount factor. Let $s ( t )$ and $a ( t )$ respectively denote the state of the environment and the action chosen at time $t$ . Let $\pi { \dot { = } } \pi ( a | s )$ , $s \in \mathcal S , a \in \mathcal A$ denote the policy. We further denote $K$ for the dimension of the action space, and write $a _ { k }$ for the $k$ th component of an action $a \in { \mathcal { A } }$ , that is, $a = ( a _ { 1 } , \ldots , a _ { K } )$ .
+
+The expected discounted return for policy $\pi$ beginning in state $s$ is given by:
+
+$$
+V _ { \pi } ( s ) = \mathbb { E } _ { \pi } [ \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r ( s ( t ) , a ( t ) ) | s ( 0 ) = s ]
+$$
+
+Standard MDP and RL problem formulations seek to maximize $V _ { \pi } ( s )$ over policies $\pi$ . For finite state and action spaces, under suitable conditions for continuous state and action spaces, there exists an optimal policy that is deterministic (Puterman, 2014; Bertsekas & Tsitsiklis, 1996). In RL with unknown environment, exploration is required to learn a suitable policy.
+
+In DRL with continuous action spaces, typically the policy is modeled by a parameterized policy network which takes as input a state $s$ and outputs a value $\mu ( s ; \theta )$ , where $\theta$ represents the current parameters of the policy network (Schulman et al., 2015; 2017; Vuong et al., 2018; Lillicrap et al., 2015; Fujimoto et al., 2018). During training, typically additive random noise is added for exploration, so that the actual action taken when in state $s$ takes the form $a = \mu ( s ; \theta ) + \epsilon$ where $\epsilon$ is a $K$ -dimensional Gaussian random vector with each component having zero mean and variance $\sigma$ . During testing, $\epsilon$ is set to zero.
+
+# 2.1 ENTROPY MAXIMIZATION RL
+
+Maximum entropy reinforcement learning takes a different approach than (1) by optimizing policies to maximize both the expected return and the expected entropy of the policy (Ziebart et al., 2008; Ziebart, 2010; Todorov, 2008; Rawlik et al., 2013; Levine & Koltun, 2013; Levine et al., 2016; Nachum et al., 2017; Haarnoja et al., 2017; 2018a;b).
+
+In particular, with maximization entropy RL, the objective is to maximize
+
+$$
+V _ { \pi } ( s ) = \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } \mathbb { E } _ { \pi } [ r ( s ( t ) , a ( t ) ) + \lambda H ( \pi ( \cdot | s ( t ) ) ) | s ( 0 ) = s ]
+$$
+
+where $H ( \pi ( \cdot | s ) )$ is the entropy of the policy when in state $s$ , and the temperature parameter $\lambda$ determines the relative importance of the entropy term against the reward.
+
+For entropy maximization DRL, when given state $s$ the policy network will typically output a $K$ - dimensional vector $\sigma ( s ; \theta )$ in addition to the vector $\mu ( s ; \theta )$ . The action selected when in state $s$ is then modeled as $\mu ( s ; \theta ) + \epsilon$ where $\epsilon \sim { \cal N } ( 0 , \sigma ( s ; \theta ) )$ .
+
+Maximum entropy RL has been touted to have a number of conceptual and practical advantages for DRL (Haarnoja et al., 2018a;b). For example, it has been argued that the policy is incentivized to explore more widely, while giving up on clearly unpromising avenues. It has also been argued that the policy can capture multiple modes of near-optimal behavior, that is, in problem settings where multiple actions seem equally attractive, the policy will commit equal probability mass to those actions. In this paper, we show for the Mujoco benchmarks that the standard additive noise exploration suffices and can achieve the same performance as maximum entropy RL.
+
+# 3 THE SQUASHING EXPLORATION PROBLEM
+
+# 3.1 BOUNDED ACTION SPACES
+
+Continuous environments typically have bounded action spaces, that is, along each action dimension $k$ there is a minimum possible action value $a _ { k } ^ { \mathrm { m i n } }$ and a maximum possible action value $a _ { k } ^ { \mathrm { m a x } }$ . When selecting an action, the action needs to be selected within these bounds before the action can be taken. DRL algorithms often handle this by squashing the action so that it fits within the bounds. For example, if along any one dimension the value $\mu ( s ; \theta ) + \epsilon$ exceeds $a _ { \mathrm { m a x } }$ , the action is set (clipped) to $a _ { \mathrm { m a x } }$ . Alternatively, a smooth form of squashing can be employed. For example, suppose $a _ { k } ^ { \mathrm { m i n } } =$ $- M$ and $a _ { k } ^ { \mathrm { m a x } } = + M$ for some positive number $M$ , then a smooth form of squashing could use $a = M \operatorname { t a n h } ( \mu ( s ; \theta ) + \epsilon )$ in which $\operatorname { t a n h } ( )$ is being applied to each component of the $K$ -dimensional vector. DDPG (Hou et al., 2017) and TD3 (Fujimoto et al., 2018) use clipping, and SAC (Haarnoja et al., 2018a;b) uses smooth squashing with the $\operatorname { t a n h } ( )$ function. For concreteness, henceforth we will assume that smooth squashing with the tanh() is employed.
+
+We note that an environment may actually allow the agent to input actions that are outside the bounds. In this case, the environment will typically first clip the actions internally before passing them on to the “actual” environment (Fujita $\&$ Maeda, 2018).
+
+We now make a simple but crucial observation: squashing actions to fit into a bounded action space can have a disastrous effect on additive-noise exploration strategies. To see this, let the output of the policy network be $\mu ( s ) = ( \mu _ { 1 } ( s ) , \ldots , \mu _ { K } ( s ) )$ . Consider an action taken along one dimension $k$ , and suppose $\mu _ { k } ( s ) > > 1$ and $\left| \epsilon _ { k } \right|$ is relatively small compared to $\mu _ { k } ( s )$ . Then the action $a _ { k } =$ $M \operatorname { t a n h } ( \mu _ { k } ( s ) + \epsilon _ { k } )$ will be very close (essentially equal) to $M$ . If the condition $\mu _ { k } ( s ) > > 1$ persists over many consecutive states, then $a _ { k }$ will remain close to 1 for all these states, and consequently there will be essentially no exploration along the $k$ th dimension. We will refer to this problem as the squashing exploration problem. A similar observation was made in Hausknecht & Stone (2015). We will argue that algorithms such as DDPG and TD3 based on the standard objective (1) with additive noise exploration can be greatly impaired by squashing exploration.
+
+# 3.2 WHAT DOES ENTROPY MAXIMIZATION BRING TO SAC FOR THE MUJUCO ENVIRONMENTS?
+
+SAC is a maximum-entropy based off-policy DRL algorithm which provides good performance across all of the Mujuco benchmark environments. To the best of our knowledge, it currently provides state of the art performance for the Mujoco benchmark. In this section, we argue that the principal contribution of the entropy term in the SAC objective is to resolve the squashing exploration problem, thereby maintaining sufficient exploration when facing bounded action spaces. To argue this, we consider two DRL algorithms: SAC with adaptive temperature (Haarnoja et al., 2018b), and
+
+SAC with entropy removed altogether (temperature set to zero) but everything else the same. We refer to them as $S A C$ and as $S A C$ without entropy. For SAC without entropy, for exploration we use additive zero-mean Gaussian noise with $\sigma$ fixed at 0.3. Both algorithms use tanh squashing. We compare these two algorithms on two Mujoco environments: Humanoid-v2 and Walker-v2.
+
+Figure 1 shows the performance of the two algorithms with 10 seeds. For Humanoid, SAC performs much better than SAC without entropy. However, for Walker, SAC without entropy performs nearly as well as SAC, implying maximum entropy RL is not as critical for this environment.
+
+![](images/219162d1cd1bf8bc2f19ed86a415e646bc8c9cfbe32e46472131c28c4a625905.jpg)  
+Figure 1: SAC performance with and without entropy maximization
+
+To understand why entropy maximization is important for one environment but less so for another, we examine the actions selected when training these two algorithms. Humanoid and Walker have action dimensions $K = 1 7$ and $K = 6$ , respectively. Here we show representative results for one dimension for both environments, and provide the full results in the Appendix. The top and bottom rows of Figure 2 shows results for Humanoid and Walker, respectively. The first column shows the $\mu _ { k }$ values for an interval of 1,000 consecutive time steps, namely, for time steps 599,000 to 600,000. The second column shows the actual action values passed to the environment for these time steps. The third and fourth columns show a concatenation of 10 such intervals of 1000 time steps, with each interval coming from a larger interval of 100,000 time steps.
+
+The top and bottom rows of Figure 2 are strikingly different. For Humanoid using SAC with entropy, the $\left| \mu _ { k } \right|$ values are small, mostly in the range [-1.5,1.5], and fluctuate significantly. This allows the action values to also fluctuate significantly, providing exploration in the action space. On the other hand, for SAC without entropy the $\left| \mu _ { k } \right|$ values are typically huge, most of which are well outside the interval [-10,10]. This causes the actions $a _ { k }$ to be persistently clustered at either $M$ or - $- M$ , leading to essentially no exploration along that dimension. As shown in the Appendix, this property (lack of exploration for SAC without entropy maximization) holds for all 17 action dimensions. For Walker, we see that for both algorithms, the $\mu _ { k }$ values are sensible, mostly in the range [-1,1] and therefore the actions chosen by both algorithms exhibit exploration.
+
+In conclusion, the principle benefit of maximum entropy RL in SAC for the Mujuco environments is that it resolves the squashing exploration problem. For some environments (such as Walker), the outputs of the policy network take on sensible values, so that sufficient exploration is maintained and overall good performance is achieved without the need for entropy maximization. For other environments (such as Humanoid), entropy maximization is needed to reduce the magnitudes of the outputs so that exploration is maintained and overall good performance is achieved.
+
+# 4 STREAMLINED OFF-POLICY (SOP) ALGORITHM
+
+Given the observations in the previous section, a natural question is: is it possible to design a streamlined off policy algorithm that does not employ entropy maximization but offers performance comparable to SAC (which has entropy maximization)?
+
+As we observed in the previous section, without entropy maximization, in some environments the policy network output values $\left| \mu _ { k } \right|$ , $k = 1 , \ldots , K$ can become persistently huge, which leads to insufficient exploration due to the squashing. A simple solution is to modify the outputs of the policy network by normalizing the output values when they collectively (across the action dimensions) become too large. To this end, let $\boldsymbol { \mu } = \left( \mu _ { 1 } , \ldots , \mu _ { K } \right)$ be the output of the original policy network, and let $\begin{array} { r } { G = \sum _ { k } | \bar { \mu _ { k } } | / K } \end{array}$ . The $G$ is simply the average of the magnitudes of the components of $\mu$ . The normalization procedure is as follows. If $G > 1$ , then we reset $\mu _ { k }  \mu _ { k } / G$ for all $k = 1 , \ldots , K$ ; otherwise, we leave $\mu$ unchanged. With this simple normalization, we are assured that the average of the normalized magnitudes is never greater than one. Henceforth we assume the policy network has been modified with the simple normalization scheme just described.
+
+![](images/05212525676040ea6efb61cfcb1304aeace075d5f5c018c548343aa1f033b039.jpg)  
+Figure 2: $\mu _ { k }$ and $a _ { k }$ values from SAC and SAC without entropy maximization
+
+Our Streamlined Off Policy (SOP) algorithm is described in Algorithm 1. The algorithm is essentially DDPG plus the normalization described above, plus clipped double Q-learning and target policy smoothing (Fujimoto et al., 2018). Another way of looking at it is as TD3 plus the normalization described above, minus the delayed policy updates and the target policy parameters. SOP also uses tanh squashing instead of clipping, since tanh gives somewhat better performance in our experiments. The SOP algorithm is “streamlined” as it has no entropy terms, temperature adaptation, target policy parameters or delayed policy updates. In our experiments, we also consider TD3 plus the simple normalization, and also another streamlined algorithm in which we replace the simple normalization scheme described above with the inverting gradients (IG) scheme as described in Hausknecht & Stone (2015). The basic idea is: when gradients suggest increasing the action magnitudes, gradients will be downscaled if actions are within the boundaries, and inverted entirely if actions are outside the boundaries. More implementation details can be found in the Appendix.
+
+# Algorithm 1 Streamlined Off-Policy
+
+<table><tr><td>1: 2: repeat</td><td>：Input: initial policy parameters 0,Q-function parameters Φ1,Φ2,empty replay buffer D Set target parameters equal to main parameters $targ ← Φ for i= 1, 2</td></tr><tr><td>3:</td><td></td></tr><tr><td>4: 5:</td><td>Generate an episode using actions a = Mtanh(μe(s) + ε) where ∈ ~ N(O,01). for j in range(however many updates) do</td></tr><tr><td>6:</td><td>Randomly sample a batch of transitions,B = {(s,a,r,s)} from D</td></tr><tr><td>7:</td><td>Compute targets for Q functions:</td></tr><tr><td>8:</td><td>yq(r,s&#x27;)=r+γmini=1,2 QΦarg(s&#x27;,Mtanh(μe(s&#x27;)+δ))δ~N(0,σ2) Update Q-functions by one step of gradient descent using</td></tr><tr><td>9:</td><td>ViB∑(s,a,r,s)∈B(Q:(s,a)-yq(r,s)²fori=1,2 Update policy by one step of gradient ascent using</td></tr><tr><td>10:</td><td>VB∑s∈B QΦ1(s,Mtanh(μθ(s))) Update target networks with targ;← pΦtarg +(1-ρ)Φi for i=1,2</td></tr></table>
+
+# 4.1 EXPERIMENTAL RESULTS FOR SOP
+
+Figure 3 compares SAC (with temperature adaptation (Haarnoja et al., 2018a;b)) with SOP, $\mathrm { T D } 3 +$ (that is, TD3 plus the simple normalization), and inverting gradients (IG) for five of the most challenging Mujuco environments. Using the same baseline code, we train with ten different random seeds for each of the two algorithms. Each algorithm performs five evaluation rollouts every 5000 environment steps. The solid curves correspond to the mean, and the shaded region to the standard deviation of the returns over the ten seeds.
+
+Results show that SOP, SAC and IG have similar sample-efficiency performance and robustness across all environments. $\mathrm { T D } 3 +$ has slightly weaker asymptotic performance for Walker and Humanoid. IG initially learns slowly for Humanoid with high variance across random seeds, but gives similar asymptotic performance. This confirms that with a simple output normalization scheme in the policy network, the performance of SAC can be achieved without maximum entropy RL.
+
+In the Appendix we provide an ablation study for SOP, which shows a major performance drop when removing either double Q-learning or normalization, whereas removing target policy smoothing (Fujimoto et al., 2018) results in only a small performance drop in some environments.
+
+![](images/39252b2fb870b529c74797173bc3397fc70ed66480e6d23d70b419f6fc1612f5.jpg)  
+Figure 3: Streamlined Off-Policy (SOP) versus SAC, $\mathrm { T D } 3 +$ and IG
+
+# 5 NON-UNIFORM SAMPLING
+
+We now show how a small change in the sampling scheme for SOP can achieve state of the art performance for the Mujoco benchmark. We call this sampling scheme Emphasizing Recent Experience (ERE). ERE has 3 core features: $( i )$ It is a general method applicable to any off-policy algorithm; $( i i )$ It requires no special data structure, is very simple to implement, and has near-zero computational overhead; $( i i i )$ It only introduces one additional important hyper-parameter.
+
+The basic idea is: during the parameter update phase, the first mini-batch is sampled from the entire buffer, then for each subsequent mini-batch we gradually reduce our range of sampling to sample more aggressively from more recent data. Specifically, assume that in the current update phase we are to make $1 0 0 0 \mathrm { { m i n i } }$ -batch updates. Let $N$ be the max size of the buffer. Then for the $k ^ { t \mathbf { \hat { h } } }$ update, we sample uniformly from the most recent $c _ { k }$ data points, where $c _ { k } = N \cdot \eta ^ { k }$ and $\eta \in \mathsf { ( 0 , 1 ] }$ is a hyper-parameter that determines how much emphasis we put on recent data. $\eta = 1$ is uniform sampling. When $\eta \ : < \ : 1$ , $c _ { k }$ decreases as we perform each update. $\eta$ can made to adapt to the learning speed of the agent so that we do not have to tune it for each environment.
+
+The effect of such a sampling formulation is twofold. The first is recent data have a higher chance of being sampled. The second is that we do this in an ordered way: we first sample from all the data in the buffer, and gradually shrink the range of sampling to only sample from the most recent data. This scheme reduces the chance of over-writing parameter changes made by new data with parameter changes made by old data (French, 1999; McClelland et al., 1995; McCloskey & Cohen, 1989; Ratcliff, 1990; Robins, 1995). This process allows us to quickly obtain new information from recent data, and better approximate the value functions near recently-visited states, while still maintaining an acceptable approximation near states visited in the more distant past.
+
+What is the effect of replacing uniform sampling with ERE? First note if we do uniform sampling on a fixed buffer, the expected number of times a data point is sampled is the same for all data points. Now consider a scenario where we have a buffer of size 1000 (FIFO queue), we collect one data at a time, and then perform one update with mini-batch size of one. If we start with an empty buffer and sample uniformly, as data fills the buffer, each data point gets less and less chance of being sampled. Specifically, over a period of 1000 updates, the expected number of times the tth data is sampled is: $1 / t + \dot { 1 / ( t + 1 ) } \dot { + } \cdot \cdot \cdot + 1 / T$ . Figure 4f shows the expected number of times a data is sampled as a function of its position in the buffer. We see that older data are expected to get sampled much more than newer data. This is undesirable because when the agent is improving and exploring new areas of the state space; new data points may contain more interesting information than the old ones, which have already been updated many times.
+
+When we apply the ERE scheme, we effectively skew the curve towards assigning higher expected number of samples for the newer data, allowing the newer data to be frequently sampled soon after being collected, which can accelerate the learning process. In the Appendix, we provide further algorithmic detail and analysis on ERE, and compare ERE to two other sampling schemes: an exponential sampling scheme and Prioritized Experience Replay (Schaul et al., 2015).
+
+# 5.1 EXPERIMENTAL RESULTS FOR SOP $^ +$ ERE
+
+Figure 4 compares the performance of SOP, SOP $^ +$ ERE, SAC and SAC+ERE. With ERE, both SAC and SOP gain a significant performance improvement in all environments. SOP+ERE learns faster than SAC and vanilla SOP in all Mujoco environments. SOP+ERE also greatly improves overall performance for the two most challenging environments, Ant and Humanoid, and has the best performance for Humanoid. In table 1, we show the mean test episode return and std across 10 random seeds at 1M timesteps for all environments. The last column displays the percentage improvement of $\mathrm { { S O P + } }$ ERE over SAC, showing that $_ { \mathrm { S O P + E R E } }$ achieves state of the art performance. In Ant and Humanoid, $_ { \mathrm { S O P + E R E } }$ improves performance by $21 \%$ and $24 \%$ over SAC at 1 million timesteps, respectively. As for the std, $\mathrm { S O P + }$ ERE gives lower values, and for Humanoid a higher value.
+
+![](images/3fa684a327ffba12579ae16a9256212442944e96892136d18c91a626e908b948.jpg)  
+Figure 4: (a) to (e) show the performance of SOP and SAC with ERE sampling. (f) shows over a period of 1000 updates, the expected number of times the tth data point is sampled (with $\eta = 0 . 9 9 6 )$ . ERE allows new data to be sampled many times soon after being collected.
+
+Table 1: Performance comparison at one million samples. Last column shows percentage improvement of SOP+ERE over SAC.   
+
+<table><tr><td>Environment</td><td> SAC Adaptive</td><td>SOP</td><td>SOP+ERE</td><td>Improvement</td></tr><tr><td>Hopper</td><td>3161.2 ± 381.0</td><td>3317.3 ± 133.9</td><td>3201.5 ± 248.7</td><td>1.3%</td></tr><tr><td>Walker</td><td>4801.5 ± 514.5</td><td>4666.5 ± 474.5</td><td>5145.9 ± 512.3</td><td>7.2%</td></tr><tr><td>HalfCheetah</td><td>10963.7 ± 512.4</td><td>9968.0 ± 497.4</td><td>11335.1 ± 478.3</td><td>3.4%</td></tr><tr><td>Ant</td><td>4153.7 ± 925.0</td><td>4674.0 ± 588.8</td><td>5023.3 ± 891.6</td><td>21.0%</td></tr><tr><td>Humanoid</td><td>5076.2 ± 148.1</td><td>4900.9 ± 316.6</td><td>6297.7 ± 500.0</td><td>24.1%</td></tr></table>
+
+# 6 RELATED WORK
+
+In recent years, there has been significant progress in improving the sample efficiency of DRL for continuous robotic locomotion tasks with off-policy algorithms (Lillicrap et al., 2015; Fujimoto et al., 2018; Haarnoja et al., 2018a;b). There is also a significant body of research on maximum entropy RL methods (Ziebart et al., 2008; Ziebart, 2010; Todorov, 2008; Rawlik et al., 2013; Levine & Koltun, 2013; Levine et al., 2016; Nachum et al., 2017; Haarnoja et al., 2017; 2018a;b). Ahmed et al. (2019) very recently shed light on how entropy leads to a smoother optimization landscape.
+
+By taking clipping in the Mujoco environments explicitly into account, Fujita & Maeda (2018) modified the policy gradient algorithm to reduce variance and provide superior performance among on-policy algorithms. Eisenach et al. (2018) extend the work of Fujita & Maeda (2018) for when an action may be direction. Hausknecht & Stone (2015) introduce Inverting Gradients, for which we provide expermintal results in this paper for the Mujoco environments. Chou et al. (2017) also explores DRL in the context of bounded action spaces. Dalal et al. (2018) consider safe exploration in the context of constrained action spaces.
+
+Uniform sampling is the most common way to sample from a replay buffer. One of the most wellknown alternatives is prioritized experience replay (PER) (Schaul et al., 2015). PER uses the absolute TD-error of a data point as the measure for priority, and data points with higher priority will have a higher chance of being sampled. This method has been tested on DQN (Mnih et al., 2015) and double DQN (DDQN) (Van Hasselt et al., 2016) with significant improvement and applied successfully in other algorithms (Wang et al., 2015; Schulze & Schulze, 2018; Hessel et al., 2018; Hou et al., 2017) and can be implemented in a distributed manner (Horgan et al., 2018). There are other methods proposed to make better use of the replay buffer. The ACER algorithm has an on-policy part and an off-policy part, with a hyper-parameter controlling the ratio of off-policy to on-policy updates (Wang et al., 2016). The RACER algorithm (Novati & Koumoutsakos, 2018) selectively removes data points from the buffer, based on the degree of ”off-policyness”, bringing improvement to DDPG (Lillicrap et al., 2015), NAF (Gu et al., 2016) and PPO (Schulman et al., 2017). In De Bruin et al. (2015), replay buffers of different sizes were tested, showing large buffer with data diversity can lead to better performance. Finally, with Hindsight Experience Replay(Andrychowicz et al., 2017), priority can be given to trajectories with lower density estimation(Zhao & Tresp, 2019) to tackle multi-goal, sparse reward environments.
+
+# 7 CONCLUSION
+
+In this paper we first showed that the primary role of maximum entropy RL for the Mujoco benchmark is to maintain satisfactory exploration in the presence of bounded action spaces. We then developed a new streamlined algorithm which does not employ entropy maximization but nevertheless matches the sampling efficiency and robustness performance of SAC for the Mujoco benchmarks. Our experimental results demonstrate a need to revisit the benefits of entropy regularization in DRL. Finally, we combined our streamlined algorithm with a simple non-uniform sampling scheme to achieve state-of-the art performance for the Mujoco benchmark.
+
+# REFERENCES
+
+Zafarali Ahmed, Nicolas Le Roux, Mohammad Norouzi, and Dale Schuurmans. Understanding the impact of entropy on policy optimization. In International Conference on Machine Learning, pp. 151–160, 2019.
+
+Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, OpenAI Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. In Advances in Neural Information Processing Systems, pp. 5048–5058, 2017.
+
+Dimitri P Bertsekas and John N Tsitsiklis. Neuro-dynamic programming, volume 5. Athena Scientific Belmont, MA, 1996.
+
+Po-Wei Chou, Daniel Maturana, and Sebastian Scherer. Improving stochastic policy gradients in continuous control with deep reinforcement learning using the beta distribution. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 834–843. JMLR. org, 2017.
+
+Gal Dalal, Krishnamurthy Dvijotham, Matej Vecerik, Todd Hester, Cosmin Paduraru, and Yuval Tassa. Safe exploration in continuous action spaces. arXiv preprint arXiv:1801.08757, 2018.
+
+Tim De Bruin, Jens Kober, Karl Tuyls, and Robert Babuska. The importance of experience replay ˇ database composition in deep reinforcement learning. In Deep reinforcement learning workshop, NIPS, 2015.
+
+Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In International Conference on Machine Learning, pp. 1329–1338, 2016.
+
+Carson Eisenach, Haichuan Yang, Ji Liu, and Han Liu. Marginal policy gradients: A unified family of estimators for bounded action spaces with applications. arXiv preprint arXiv:1806.05134, 2018.
+
+Robert M French. Catastrophic forgetting in connectionist networks. Trends in cognitive sciences, 3(4):128–135, 1999.
+
+Justin Fu, Aviral Kumar, Matthew Soh, and Sergey Levine. Diagnosing bottlenecks in deep qlearning algorithms. arXiv preprint arXiv:1902.10250, 2019.
+
+Scott Fujimoto, Herke van Hoof, and Dave Meger. Addressing function approximation error in actor-critic methods. arXiv preprint arXiv:1802.09477, 2018.
+
+Yasuhiro Fujita and Shin-ichi Maeda. Clipped action policy gradient. arXiv preprint arXiv:1802.07564, 2018.
+
+Shixiang Gu, Timothy Lillicrap, Ilya Sutskever, and Sergey Levine. Continuous deep q-learning with model-based acceleration. In International Conference on Machine Learning, pp. 2829– 2838, 2016.
+
+Tuomas Haarnoja, Haoran Tang, Pieter Abbeel, and Sergey Levine. Reinforcement learning with deep energy-based policies. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1352–1361. JMLR. org, 2017.
+
+Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Offpolicy maximum entropy deep reinforcement learning with a stochastic actor. arXiv preprint arXiv:1801.01290, 2018a.
+
+Tuomas Haarnoja, Aurick Zhou, Kristian Hartikainen, George Tucker, Sehoon Ha, Jie Tan, Vikash Kumar, Henry Zhu, Abhishek Gupta, Pieter Abbeel, et al. Soft actor-critic algorithms and applications. arXiv preprint arXiv:1812.05905, 2018b.
+
+Matthew Hausknecht and Peter Stone. Deep reinforcement learning in parameterized action space. arXiv preprint arXiv:1511.04143, 2015.
+
+Peter Henderson, Riashat Islam, Philip Bachman, Joelle Pineau, Doina Precup, and David Meger. Deep reinforcement learning that matters. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Matteo Hessel, Joseph Modayil, Hado Van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Dan Horgan, Bilal Piot, Mohammad Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado Van Hasselt, and David Silver. Distributed prioritized experience replay. arXiv preprint arXiv:1803.00933, 2018.
+
+Yuenan Hou, Lifeng Liu, Qing Wei, Xudong Xu, and Chunlin Chen. A novel ddpg method with prioritized experience replay. In 2017 IEEE International Conference on Systems, Man, and Cybernetics (SMC), pp. 316–321. IEEE, 2017.
+
+Riashat Islam, Peter Henderson, Maziar Gomrokchi, and Doina Precup. Reproducibility of benchmarked deep reinforcement learning tasks for continuous control. arXiv preprint arXiv:1708.04133, 2017.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Eric Langlois, Shunshi Zhang, Guodong Zhang, Pieter Abbeel, and Jimmy Ba. Benchmarking model-based reinforcement learning. arXiv preprint arXiv:1907.02057, 2019.
+
+Sergey Levine and Vladlen Koltun. Guided policy search. In International Conference on Machine Learning, pp. 1–9, 2013.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. The Journal of Machine Learning Research, 17(1):1334–1373, 2016.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+James L McClelland, Bruce L McNaughton, and Randall C O’reilly. Why there are complementary learning systems in the hippocampus and neocortex: insights from the successes and failures of connectionist models of learning and memory. Psychological review, 102(3):419, 1995.
+
+Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation, volume 24, pp. 109–165. Elsevier, 1989.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.
+
+Ofir Nachum, Mohammad Norouzi, Kelvin Xu, and Dale Schuurmans. Bridging the gap between value and policy based reinforcement learning. In Advances in Neural Information Processing Systems, pp. 2775–2785, 2017.
+
+Guido Novati and Petros Koumoutsakos. Remember and forget for experience replay. arXiv preprint arXiv:1807.05827, 2018.
+
+Martin L Puterman. Markov Decision Processes.: Discrete Stochastic Dynamic Programming. John Wiley & Sons, 2014.
+
+Roger Ratcliff. Connectionist models of recognition memory: constraints imposed by learning and forgetting functions. Psychological review, 97(2):285, 1990.
+
+Konrad Rawlik, Marc Toussaint, and Sethu Vijayakumar. On stochastic optimal control and reinforcement learning by approximate inference. In Twenty-Third International Joint Conference on Artificial Intelligence, 2013.
+
+Anthony Robins. Catastrophic forgetting, rehearsal and pseudorehearsal. Connection Science, 7(2): 123–146, 1995.
+
+Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. arXiv preprint arXiv:1511.05952, 2015.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International Conference on Machine Learning, pp. 1889–1897, 2015.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Christopher Schulze and Marcus Schulze. Vizdoom: Drqn with prioritized experience replay, double-q learning and snapshot ensembling. In Proceedings of SAI Intelligent Systems Conference, pp. 1–17. Springer, 2018.
+
+Emanuel Todorov. General duality between optimal control and estimation. In 2008 47th IEEE Conference on Decision and Control, pp. 4286–4292. IEEE, 2008.
+
+Hado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. In AAAI, volume 2, pp. 5. Phoenix, AZ, 2016.
+
+Quan Vuong, Yiming Zhang, and Keith W Ross. Supervised policy update for deep reinforcement learning. arXiv preprint arXiv:1805.11706, 2018.
+
+Ziyu Wang, Tom Schaul, Matteo Hessel, Hado Van Hasselt, Marc Lanctot, and Nando De Freitas. Dueling network architectures for deep reinforcement learning. arXiv preprint arXiv:1511.06581, 2015.
+
+Ziyu Wang, Victor Bapst, Nicolas Heess, Volodymyr Mnih, Remi Munos, Koray Kavukcuoglu, and Nando de Freitas. Sample efficient actor-critic with experience replay. arXiv preprint arXiv:1611.01224, 2016.
+
+Rui Zhao and Volker Tresp. Curiosity-driven experience prioritization via density estimation. arXiv preprint arXiv:1902.08039, 2019.
+
+Brian D Ziebart. Modeling purposeful adaptive behavior with the principle of maximum causal entropy. PhD thesis, figshare, 2010.
+
+Brian D Ziebart, Andrew Maas, J Andrew Bagnell, and Anind K Dey. Maximum entropy inverse reinforcement learning. 2008.
+
+# A ABLATION STUDY
+
+In this ablation study we separately examine the importance of $( i )$ the normalization at the output of the policy network; $( i i )$ the double Q networks; (iii) and randomization used in the line 8 of the SOP algorithm (that is, target policy smoothing (Fujimoto et al., 2018)).
+
+Figure 5 shows the results for the five environments considered in this paper. In Figure 5, “no normalization” is SOP without the normalization of the outputs of the policy network; “single $\mathrm { Q } ^ { \mathrm { , } }$ is SOP with one Q-network instead of two; and “no smoothing” is SOP without the randomness in line 8 of the algorithm.
+
+Figure 5 confirms that double Q-networks are critical for obtaining good performance (Van Hasselt et al., 2016; Fujimoto et al., 2018; Haarnoja et al., 2018a). Figure 5 also shows that output normalization is also critical. Without output normalization, performance fluctuates wildly, and average performance can decrease dramatically, particularly for Humanoid and HalfCheetah. Target policy smoothing improves performance by a relatively small amount.
+
+![](images/f121a25f03fa18b60add965b59fe16370fefc3650fc75a7b95f3f7f5da43bfc5.jpg)  
+Figure 5: Ablation Study
+
+# B HYPERPARAMETERS
+
+Table 2 shows hyperparameters used for SOP, $_ { \mathrm { S O P + E R E } }$ and $\mathrm { S O P { + } P E R }$ . For adaptive SAC, we use our own PyTorch implementation for the comparisons. Our implementation uses the same hyperparameters as used in the original paper (Haarnoja et al., 2018b). Our implementation of SOP variants and adaptive SAC share most of the code base. For TD3, our implementation uses the same hyperparamters as used in the authors’ implementation, which is different from the ones in the original paper (Fujimoto et al., 2018). They claimed that the new set of hyperparamters can improve performance for TD3. We now discuss hyperparameter search for better clarity, fairness and reproducibility (Henderson et al., 2018; Duan et al., 2016; Islam et al., 2017).
+
+For the $\eta$ value in the ERE scheme, in our early experiments we tried the values (0.993, 0.994, 0.995, 0.996, 0.997, 0.998) on the Ant and found 0.995 to work well. This initial range of values was decided by computing the ERE sampling range for the oldest data. We found that for smaller values, the range would simply be too small. For the PER scheme, we did some informal preliminary search, then searched on Ant for $\beta _ { 1 }$ in (0, 0.4, 0.6, 0.8), $\beta _ { 2 }$ in (0, 0.4, 0.5, 0.6, 1), and learning rate in (1e-4, 2e-4, 3e-4, 5e-4, 8e-4, 1e-3), we decided to search these values because the original paper used $\beta _ { 1 } = 0 . 6$ , $\beta _ { 2 } = 0 . 4$ and with reduced learning rate. For the exponential sampling scheme, we searched the $\lambda$ value in (3e-7, 1e-6, 3e-6, 5e-6, 1e-5, 3e-5, 5e-5, 1e-4) in Ant, this search range was decided by plotting out the probabilities of sampling, and then pick a set of values that are not too extreme. For $\sigma$ in SOP, in some of our early experiments with SAC, we accidentally found that $\sigma = 0 . 3$ gives good performance for SAC without entropy and with Gaussian noise. We searched values (0.27, 0.28, 0.29, 0.3). For $\sigma$ values for $\mathrm { T D } 3 +$ , we searched values (0.1, 0.15, 0.2, 0.25, 0.3).
+
+Table 2: SOP Hyperparameters   
+
+<table><tr><td rowspan=1 colspan=1>Parameter</td><td rowspan=1 colspan=1>Value</td></tr><tr><td rowspan=1 colspan=1>Sharedoptimizerlearning ratediscount (γ)target smoothing coefficient (p)target update intervalreplay buffer sizenumber of hidden layers for all networksnumber of hidden units per layermini-batch sizenonlinearity</td><td rowspan=1 colspan=1>Adam (Kingma &amp; Ba,2014)3.10-40.990.00511062256256ReLU</td></tr><tr><td rowspan=1 colspan=1>SAC adaptiveentropy target</td><td rowspan=1 colspan=1>dim(A) (e.g., 6 for HalfCheetah-v2)</td></tr><tr><td rowspan=1 colspan=1>SOPgaussian noise std σ = O1 = 02</td><td rowspan=1 colspan=1>0.29</td></tr><tr><td rowspan=1 colspan=1>TD3gaussian noise std for data collection o guassian noise std for target policy smoothing o</td><td rowspan=1 colspan=1>0.1 * action limit0.2</td></tr><tr><td rowspan=1 colspan=1>TD3+gaussian noise std for data collection o guassian noise std for target policy smoothing </td><td rowspan=1 colspan=1>0.150.2</td></tr><tr><td rowspan=1 colspan=1>EREERE initial no</td><td rowspan=1 colspan=1>0.995</td></tr><tr><td rowspan=1 colspan=1>PERPER βi (α in PER paper)PER β2 (β in PER paper)</td><td rowspan=1 colspan=1>0.40.4</td></tr><tr><td rowspan=1 colspan=1>EXPExponential 入</td><td rowspan=1 colspan=1>5e-06</td></tr></table>
+
+# C ERE PSEUDOCODE
+
+1: Input: initial policy parameters $\theta$ , Q-function parameters $\phi _ { 1 }$ , $\phi _ { 2 }$ , empty replay buffer $\mathcal { D }$ of s $N$ , initial $\eta _ { 0 }$ , recent and max performance improvement $I _ { r e c e n t } = I _ { m a x } = 0$ .   
+2: Set target parameters equal to main parameters $\phi _ { \mathrm { t a r g , i } }  \phi _ { i }$ for $\mathrm { i } = 1 , 2$   
+3: repeat   
+4: Generate an episode using actions $a = M \mathrm { t a n h } ( \mu _ { \theta } ( s ) + \epsilon )$ where $\epsilon \sim \mathcal { N } ( 0 , \sigma _ { 1 } )$ .   
+5: update $I _ { r e c e n t } , I _ { m a x }$ with training episode returns, let $K =$ length of episode   
+6: co ute $\begin{array} { r } { \eta = \eta _ { 0 } \cdot \frac { I _ { r e c e n t } } { I _ { m a x } } + ( 1 - \frac { I _ { r e c e n t } } { I _ { m a x } } ) } \end{array}$   
+7: 8: for $j$ in rangompute $( K )$ $c _ { k } = N \cdot \eta ^ { k { \frac { 1 0 0 0 } { K } } }$   
+9: Sample a batch of transitions, $B = \{ ( s , a , r , s ) \}$ from most recent $c _ { k }$ data in $\mathcal { D }$   
+10: Compute targets for Q functions: $\begin{array} { r } { \dot { y } _ { q } ( r , s ^ { \prime } ) = r + \gamma \operatorname* { m i n } _ { i = 1 , 2 } Q _ { \phi _ { \mathrm { t a r g } , i } } ( s ^ { \prime } , M \mathrm { t a n h } ( \mu _ { \theta } ( s ^ { \prime } ) + \delta ) ) \quad \delta \sim \mathcal { N } ( 0 , \sigma _ { 2 } ) } \end{array}$   
+11: Update Q-functions by one step of gradient descent using $\begin{array} { r } { \nabla _ { \phi _ { i } } \frac { 1 } { | B | } \sum _ { ( s , a , r , s ^ { \prime } ) \in B } \big ( Q _ { \phi , i } ( s , a ) - y _ { q } ( r , s ^ { \prime } ) \big ) ^ { 2 } } \end{array}$ for $i = 1 , 2$   
+12: Update policy by one step of gradient ascent using $\begin{array} { r } { \nabla _ { \boldsymbol { \theta } } \frac { 1 } { | \boldsymbol { B } | } \dot { \sum _ { s \in B } } Q _ { \phi , 1 } \big ( \dot { s } , M \operatorname { t a n h } ( \mu _ { \boldsymbol { \theta } } ( s ) ) \big ) } \end{array}$   
+13: Update target networks with ${ \phi } _ { \mathrm { t a r g , i } } \dot {  } \rho { \phi } _ { \mathrm { t a r g , i } } + ( 1 - \rho ) { \phi } _ { i } \mathrm { f o r } i = 1 , 2$
+
+# D INVERTING GRADIENT METHOD
+
+In this section we discuss the details of the Inverting Gradient method.
+
+Hausknecht & Stone (2015) discussed three different methods for bounded parameter space learning: Zeroing Gradients, Squashing Gradients and Inverting Gradients, they analyzed and tested the three methods and found that Inverting Gradients method can achieve much stronger performance than the other two. In our implementation, we remove the tanh function from SOP and use Inverting Gradients instead to bound the actions. Let $p$ indicate the output of the last layer of the policy network. During exploration $p$ will be the mean of a normal distribution that we sample actions from, the IG approach can be summarized by the following equation (Hausknecht & Stone, 2015):
+
+$$
+\nabla _ { p } = \nabla _ { p } \cdot \left\{ \begin{array} { l l } { ( p _ { \mathrm { m a x } } - p ) / ( p _ { \mathrm { m a x } } - p _ { \mathrm { m i n } } ) } & { \mathrm { i f ~ } \nabla _ { p } \mathrm { ~ s u g g e s t s ~ i n c r e a s i n g ~ } p } \\ { ( p - p _ { \mathrm { m i n } } ) / ( p _ { \mathrm { m a x } } - p _ { \mathrm { m i n } } ) } & { \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+Where $\nabla _ { p }$ is the gradient of the policy loss w.r.t to $p$ . During a policy network update, we first backpropagate the gradients from the outputs of the Q network to the output of the policy network for each data point in the batch, we then compute the ratio $( p _ { \mathrm { m a x } } - p ) / ( p _ { \mathrm { m a x } } - p _ { \mathrm { m i n } } )$ or $( p _ { \mathrm { m a x } } -$ $p ) / ( p _ { \mathrm { m a x } } - \bar { p _ { \mathrm { m i n } } } )$ for each $p$ value (each action dimension), depending on the sign of the gradient. We then backpropagate from the output of the policy network to parameters of the policy network, and we modify the gradients in the policy network according to the ratios we computed. We made an efficient implementation and further discuss the computation efficiency of IG in the implementation details section.
+
+# E SOP WITH OTHER SAMPLING SCHEMES
+
+We also investigate the effect of other interesting sampling schemes.
+
+# E.1 SAC WITH PRIORITIZED EXPERIENCE REPLAY
+
+We also implement the proportional variant of Prioritized Experience Replay (Schaul et al., 2015) with SOP.
+
+Since SOP has two Q-networks, we redefine the absolute TD error $| \delta |$ of a transition $( s , a , r , s ^ { \prime } )$ to be the average absolute TD error in the Q network update:
+
+$$
+\vert \delta \vert = \frac 1 2 \sum _ { l = 1 } ^ { 2 } \vert y _ { q } ( r , s ^ { \prime } ) - Q _ { \phi , l } ( s , a ) \vert
+$$
+
+Within the sum, the first term $\begin{array} { r } { y _ { q } ( r , s ^ { \prime } ) = r + \gamma \operatorname* { m i n } _ { i = 1 , 2 } Q _ { \phi _ { \mathrm { t a r g } , i } } ( s ^ { \prime } , \operatorname { t a n h } ( \mu _ { \theta } ( s ^ { \prime } ) + \delta ) ) , \delta \sim \mathcal N ( 0 , \sigma _ { 2 } ) } \end{array}$ is simply the target for the Q network, and the term $Q _ { \theta , l } ( s , a )$ is the current estimate of the $l ^ { t h } \textbf { Q }$ network. For the $i ^ { t h }$ data point, the definition of the priority value $p _ { i }$ is $p _ { i } = | \delta _ { i } | + \epsilon$ . The probability of sampling a data point $P ( i )$ is computed as:
+
+$$
+P ( i ) = \frac { p _ { i } ^ { \beta _ { 1 } } } { \sum _ { j } p _ { j } ^ { \beta _ { 1 } } }
+$$
+
+where $\beta _ { 1 }$ is a hyperparameter that controls how much the priority value affects the sampling probability, which is denoted by $\alpha$ in Schaul et al. (2015), but to avoid confusion with the $\alpha$ in SAC, we denote it as $\beta _ { 1 }$ . The importance sampling (IS) weight $w _ { i }$ for a data point is computed as:
+
+$$
+w _ { i } = ( \frac { 1 } { N } \cdot \frac { 1 } { P ( i ) } ) ^ { \beta _ { 2 } }
+$$
+
+where $\beta _ { 2 }$ is denoted as $\beta$ in Schaul et al. (2015).
+
+Based on the SOP algorithm, we change the sampling method from uniform sampling to sampling using the probabilities $P ( i )$ , and for the Q updates we apply the IS weight $w _ { i }$ . This gives SOP with Prioritized Experience Replay (SOP+PER). We note that as compared with $\mathrm { S O P { + } P E R }$ , ERE does not require a special data structure and has negligible extra cost, while PER uses a sum-tree structure with some additional computational cost. We also tried several variants of $\mathrm { S O P { + } P E R }$ , but preliminary results show that it is unclear whether there is improvement in performance, so we kept the algorithm simple.
+
+# E.2 SOP WITH EXPONENTIAL SAMPLING
+
+The ERE scheme is similar to an exponential sampling scheme where we assign the probability of sampling according to the probability density function of an exponential distribution. Essentially, in such a sampling scheme, the more recent data points get exponentially more probability of being sampled compared to older data.
+
+For the $i ^ { t h }$ most recent data point, the probability of sampling a data point $P ( i )$ is computed as:
+
+$$
+P ( i ) = \lambda e ^ { - \lambda x }
+$$
+
+We apply this sampling scheme to SOP and refer to this variant as SOP+EXP.
+
+# E.3 PER AND EXP EXPERIMENT RESULTS
+
+Figure 6 shows a performance comparison of SOP, SOP $+$ ERE, $\mathrm { S O P { + } E X P }$ and SOP+PER. Results show that the exponential sampling scheme gives a boost to the performance of SOP, and especially in the Humanoid environment, although not as good as ERE. Surprisingly, SOP+PER does not give a significant performance boost to SOP (if any boost at all). We also found that it is difficult to find hyperparameter settings for $\mathrm { S O P { + } P E R }$ that work well for all environments. Some of the other hyperparameter settings actually reduce performance. It is unclear why PER does not work so well for SOP. A similar result has been found in another recent paper (Fu et al., 2019), showing that PER can significantly reduce performance on TD3. Further research is needed to understand how PER can be successfully adapted to environments with continuous action spaces and dense reward structure.
+
+![](images/c6e5d3de5aaf676639243467053f3171722a3785080a07f283480f09babe6955.jpg)  
+Figure 6: Streamlined Off-Policy (SOP), with ERE and PER sampling schemes
+
+# F ADDITIONAL ERE ANALYSIS
+
+Figure 7 shows, for fixed $\eta$ , how $\eta$ affects the data sampling process, under the ERE sampling scheme. Recent data points have a much higher probability of being sampled compared to older data, and a smaller $\eta$ value gives more emphasis to recent data.
+
+Different $\eta$ values are desirable depending on how fast the agent is learning and how fast the past experiences become obsolete. So to make ERE work well in different environments with different reward scales and learning progress, we adapt $\eta$ to the the speed of learning. To this end, define performance to be the training episode return. Define $I _ { r e c e n t }$ to be how much performance improved from $N / 2$ timesteps ago, and $I _ { m a x }$ to be the maximum improvement throughout training, where $N$ is the buffer size. Let the hyperparameter $\eta _ { 0 }$ be the initial $\eta$ value. We then adapt $\eta$ according to the formula: $\eta = \eta _ { 0 } \cdot I _ { r e c e n t } / I _ { m a x } + 1 - ( I _ { r e c e n t } / I _ { m a x } )$ .
+
+Under such an adaptive scheme, when the agent learns quickly, the $\eta$ value is low in order to learn quickly from new data. When progress is slow, $\eta$ is higher to make use of the stabilizing effect of uniform sampling from the whole buffer.
+
+![](images/3b8c311ff8da3cd184d83e3df6a46db4181aa6a1e5df8658994ead13d30cb150.jpg)  
+Figure 7: Effect of different $\eta$ values. The plots assume a replay buffer with 1 million samples, and $1 { , } 0 0 0 \mathrm { m i n i }$ -batches of size 256 in an update phase. Figure $\mathrm { 7 a }$ plots $c _ { k }$ (ranging from 0 to 1 million) as a function of $k$ (ranging from 1 to 1,000). Figure $\mathrm { 7 b }$ plots the expected number of times a data point in the buffer is sampled, with the data points ordered from most to least recent.
+
+# G ADDITIONAL IMPLEMENTATION DETAILS
+
+# G.1 ERE IMPLEMENTATION
+
+In this section we discuss some programming details. These details are not necessary for understanding the algorithm, but they might help with reproducibility.
+
+In the ERE scheme, the sampling range always starts with the entire buffer (1M data) and then gradually shrinks. This is true even when the buffer is not full. So even if there are not many data points in the buffer, we compute $c _ { k }$ based as if there are 1M data points in the buffer. One can also modify the design slightly to obtain a variant that uses the current amount of data points to compute $c _ { k }$ . In addition to the reported scheme, we also tried shrinking the sampling range linearly, but it gives less performance gain.
+
+In our implementation we set the number of updates after an episode to be the same as the number of timesteps in that episode. Since environments do not always end at 1000 timesteps, we can give a more general formula for $c _ { k }$ . Let $K$ be the number of mini-batch updates, let $N$ be the max size of the replay buffer, then:
+
+$$
+c _ { k } = N \cdot \eta ^ { k { \frac { 1 0 0 0 } { K } } }
+$$
+
+With this formulation, the range of sampling shrinks in more or less the same way with varying number of mini-batch updates. We always do uniform sampling in the first update, and we always have ηK 1000K $\eta ^ { K \frac { 1 0 0 0 } { K } } = \eta ^ { 1 0 0 0 }$ η1000 in the last update.
+
+When $\eta$ is small, $c _ { k }$ can also become small for some of the mini-batches. To prevent getting a minibatch with too many repeating data points, we set the minimum value for $c _ { k }$ to 5000. We did not find this value to be too important and did not find the need to tune it. It also does not have any effect for any $\eta \geq 0 . 9 9 5$ since the sampling range cannot be lower than 6000.
+
+In the adaptive scheme with buffer of size 1M, the recent performance improvement is computed as the difference of the current episode return compared to the episode return 500,000 timesteps earlier.
+
+Before we reach 500,000 timesteps, we simply use $\eta _ { 0 }$ . The exact way of computing performance improvement does not have a significant effect on performance as long as it is reasonable.
+
+# G.2 PROGRAMMING AND COMPUTATION COMPLEXITY
+
+In this section we give analysis on the additional programming and computation complexity brought by ERE and PER.
+
+In terms of programming complexity, ERE is a clear winner since it only requires a small adjustment to how we sample mini-batches. It does not modify how the buffer stores the data, and does not require a special data structure to make it work efficiently. Thus the implementation difficulty is minimal. PER (proportional variant) requires a sum-tree data structure to make it run efficiently. The implementation is not too complicated, but compared to ERE it is a lot more work.
+
+The exponential sampling scheme is very easy to implement, although a naive implementation will incur a significant computation overhead when sampling from a large buffer. To improve its computation efficiency, we instead uses an approximate sampling method. We first sample data indexes from segments of size 100 from the replay buffer, and then for each segment sampled, we sample one data point uniformly from that segment.
+
+In terms of computation complexity (not sample efficiency), and wall-clock time, ERE’s extra computation is negligible. In practice we observe no difference in computation time between SOP and SOP+ERE. PER needs to update the priority of its data points constantly and compute sampling probabilities for all the data points. The complexity for sampling and updates is $\bar { O ( l o g ( N ) ) }$ , and the rank-based variant is similar (Schaul et al., 2015). Although this is not too bad, it does impose a significant overhead on SOP: SOP+PER runs twice as long as SOP. Also note that this overhead grows linearly with the size of the mini-batch. The overhead for the Mujoco environments is higher compared to Atari, possibly because the Mujoco environments have a smaller state space dimension while a larger batch size is used, making PER take up a larger portion of computation cost. For the exponential sampling scheme, the extra computation is also close to negligible when using the approximate sampling method.
+
+In terms of the proposed normalization scheme and the Inverting Gradients (IG) method, the normalization is very simple and can be easily implemented and has negligible computation overhead. IG has a simple idea, but its implementation is slightly more complicated than the normalization scheme. When implemented naively, IG can have a large computation overhead, but it can be largely avoided by making sure the gradient computation is still done in a batch-manner. We have made a very efficient implementation and our code is publicly available so that interested reader can easily reproduce it.
+
+# H ADDITIONAL EXPERIMENTAL RESULTS
+
+# H.1 INVERTING GRADIENTS WITH ERE
+
+In Figure 8 we show additional results on applying ERE to $\mathrm { S O P { + } I G }$ . The result shows that after applying the ERE scheme, SOP and IG both get a performance boost. The performance of the $\mathrm { S O P + }$ ERE and $\mathrm { I G } +$ ERE are similar.
+
+# H.2 TD3 VERSUS TD3+
+
+In figure 9, we show additional results comparing TD3 with TD3 plus our normalization scheme, which we refer as $\mathrm { T D } 3 +$ . The results show that after applying our normalization scheme, $\mathrm { T D } 3 +$ has a significant performance boost in Humanoid, while in other environments, both algorithms achieve similar performance.
+
+![](images/8f7dd1103a27e903cbfbfeadb55a5e9f1a033831cbacff2811c2dcf22f1fa2f8.jpg)  
+Figure 8: SOP and inverting gradients with ERE sampling scheme
+
+![](images/7045d822d7700f36c75f37ca47f6c3dab00c6a21b4a2301e841389f146889a93.jpg)  
+Figure 9: TD3 versus $\mathrm { T D } 3 +$ (TD3 plus the normalization scheme)
+
+# I ADDITIONAL ANALYSIS AND RESULTS COMPARING SAC WITH AND WITHOUT ENTROPY
+
+To understand why entropy maximization is important for one environment but less so for another, we examine the actions selected when training SAC with and without entropy. Humanoid and Walker2d have action dimensions $K \ : = \ : 1 7$ and $K \ : = \ : 6$ , respectively. In addition to the representative results shown for one dimension for both environments in Section 3.2, the results for all the dimensions are provided here in Figures 10 and 11.
+
+From Figure 10, we see that for Humanoid using SAC (which uses entropy maximization), the $\left| \mu _ { k } \right|$ values are small and fluctuate significantly for all 17 dimensions. On the other hand, for SAC without entropy the $\left| \mu _ { k } \right|$ values are typically huge, again for all 17 dimensions. This causes the actions $a _ { k }$ to be persistently clustered at either $M$ or - $. M$ . As for Walker, the $\left| \mu _ { k } \right|$ values are sensible for both algorithms for all 6 dimensions, as shown in figure 11.
+
+![](images/6015d4f7d6c478b78b3cc4e75f09ebdbcdfdb6556d8f32f3a1bc3e8a48055e44.jpg)  
+Figure 10: Humanoid-v2: $\mu _ { k }$ and $a _ { k }$ values from SAC and SAC without entropy maximization
+
+![](images/b92a975e229174b4c46170be26078d6908746e7ca97115346a55c5db4d4af0b3.jpg)  
+Figure 10: Humanoid-v2: $\mu _ { k }$ and $a _ { k }$ values from SAC and SAC without entropy maximization
+
+![](images/53d141253c51cb5282a0e113f4f760a51dbee67098f7bf61002c14aee1a50296.jpg)  
+Figure 10: Humanoid-v2: $\mu _ { k }$ and $a _ { k }$ values from SAC and SAC without entropy maximization
+
+![](images/cbcfe5f433989053fc09e9bad90042c630532ca66c5f36f888be6f928c356df1.jpg)  
+Figure 11: Walker2d-v2: $\mu _ { k }$ and $a _ { k }$ values from SAC and SAC without entropy maximization

md/train/SJxhNTNYwB/SJxhNTNYwB.md

@@ -0,0 +1,404 @@
+# BLACK-BOX ADVERSARIAL ATTACK WITH TRANSFERABLE MODEL-BASED EMBEDDING
+
+Zhichao Huang, Tong Zhang   
+The Hong Kong University of Science and Technology   
+zhuangbx@connect.ust.hk, tongzhang@tongzhang-ml.org
+
+# ABSTRACT
+
+We present a new method for black-box adversarial attack. Unlike previous methods that combined transfer-based and scored-based methods by using the gradient or initialization of a surrogate white-box model, this new method tries to learn a low-dimensional embedding using a pretrained model, and then performs efficient search within the embedding space to attack an unknown target network. The method produces adversarial perturbations with high level semantic patterns that are easily transferable. We show that this approach can greatly improve the query efficiency of black-box adversarial attack across different target network architectures. We evaluate our approach on MNIST, ImageNet and Google Cloud Vision API, resulting in a significant reduction on the number of queries. We also attack adversarially defended networks on CIFAR10 and ImageNet, where our method not only reduces the number of queries, but also improves the attack success rate.
+
+# 1 INTRODUCTION
+
+The wide adoption of neural network models in modern applications has caused major security concerns, as such models are known to be vulnerable to adversarial examples that can fool neural networks to make wrong predictions (Szegedy et al., 2014). Methods to attack neural networks can be divided into two categories based on whether the parameters of the neural network are assumed to be known to the attacker: white-box attack and black-box attack. There are several approaches to find adversarial examples for black-box neural networks. The transfer-based attack methods first pretrain a source model and then generate adversarial examples using a standard white-box attack method on the source model to attack an unknown target network (Goodfellow et al., 2015; Madry et al., 2018; Carlini & Wagner, 2017; Papernot et al., 2016a). The score-based attack requires a loss-oracle, which enables the attacker to query the target network at multiple points to approximate its gradient. The attacker can then apply the white-box attack techniques with the approximated gradient (Chen et al., 2017; Ilyas et al., 2018a; Tu et al., 2018).
+
+A major problem of the transfer-based attack is that it can not achieve very high success rate. And transfer-based attack is weak in targeted attack. On the contrary, the success rate of score-based attack has only small gap to the white-box attack but it requires many queries. Thus, it is natural to combine the two black-box attack approaches, so that we can take advantage of a pretrained white-box source neural network to perform more efficient search to attack an unknown target black-box model.
+
+In fact, in the recent NeurIPS 2018 Adversarial Vision Challenge (Brendel et al., 2018), many teams transferred adversarial examples from a source network as the starting point to carry out black-box boundary attack (Brendel et al., 2017). N Attack also used a regression network as initialization in the score-based attack (Li et al., 2019a). The transferred adversarial example could be a good starting point that lies close to the decision boundary for the target network and accelerate further optimization. P-RGF (Cheng et al., 2019) used the gradient information from the source model to accelerate searching process. However, gradient information is localized and sometimes it is misleading. In this paper, we push the idea of using a pretrained white-box source network to guide black-box attack significantly further, by proposing a method called TRansferable EMbedding based Black-box Attack (TREMBA). TREMBA contains two stages: (1) train an encoder-decoder that can effectively generate adversarial perturbations for the source network with a low-dimensional embedding space; (2) apply NES (Natural Evolution Strategy) of (Wierstra et al., 2014) to the low-dimensional embedding space of the pretrained generator to search adversarial examples for the target network. TREMBA uses global information of the source model, capturing high level semantic adversarial features that are insensitive to different models. Unlike noise-like perturbations, such perturbations would have much higher transferablity across different models. Therefore we could gain query efficiency by performing queries in the embedding space.
+
+We note that there have been a number of earlier works on using generators to produce adversarial perturbations in the white-box setting (Baluja & Fischer, 2018; Xiao et al., 2018; Wang & Yu, 2019). While black-box attacks were also considered there, they focused on training generators with dynamic distillation. These early approaches required many queries to fine-tune the classifier for different target networks, which may not be practical for real applications. While our approach also relies on a generator, we train it as an encoder-decoder that produces a low-dimensional embedding space. By applying a standard black-box attack method such as NES on the embedding space, adversarial perturbations can be found efficiently for a target model.
+
+It is worth noting that the embedding approach has also been used in AutoZOOM (Tu et al., 2018). However, it only trained the autoencoder to reconstruct the input, and it did not take advantage of the information of a pretrained network. Although it also produces structural perturbations, these perturbations are usually not suitable for attacking regular networks and sometimes its performance is even worse than directly applying NES to the images (Cheng et al., 2019; Guo et al., 2019). TREMBA, on the other hand, tries to learn an embedding space that can efficiently generate adversarial perturbations for a pretrained source network. Compared to AutoZOOM, our new method produces adversarial perturbation with high level semantic features that could hugely affect arbitrary target networks, resulting in significantly lower number of queries.
+
+We summarize our contributions as follows:
+
+1. We propose TREMBA, an attack method that explores a novel way to utilize the information of a pretrained source network to improve the query efficiency of black-box attack on a target network.   
+2. We show that TREMBA can produce adversarial perturbations with high level semantic patterns, which are effective across different networks, resulting in much lower queries on MNIST and ImageNet especially for the targeted attack that has low transferablity.   
+3. We demonstrate that TREMBA can be applied to SOTA defended models (Madry et al., 2018; Xie et al., 2018). Compared with other black-box attacks, TREMBA increases success rate by approximately $1 0 \%$ while reduces the number of queries by more than $5 0 \%$ .
+
+# 2 RELATED WORKS
+
+There have been a vast literature on adversarial examples. We will cover the most relevant topics including white-box attack, black-box attack and defense methods.
+
+White-Box Attack White-box attack requires the full knowledge of the target model. It was first discovered by (Szegedy et al., 2014) that adversarial examples could be found by solving an optimization problem with L-BFGS (Nocedal, 1980). Later on, other methods were proposed to find adversarial examples with improved success rate and efficiency (Goodfellow et al., 2015; Kurakin et al., 2016; Papernot et al., 2016b; Moosavi-Dezfooli et al., 2016). More recently, it was shown that generators can also construct adversarial noises with high success rate (Xiao et al., 2018; Baluja & Fischer, 2018).
+
+Black-Box Attack Black-box attack can be divided into three categories: transfer-based, score-based and decision-based. It is well known that adversaries have high transferablity across different networks (Papernot et al., 2016a). Transfer-based methods generate adversarial noises on a source model and then transfer it to an unknown target network. It is known that targeted attack is harder than untargeted attack for transfer-based methods, and using an ensemble of source models can improve the success rate (Liu et al., 2016). Score-based attack assumes that the attacker can query the output scores of the target network. The attacker usually uses sampling methods to approximate the true gradient (Chen et al., 2017; Ilyas et al., 2018a; Li et al., 2019a; Chen et al., 2018). AutoZOOM tried to improve the query efficiency by reducing the sampling space with a bilinear transformation or an autoencoder (Tu et al., 2018). (Ilyas et al., 2018b) incorporated data and time prior to accelerate attacking. In contrast to the gradient based method, (Moon et al., 2019) used combinatorial optimization to achieve good efficiency. In decision-based attack, the attacker only knows the output label of the classifier. Boundary attack and its variants are very powerful in this setting (Brendel et al., 2017; Dong et al., 2019). In NeutIPS 2018 Adversarial Vision Challenge (Brendel et al., 2018), some teams combined transfer-based attack and decision-based attack in their attacking methods (Brunner et al., 2018). And in a similar spirit, $\mathcal { N }$ Attack also used a regression network as initialization in score-based attack (Li et al., 2019a). Gradient information from the surrogate model could also be used to accelerate the scored-based attack (Cheng et al., 2019) .
+
+Defense Methods Several methods have been proposed to overcome the vulnerability of neural networks. Gradient masking based methods add non-differential operations in the model, interrupting the backward pass of gradients. However, they are vulnerable to adversarial attacks with the approximated gradient (Athalye et al., 2018; Li et al., 2019a). Adversarial training is the SOTA method that can be used to improve the robustness of neural networks. Adversarial training is a minimax game. The outside minimizer performs regular training of the neural network, and the inner maximizer finds a perturbation of the input to attack the network. The inner maximization process can be approximated with FGSM (Goodfellow et al., 2015), PGD (Madry et al., 2018), adversarial generator (Wang & Yu, 2019) etc. Moreover, feature denoising can improve the robustness of neural networks on ImageNet (Xie et al., 2018).
+
+# 3 BLACK-BOX ADVERSARIAL ATTACK WITH GENERATOR
+
+Consider a DNN classifier $F ( x )$ . Let $x \in [ 0 , 1 ] ^ { \dim ( x ) }$ be an input, and let $F ( x )$ be the output vector obtained before the softmax layer. We denote $F ( x ) _ { i }$ as the $i$ -th component for the output vector and $y$ as the label for the input. For un-targeted attack, our goal is to find a small perturbation $\delta$ such that the classifier predicts the wrong label, i.e. arg max $F ( x + \delta ) \neq y$ . And for targeted attack, we want the classifier to predicts the target label $t$ , i.e. arg max $F ( x + \delta ) = t$ . The perturbation $\delta$ is usually bounded by $\ell _ { p }$ norm: $\| \delta \| _ { p } \leq \varepsilon$ , with a small $\varepsilon > 0$ .
+
+Adversarial perturbations often have high transferablity across different DNNs. Given a white-box source DNN $F _ { s }$ with known architecture and parameters, we can transfer its white-box adversarial perturbation $\delta _ { s }$ to a black-box target DNN $F _ { t }$ with reasonably good success rate. It is known that even if $x + \delta _ { s }$ fails to be an adversarial example, $\delta _ { s }$ can still act as a good starting point for searching adversarial examples using a score-based attack method. This paper shows that the information of $F _ { s }$ can be further utilized to train a generator, and performing search on its embedding space leads to more efficient black-box attacks of an unknown target network $F _ { t }$ .
+
+# 3.1 GENERATING ADVERSARIAL PERTURBATIONS WITH GENERATOR
+
+Adversarial perturbations can be generated by a generator network $\mathcal { G }$ . We explicitly divide the generator into two parts: an encoder $\mathcal { E }$ and a decoder $\mathcal { D }$ . The encoder takes the origin input $x$ and output a latent vector $z = \mathcal { E } ( x )$ , where $\dim ( z ) \ll \dim ( x )$ . The decoder takes $z$ as the input and outputs an adversarial perturbation $\delta = \varepsilon \operatorname { t a n h } ( \mathcal { D } ( z ) )$ with $\dim ( \delta ) = \dim ( x )$ . In our new method, we will train the generator $\mathcal { G }$ so that $\delta = \varepsilon \operatorname { t a n h } ( \mathcal { G } ( x ) )$ can fool the source network $F _ { s }$ .
+
+Suppose we have a training set $\left\{ \left( x _ { 1 } , y _ { 1 } \right) , \ldots , \left( x _ { n } , y _ { n } \right) \right\}$ , where $x _ { i }$ denotes the input and $y _ { i }$ denotes its label. For un-targeted attack, we train the desired generator by minimizing the hinge loss used in the C&W attack (Carlini & Wagner, 2017):
+
+$$
+\mathcal { L } _ { \mathrm { u n t a r g e t } } ( x _ { i } , y _ { i } ) = \operatorname* { m a x } \left( F _ { s } ( \varepsilon \operatorname { t a n h } ( \mathcal { G } ( x _ { i } ) ) + x _ { i } ) _ { y _ { i } } - \operatorname* { m a x } _ { j \neq y _ { i } } F _ { s } ( \varepsilon \operatorname { t a n h } ( \mathcal { G } ( x _ { i } ) ) + x _ { i } ) _ { j } , - \kappa \right) ,
+$$
+
+And for targeted, we use
+
+$$
+\mathcal { L } _ { \mathrm { t a r g e t } } ( x _ { i } , t ) = \operatorname* { m a x } \left( \operatorname* { m a x } _ { j \neq t } F _ { s } ( \varepsilon \operatorname { t a n h } ( \mathcal { G } ( x _ { i } ) ) + x _ { i } ) _ { j } - F _ { s } ( \varepsilon \operatorname { t a n h } ( \mathcal { G } ( x _ { i } ) ) + x _ { i } ) _ { t } , - \kappa \right) ,
+$$
+
+where $t$ denotes the targeted class and $\kappa$ is the margin parameter that can be used to adjust transferability of the generator. A higher value of $\kappa$ leads to higher transferability to other models (Carlini & Wagner, 2017). We focus on $\ell _ { \infty }$ norm in this work. By adding point-wise tanh function to an unnormalized output $\mathcal { D } ( z )$ , and scaling it with $\varepsilon$ $, \delta = \varepsilon \operatorname { t a n h } ( \mathcal { D } ( z ) )$ is already bounded as $\| \delta \| _ { \infty } < \varepsilon$ .
+
+Therefore we employ this transformation, so that we do not need to impose the infinity norm constraint explicitly. While hinge loss is employed in this paper, we believe other loss functions such the cross entropy loss will also work.
+
+# 3.2 SEARCH OVER LATENT SPACE WITH NES
+
+Given a new black-box DNN classifier $F _ { t } ( x )$ , for which we can only query its output at any given point $x$ . As in (Ilyas et al., 2018a; Wierstra et al., 2014), we can employ NES to approximate the gradient of a properly defined surrogate loss in order to find an adversarial example. Denote the surrogate loss by $\mathcal { L }$ , rather than calculating $\nabla _ { \delta } \mathcal { L } ( x + \delta , y )$ directly, NES update $\delta$ by using $\nabla _ { \delta } \mathbb { E } _ { \omega \sim \mathcal { N } ( \delta , \sigma ^ { 2 } ) } [ L ( x + \omega , y ) ]$ , which can be transformed into $\mathbb { E } _ { \omega \sim \mathcal { N } ( \delta , \sigma ^ { 2 } ) } [ L ( x + \omega , y ) \nabla _ { \omega } \log ( \mathcal { N } ( \omega | \delta , \sigma ^ { 2 } ) ) ]$ . The expectation can be approximated by taking finite samples. And we could use the following equation to iteratively update $\delta$ :
+
+$$
+\delta _ { t + 1 } = \prod _ { [ - \varepsilon , \varepsilon ] } ( \delta _ { t } - \eta \cdot \mathrm { s i g n } ( \frac { 1 } { b } \sum _ { k = 1 } ^ { b } \mathcal { L } ( x + \omega _ { k } , y ) \nabla \log \mathcal { N } ( \omega _ { k } | \delta _ { t } , \sigma ^ { 2 } ) ) ) ,
+$$
+
+where $\eta$ is the learning rate, $b$ is the minibatch sample size, $\omega _ { k }$ is the sample from the gaussian distribution and $\Pi _ { [ - \varepsilon , \varepsilon ] }$ represents a clipping operation, which projects $\delta$ onto the $\ell _ { \infty }$ ball. The sign function provides an approximation of the gradient, which has been widely used in adversarial attack (Ilyas et al., 2018a; Madry et al., 2018). However, it is observed that more effective attacks can be obtained by removing the sign function (Li et al., 2019b). Therefore in this work, we remove the sign function from Eqn (3) and directly use the estimated gradient.
+
+Instead of performing search on the input space, TREMBA performs search on the embedding space $z$ . The generator $\mathcal { G }$ explores the weakness of the source DNN $F _ { s }$ so that $\mathcal { D }$ produces perturbations that can effective attack $F _ { s }$ . For a different unknown target network $F _ { t }$ , we show that our method can still generate perturbations leading to more effective attack of $F _ { t }$ . Given an input $x$ and its label $y$ we choose a starting point $z ^ { 0 } = \mathcal { E } \bar { ( x ) }$ . The gradient of $z ^ { t }$ given by NES can be estimated as:
+
+$$
+\begin{array} { r l } & { \nabla _ { z ^ { t } } \mathcal { L } ( x + \varepsilon \operatorname { t a n h } ( \mathcal { D } ( z ^ { t } ) ) , y ) \approx \nabla _ { z ^ { t } } \mathbb { E } _ { \nu \sim \mathcal { N } ( z ^ { t } , \sigma ^ { 2 } ) } \left[ \mathcal { L } ( x + \varepsilon \operatorname { t a n h } ( \mathcal { D } ( \nu ) ) , y ) \right] } \\ & { \qquad \approx \displaystyle \frac { 1 } { b } \sum _ { k = 1 } ^ { b } \mathcal { L } ( x + \varepsilon \operatorname { t a n h } ( \mathcal { D } ( \nu _ { k } ) ) , y ) \nabla _ { z ^ { t } } \log \mathcal { N } ( \nu _ { k } | z ^ { t } , \sigma ^ { 2 } ) . } \end{array}
+$$
+
+where $\nu _ { k }$ is the sample from the gaussian distribution $\mathcal { N } ( z ^ { t } , \sigma ^ { 2 } )$ . Moreover, $z ^ { t }$ is updated with stochastic gradient descent. The detailed procedure is presented in Algorithm 1. We do not need to do projection explicitly since $\delta$ already satisfies $\| \delta \| _ { \infty } < \varepsilon$ .
+
+Next we shall briefly explain why applying NES on the embedding space $z$ can accelerate the search process. Adversarial examples can be viewed as a distribution lying around a given input. Usually this distribution is concentrated on some small regions, making the search process relatively slow. After training on the source network, the adversarial perturbations of TREMBA would have high level semantic patterns that are likely to be adversarial patterns of the target network. Therefore searching over $z$ is like searching adversarial examples in a lower dimensional space containing likely adversarial patterns. The distribution of adversarial perturbations in this space is much less concentrated. It is thus much easier to find effective adversarial patterns in the embedding space.
+
+# 4 EXPERIMENTS
+
+We evaluated the number of queries versus success rate of TREMBA on undefended network in two datasets: MNIST (LeCun et al., 1998) and ImageNet (Russakovsky et al., 2015). Moreover, we evaluated the efficiency of our method on adversarially defended networks in CIFAR10 (Krizhevsky & Hinton, 2009) and ImageNet. We also attacked Google Cloud Vision API to show TREMBA can generalize to truly black-box model.1 We used the hinge loss from Eqn 1 and 2 as the surrogate loss for un-targeted and targeted attack respectively.
+
+We compared TREMBA to four methods: (1) NES: Method introduced by (Ilyas et al., 2018a), but without the sign function for reasons explained earlier. (2) Trans-NES: Take an adversarial
+
+Input: Target Network $F _ { t }$ ; Input $x$ and its label $y$ or the target class $t$ ; Encoder $\mathcal { E }$ ; Decoder $\mathcal { D }$ ; Standard deviation $\sigma$ ; Learning rate $\eta$ ; Sample size $b$ ; Iterations $T$ ; Bound for adversarial perturbation $\varepsilon$   
+Output: Adversarial perturbation $\delta$   
+1: $\bar { z } _ { 0 } = \mathcal { E } ( x )$   
+2: for $t = 1$ to $T$ do   
+3: Sample Gaussian noise $\nu _ { 1 } , \nu _ { 2 } , \cdot \cdot \cdot , \nu _ { b } \sim \mathcal { N } ( z _ { t - 1 } , \sigma ^ { 2 } )$   
+4: Calculate $\begin{array} { r } { \mathcal { L } _ { i } = \mathcal { L } _ { \mathrm { u n t a r g e t } } ( x , y ) } \end{array}$ or $\mathcal { L } _ { \mathrm { t a r g e t } } ( x , t )$   
+5: Update $\begin{array} { r } { z _ { t } = z _ { t - 1 } - \frac { \eta } { b } \sum _ { i = 1 } ^ { b } \mathcal { L } _ { i } \nabla _ { z _ { t - 1 } } \log \mathcal { N } ( \nu _ { i } | z _ { t - 1 } , \sigma ^ { 2 } ) } \end{array}$   
+6: end for   
+7: return $\delta = \varepsilon \operatorname { t a n h } ( \mathcal { D } ( z _ { T } ) )$
+
+perturbation generated by PGD or FGSM on the source model to initialize NES. (3) AutoZOOM: Attack target network with an unsupervised autoencoder described in (Tu et al., 2018). For fair comparisons with other methods, the strategy of choosing sample size was removed. (4) P-RGF: Prior-guided random gradient-free method proposed in (Cheng et al., 2019). The $\mathrm { P - R G F _ { D } } ( \lambda ^ { * } )$ version was compared. We also combined P-RGF with initialization from Trans- ${ \bf \cdot N E S _ { P G D } }$ to form a more efficient method for comparison, denoted by Trans-P-RGF.
+
+Since different methods achieve different success rates, we need to compare their efficiency at different levels of success rate. For method $i$ with success rate $s _ { i }$ , the average number of queries is $q _ { i }$ for all success examples. Let $q ^ { * }$ denote the upper limit of queries, we modified the average number of queries to be $q _ { i } ^ { * } = [ ( \operatorname* { m a x } _ { j } s _ { j } - s _ { i } ) \cdot q ^ { * } + s _ { i } \cdot q _ { i } ] / \operatorname* { m a x } _ { j } s _ { j }$ , which unified the level of success rate and treated queries of failure examples as the upper limit on the number of queries. Average queries sometimes could be misleading due to the the heavy tail distribution of queries. Therefore we plot the curve of success rate at different query levels to show the detailed behavior of different attacks.
+
+The upper limit on the number of queries was set to 50000 for all datasets, which already gave very high success rate for nearly all the methods. Only correctly classified images were counted towards success rate and average queries. And to fairly compare these methods, we chose the sample size to be the same for all methods. We also added momentum and learning decay for optimization. And we counted the queries as one if its starting point successfully attacks the target classifier. The learning rate was fine-tuned for all algorithms. We listed the hyperparameters and architectures of generators and classifiers in Appendix B and C.
+
+# 4.1 BLACK-BOX ATTACK ON MNIST
+
+We trained four neural networks on MNIST, denoted by ConvNet1, ConvNet1\*, ConvNet2 and FCNet. ConvNet1\* and ConvNet1 have the same architecture but different parameters. All the network achieved about $9 9 \%$ accuracy. The generator $\mathcal { G }$ was trained on ConvNet1\* using all images from the training set. Each attack was tested on images from the MNIST test set. The limit of $\ell _ { \infty }$ was $\varepsilon = 0 . 2$
+
+We performed un-targeted attack on MNIST. Table 1 lists the success rate and the average queries. Although the success rate of TREMBA is slightly lower than Trans-NES in ConvNet1 and FCNet, their success rate are already close to $1 0 0 \%$ and TREMBA achieves about $5 0 \%$ reduction of queries compared with other attacks. In contrast to efficient attack on ImageNet, P-RGF and Trans-P-RGF behaves very bad on MNIST. Figure 4.1 shows that TREMBA consistently achieves higher success rate at nearly all query levels.
+
+# 4.2 BLACK-BOX ATTACK ON IMAGENET
+
+We randomly divided the ImageNet validation set into two parts, containing 49000 and 1000 images respectively. The first part was used as the training data for the generator $\mathcal { G }$ , and the second part was used for evaluating the attacks. We evaluated the efficiency of all adversarial attacks on VGG19 (Simonyan & Zisserman, 2014), Resnet34 (He et al., 2016), DenseNet121 (Huang et al., 2017) and MobilenetV2 (Sandler et al., 2018). All networks were downloaded using torchvision package. We set $\varepsilon = 0 . 0 3 1 2 5$ .
+
+Table 1: Success rate and average queries of un-targeted attack on MNIST. $\varepsilon = 0 . 2$   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">ConvNet1</td><td colspan="2">ConvNet2</td><td colspan="2">FCNet</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>NES</td><td>97.88%</td><td>4380</td><td>90.32%</td><td>5428</td><td>99.98%</td><td>1183</td></tr><tr><td>Trans-NESPGD</td><td>98.65%</td><td>2113</td><td>90.22%</td><td>4691</td><td>99.99 %</td><td>818</td></tr><tr><td>Trans-NESFGSM</td><td>98.34%</td><td>3592</td><td>91.32%</td><td>4218</td><td>99.99%</td><td>1540</td></tr><tr><td>AutoZOOM</td><td>93.39%</td><td>5874</td><td>91.21%</td><td>2645</td><td>99.69%</td><td>823</td></tr><tr><td>P-RGF</td><td>68.53%</td><td>16135</td><td>39.85%</td><td>29692</td><td>90.42%</td><td>8289</td></tr><tr><td>Trans-P-RGF</td><td>66.34%</td><td>16428</td><td>27.57%</td><td>35576</td><td>68.39%</td><td>18818</td></tr><tr><td>TREMBA</td><td>98.00%</td><td>1064</td><td>92.63%</td><td>1359</td><td>99.75%</td><td>470</td></tr></table>
+
+![](images/62477a1ba933fee061fd231bbb9e64a52892f505e208cb4783fe74c2be01827c.jpg)  
+Figure 1: Success rate of un-targeted attack at different query levels for undefended MNIST models.
+
+Following (Liu et al., 2016), we used an ensemble (VGG16, Resnet18, Squeezenet (Iandola et al., 2016) and Googlenet (Szegedy et al., 2015)) as the source model to improve transferablity (Liu et al., 2016) for both targeted and un-targeted attack. TREMBA, Trans-NES, P-RGF and Trans-P-RGF all used the same source model for fair comparison. We chose several target class. Here, we show the result of attacking class 0 (tench) in Table 2 and Figure 2. And we leave the result of attacking other classes in Appendix A.1. The average queries for TREMBA is about 1000 while nearly all the average queries for other methods are more than 6000. TREMBA also achieves much lower queries for un-targeted attack on ImageNet. The result is shown in Appendix A.2 due to space limitation. And we also compared TREMBA with CombOpt (Moon et al., 2019) in the Appendix A.9.
+
+Figure 3 shows the adversarial perturbations of different methods. Unlike adversarial perturbations produced by PGD, the perturbations of TREMBA reflect some high level semantic patterns of the targeted class such as the fish scale. As neural networks usually capture such patterns for classification, the adversarial perturbation of TREMBA would be more easy to transfer than the noise-like perturbation produced by PGD. Therefore TREMBA can search very effectively for the target network. More examples of perturbations of TREMBA are shown in Appendix A.3.
+
+Choice of ensemble: We performed attack on different ensembles of source model, which is shown in Appendix A.4. TREMBA outperforms the other methods in different ensemble model. And more source networks lead to better transferability for TREMBA, Trans-NES and Trans-P-RGF.
+
+Varying $\varepsilon$ : We also changed $\varepsilon$ and performed attack on $\varepsilon \ = \ 0 . 0 2$ and $\varepsilon ~ = ~ 0 . 0 4$ . As shown in Appendix A.5, TREMBA still outperforms the other methods despite using the $\mathcal { G }$ trained on $\varepsilon = 0 . 0 3 1 2 5$ . We also show the result of TREMBA for commonly used $\varepsilon = 0 . 0 5$ .
+
+Sample size and dimension the embedding space: To justify the choice of sample size, we performed a hyperparameter sweep over $b$ and the result is shown in Appendix A.6. And we also changed the dimension of the embedding space for AutoZOOM and Trans-P-RGF. As shown in Appendix A.7, the performance gain of TREMBA does not purely come from the diminishing of dimension of the embedding space.
+
+# 4.3 BLACK-BOX ATTACK ON DEFENDED MODELS
+
+This section presents the results for attacking defended networks. We performed un-targeted attack on two SOTA defense methods on CIFAR10 and ImageNet. MNIST is not studied since it is already robust against very strong white-box attacks. For CIFAR10, the defense model was going through PGD minimax training (Madry et al., 2018). We directly used their model as the source network2, denoted by WResnet. To test whether these methods can transfer to a defended network with a different architecture, we trained a defended ResNeXt (Xie et al., 2017) using the same method. For ImageNet, we used the SOTA model3 from (Xie et al., 2018). We used "ResNet152 Denoise" as the source model and transfered adversarial perturbations to the most robust "ResNeXt101 DenoiseAll". Following the previous settings, we set $\varepsilon = 0 . 0 3 1 2 5$ for both CIFAR10 and ImageNet.
+
+Table 2: Success rate and average queries of black-box targeted attack on ImageNet. Targeted class is class 0 (tench). $\varepsilon = 0 . 0 3 1 2 5$   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">VGG19</td><td colspan="2">Resnet34</td><td colspan="2">DenseNet121</td><td colspan="2">MobilenetV2</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>NES</td><td>94.86%</td><td>12283</td><td>93.89%</td><td>14418</td><td>95.65%</td><td>12538</td><td>97.76%</td><td>10276</td></tr><tr><td>Trans-NESPGD</td><td>96.26%</td><td>6854</td><td>95.97%</td><td>8737</td><td>96.59%</td><td>8627</td><td>98.04%</td><td>9375</td></tr><tr><td>Trans-NESFGSM</td><td>90.85%</td><td>12885</td><td>91.81%</td><td>14090</td><td>93.61%</td><td>12859</td><td>97.48%</td><td>9983</td></tr><tr><td>AutoZOOM</td><td>25.80%</td><td>40195</td><td>26.25%</td><td>39681</td><td>31.98%</td><td>37628</td><td>27.03%</td><td>39689</td></tr><tr><td>P-RGF</td><td>96.12%</td><td>6951</td><td>90.28%</td><td>10221</td><td>91.84%</td><td>11563</td><td>88.94%</td><td>14596</td></tr><tr><td>Trans-P-RGF</td><td>98.06%</td><td>2262</td><td>93.61%</td><td>6309</td><td>94.69%</td><td>7263</td><td>91.60%</td><td>10048</td></tr><tr><td>TREMBA</td><td>98.47%</td><td>853</td><td>96.38%</td><td>1206</td><td>98.50%</td><td>1124</td><td>99.16%</td><td>1210</td></tr></table>
+
+![](images/39740db59edfe97f8e352e9e85b41520b0ee4ad16eaddb24968de5b4c4dc5804.jpg)  
+Figure 2: The success rate of black-box adversarial targeted attack at different query levels for ImageNet models. The targeted class is tench
+
+![](images/b2b014bf7c795555e27940cc09cc94ede76a925f4db69d34200ae8000fd64c81.jpg)  
+Figure 3: Visualization of adversarial perturbations targeted at tench
+
+As shown in Table 3, TREMBA achieves higher success rates with lower number of queries. TREMBA achieves about $1 0 \%$ improvement of success rate while the average queries are reduced by more than $5 0 \%$ on ImageNet and by $8 0 \%$ on CIFAR10. The curves in Figure 4(a) and 4(b) show detailed behaviors. The performance of AutoZOOM surpasses Trans-NES on defended models. We suspect that low-frequency adversarial perturbations produced by AutoZOOM will be more suitable to fool the defended models than the regular networks. However, the patterns learned by AutoZOOM are still worse than adversarial patterns learned by TREMBA from the source network.
+
+Table 3: Success rate of average queries of black-box un-targeted attack on defended CIFAR10 and ImageNet model. Source network is WResNet and ResNet152 Denoise.   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">CIFAR10 ResneXt</td><td colspan="2">ImageNet RexneXt101 DenoiseAll</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>NES</td><td>32.17%</td><td>24521</td><td>29.72%</td><td>26526</td></tr><tr><td>Trans-NESPGD</td><td>32.92%</td><td>20735</td><td>32.84%</td><td>20446</td></tr><tr><td>Trans-NESFGSM</td><td>33.17%</td><td>20873</td><td>33.66%</td><td>18547</td></tr><tr><td>AutoZOOM</td><td>33.70%</td><td>14870</td><td>38.75%</td><td>14605</td></tr><tr><td>P-RGF</td><td>22.37%</td><td>25818</td><td>32.51%</td><td>17926</td></tr><tr><td>Trans-P-RGF</td><td>20.88%</td><td>27222</td><td>31.03%</td><td>19262</td></tr><tr><td>TREMBA</td><td>42.73%</td><td>2528</td><td>49.59%</td><td>5985</td></tr><tr><td>TREMBAoSP</td><td>41.56%</td><td>4994</td><td>50.41%</td><td>4771</td></tr></table>
+
+![](images/30f8ae897e88cefc589a0c55c6e999bf8bea782c67b5049c0de9d88e6baaf067.jpg)  
+Figure 4: The success rate at different query levels for defended CIFAR10 and ImageNet models. (a)CIFAR10; (b)ImageNet.
+
+Table 4: Success rate and average queries of un-targeted attack of 10 images on Google Vision API.   
+
+<table><tr><td>Method</td><td>NES</td><td>AutoZOOM</td><td>Trans-NESPGD</td><td>P-RGF</td><td>Trans-P-RGF</td><td>TREMBA</td></tr><tr><td>Success</td><td>70.00%</td><td>20.00%</td><td>70.00%</td><td>50.00%</td><td>60.00%</td><td>90.00%</td></tr><tr><td>Queries</td><td>245</td><td>410</td><td>114</td><td>324</td><td>167</td><td>8</td></tr></table>
+
+An optimized starting point for TREMBA: $z _ { 0 } = \mathcal { E } ( x )$ is already a good starting point for attacking undefended networks. However, the capability of generator is limited for defended networks (Wang & Yu, 2019). Therefore, $z _ { \mathrm { 0 } }$ may not be the best starting point we can get from the defended source network. To enhance the usefulness of the starting point, we optimized $z$ on the source network by gradient descent and found
+
+$$
+z _ { 0 } ^ { * } = \underset { z } { \mathrm { a r g } } \underset { n } { \mathrm { m i n } } \operatorname* { m a x } \left( F _ { s } ( \varepsilon \operatorname { t a n h } ( \mathcal { D } ( z ) ) + x ) _ { y } - \underset { j \neq y _ { i } } { \mathrm { m a x } } F _ { s } ( \varepsilon \operatorname { t a n h } ( \mathcal { D } ( z ) ) + x ) _ { j } , - \kappa \right) .
+$$
+
+The method is denoted by TREMBAOSP (TREMBA with optimized starting point). Figure 4 shows TREMBAOSP has higher success rate at small query levels, which means its starting point is better than TREMBA.
+
+# 4.4 ATTACK GOOGLE CLOUD VISION API
+
+We also attacked the Google Cloud Vision API, which was much harder to attack than the single neural network. Therefore we set $\varepsilon = 0 . 0 5$ and perform un-targeted attack on the API, changing the top1 label to whatever is not on top1 before. We chose 10 images for the ImageNet dataset and set query limit to be 500 due to high cost to use the API. As shown Table 4, TREMBA achieves much higher accuracy success rate and lower number of queries. We show the example of successfully attacked image in Appendix A.8.
+
+# 5 CONCLUSION
+
+We propose a novel method, TREMBA, to generate likely adversarial patterns for an unknown network. The method contains two stages: (1) training an encoder-decoder to generate adversarial perturbations for the source network; (2) search adversarial perturbations on the low-dimensional embedding space of the generator for any unknown target network. Compared with SOTA methods, TREMBA learns an embedding space that is more transferable across different network architectures. It achieves two to six times improvements in black-box adversarial attacks on MNIST and ImageNet and it is especially efficient in performing targeted attack. Furthermore, TREMBA demonstrates great capability in attacking defended networks, resulting in a nearly $1 0 \%$ improvement on the attack success rate, with two to six times of reductions in the number of queries. TREMBA opens up new ways to combine transfer-based and score-based attack methods to achieve higher efficiency in searching adversarial examples.
+
+For targeted attack, TREMBA requires different generators to attack different classes. We believe methods from conditional image generation (Mirza & Osindero, 2014) may be combined with TREMBA to form a single generator that could attack multiple targeted classes. We leave it as a future work.
+
+# REFERENCES
+
+Anish Athalye, Nicholas Carlini, and David A. Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, 2018. URL http://proceedings.mlr. press/v80/athalye18a.html.
+
+Shumeet Baluja and Ian Fischer. Learning to attack: Adversarial transformation networks. In Proceedings of AAAI-2018, 2018. URL http://www.esprockets.com/papers/aaai2018. pdf.
+
+Wieland Brendel, Jonas Rauber, and Matthias Bethge. Decision-based adversarial attacks: Reliable attacks against black-box machine learning models. arXiv preprint arXiv:1712.04248, 2017.
+
+Wieland Brendel, Jonas Rauber, Alexey Kurakin, Nicolas Papernot, Behar Veliqi, Marcel Salathé, Sharada P Mohanty, and Matthias Bethge. Adversarial vision challenge. In 32nd Conference on Neural Information Processing Systems (NIPS 2018) Competition Track, 2018. URL https: //arxiv.org/abs/1808.01976.
+
+Thomas Brunner, Frederik Diehl, Michael Truong Le, and Alois Knoll. Guessing smart: Biased sampling for efficient black-box adversarial attacks. arXiv preprint arXiv:1812.09803, 2018.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy (SP), pp. 39–57. IEEE, 2017.
+
+Jinghui Chen, Jinfeng Yi, and Quanquan Gu. A frank-wolfe framework for efficient and effective adversarial attacks. arXiv preprint arXiv:1811.10828, 2018.
+
+Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 15–26. ACM, 2017.
+
+Shuyu Cheng, Yinpeng Dong, Tianyu Pang, Hang Su, and Jun Zhu. Improving black-box adversarial attacks with a transfer-based prior. arXiv preprint arXiv:1906.06919, 2019.
+
+Yinpeng Dong, Hang Su, Baoyuan Wu, Zhifeng Li, Wei Liu, Tong Zhang, and Jun Zhu. Efficient decision-based black-box adversarial attacks on face recognition. arXiv preprint arXiv:1904.04433, 2019.
+
+Ian Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In International Conference on Learning Representations, 2015. URL http:// arxiv.org/abs/1412.6572.
+
+Chuan Guo, Jacob R Gardner, Yurong You, Andrew Gordon Wilson, and Kilian Q Weinberger. Simple black-box adversarial attacks. arXiv preprint arXiv:1905.07121, 2019.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017.
+
+Forrest N Iandola, Song Han, Matthew W Moskewicz, Khalid Ashraf, William J Dally, and Kurt Keutzer. Squeezenet: Alexnet-level accuracy with $5 0 \mathrm { x }$ fewer parameters and $< 0 . 5 \mathrm { m b }$ model size. arXiv preprint arXiv:1602.07360, 2016.
+
+Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box adversarial attacks with limited queries and information. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 2137–2146, Stockholmsmässan, Stockholm Sweden, 10–15 Jul 2018a. PMLR.
+
+Andrew Ilyas, Logan Engstrom, and Aleksander Madry. Prior convictions: Black-box adversarial attacks with bandits and priors. arXiv preprint arXiv:1807.07978, 2018b.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016.
+
+Yann LeCun, Léon Bottou, Yoshua Bengio, Patrick Haffner, et al. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Yandong Li, Lijun Li, Liqiang Wang, Tong Zhang, and Boqing Gong. Nattack: Learning the distributions of adversarial examples for an improved black-box attack on deep neural networks. arXiv preprint arXiv:1905.00441, 2019a.
+
+Yandong Li, Lijun Li, Liqiang Wang, Tong Zhang, and Boqing Gong. NATTACK: A STRONG AND UNIVERSAL GAUSSIAN BLACK-BOX ADVERSARIAL ATTACK, 2019b. URL https: //openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ ryeoxnRqKQ.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. arXiv preprint arXiv:1611.02770, 2016.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } }$ rJzIBfZAb.
+
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint arXiv:1411.1784, 2014.
+
+Seungyong Moon, Gaon An, and Hyun Oh Song. Parsimonious black-box adversarial attacks via efficient combinatorial optimization. arXiv preprint arXiv:1905.06635, 2019.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2574–2582, 2016.
+
+Jorge Nocedal. Updating quasi-newton matrices with limited storage. Mathematics of computation, 35(151):773–782, 1980.
+
+Nicolas Papernot, Patrick McDaniel, and Ian Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. arXiv preprint arXiv:1605.07277, 2016a.
+
+Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In 2016 IEEE European Symposium on Security and Privacy (EuroS&P), pp. 372–387. IEEE, 2016b.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015.
+
+Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4510–4520, 2018.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations, 2014. URL http://arxiv.org/abs/1312.6199.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1–9, 2015.
+
+Chun-Chen Tu, Paishun Ting, Pin-Yu Chen, Sijia Liu, Huan Zhang, Jinfeng Yi, Cho-Jui Hsieh, and Shin-Ming Cheng. Autozoom: Autoencoder-based zeroth order optimization method for attacking black-box neural networks. arXiv preprint arXiv:1805.11770, 2018.
+
+Huaxia Wang and Chun-Nam Yu. A direct approach to robust deep learning using adversarial networks. In International Conference on Learning Representations, 2019. URL https:// openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ S1lIMn05F7.
+
+Daan Wierstra, Tom Schaul, Tobias Glasmachers, Yi Sun, Jan Peters, and Jürgen Schmidhuber. Natural evolution strategies. The Journal of Machine Learning Research, 15(1):949–980, 2014.
+
+Chaowei Xiao, Bo Li, Jun-Yan Zhu, Warren He, Mingyan Liu, and Dawn Song. Generating adversarial examples with adversarial networks, 2018. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ HknbyQbC-.
+
+Cihang Xie, Yuxin Wu, Laurens van der Maaten, Alan Yuille, and Kaiming He. Feature denoising for improving adversarial robustness. arXiv preprint arXiv:1812.03411, 2018.
+
+Saining Xie, Ross Girshick, Piotr Dollár, Zhuowen Tu, and Kaiming He. Aggregated residual transformations for deep neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1492–1500, 2017.
+
+# A EXPERIMENT RESULT
+
+A.1 TARGETED ATTACK ON IMAGENET
+
+Figure 9 shows result of the targeted attack on dipper, American chameleon, night snake, ruffed grouse and black swan. TREMBA achieves much higher success rate than other methods at almost all queries level.
+
+# A.2 UN-TARGETED ATTACK ON IMAGENET
+
+We used the same source model from targeted attack as the source model for un-targeted attack. We report our evaluation results in Table 5 and Figure 5. Compared with Trans-P-RGF, TREMBA reduces the number of queries by more than a half in ResNet34, DenseNet121 and MobilenetV2. Searching in the embedding space of generator remains very effective even when the target network architecture differs significantly from the networks in the source model.
+
+Table 5: Success rate and average queries of un-targeted attack on ImageNet. $\varepsilon = 0 . 0 3 1 2 5$   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">VGG19</td><td colspan="2">Resnet34</td><td colspan="2">DenseNet121</td><td colspan="2">MobilenetV2</td></tr><tr><td> Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>NES</td><td>100%</td><td>924</td><td>100%</td><td>1255</td><td>100%</td><td>1235</td><td>99.86%</td><td>872</td></tr><tr><td>Trans-NESPGD</td><td>100%</td><td>441</td><td>100%</td><td>827</td><td>100%</td><td>838</td><td>100%</td><td>733</td></tr><tr><td>Trans-NESFGSM</td><td>100%</td><td>586</td><td>100%</td><td>982</td><td>100%</td><td>961</td><td>100%</td><td>648</td></tr><tr><td>AutoZOOM</td><td>94.18%</td><td>5184</td><td>96.25%</td><td>3754</td><td>94.56%</td><td>4567</td><td>95.38%</td><td>4213</td></tr><tr><td>P-RGF</td><td>100%</td><td>277</td><td>99.72%</td><td>635</td><td>100%</td><td>709</td><td>99.72%</td><td>730</td></tr><tr><td>Trans-P-RGF</td><td>100%</td><td>130</td><td>99.86%</td><td>371</td><td>99.18%</td><td>806</td><td>99.86%</td><td>522</td></tr><tr><td>TREMBA</td><td>100%</td><td>88</td><td>100%</td><td>183</td><td>100%</td><td>172</td><td>100%</td><td>61</td></tr></table>
+
+![](images/f45f4f634355a94b1907d5d479ca61455d14143bcbb864fa2935d439fbcd6602.jpg)  
+Figure 5: The success rate of un-targeted black-box adversarial attack at different query levels for undefended ImageNet models.
+
+# A.3 VISUALIZATION OF TARGETED PERTURBATION
+
+Figure 10 shows some examples of adversarial perturbations produced by TREMBA. The first column is one image of the target class and other columns are examples of perturbations (amplified by 10 times). It is easy to discover some features of the target class in the adversarial perturbation such as the feather for birds and the body for snakes.
+
+# A.4 EXPERIMENTS ON DIFFERENT ENSEMBLES
+
+We chose two more source ensemble models for evaluation. The first ensemble contains VGG16 and Squeezenet. And the second ensemble is consist of VGG16, Squeezenet and Googlenet. Figure 6 shows our result for targeted attack for ImageNet. We only compared Trans-NESPGD and Trans-PRGF since they are the best variants from Trans-NES and P-RGF.
+
+![](images/a0aa16b99546c014863fe8cacddad3ddd0bb64dd4171e7d1507fb1ebe3f29029.jpg)  
+Figure 6: We show the success rate at different query levels for targeted attack for different ensemble source networks. V represents VGG16; S represents Squeezenet; G represents Googlenet; R represents Resnet18
+
+# A.5 VARYING $\varepsilon$
+
+We chose $\varepsilon = 0 . 0 2$ and $\varepsilon = 0 . 0 4$ and performed targeted attack on ImageNet. Although TREMBA used the same model that is trained on $\varepsilon = 0 . 0 3 1 2 5$ , it still outperformed other methods, which shows that TREMBA can also generalize to different strength of adversarial attack with different $\varepsilon$ .
+
+For the commonly used $\varepsilon = 0 . 0 5$ , TREMBA also performs well. The results are shown in Table 6, Table 7, and Figure 8.
+
+# A.6 VARYING SAMPLE SIZE
+
+We performed a hyperparameter sweep over $b$ on Densenet121 on un-targeted attack on ImageNet. $b = 2 0$ may not be the best choice Trans-NES, but it is not the best for TREMBA, either. Generally, the performance is not very sensitive to $b$ , and TREMBA will also outperform other methods even if we fine-tune the sample size for all the methods.
+
+# A.7 DIMENSION OF THE EMBEDDING SPACE
+
+We slightly changed the architecture of the autoencoder by adding max pooling layers and changing the number of filters and perform un-targeted attack on ImageNet. More specifically, we added additional max pooling layers after the first and the fourth convolution layers and changed the number of filters of the last layer in the encoder to be 8. Thus, the dimension of the embedding space would be $8 \times 8 \times 8$ . And we also changed the factor of bilinear sampling in the decoder. The remaining settings are the same in Appendix A.2. As shown in Table 9, this autoencoder is even worse than the original autoencoder despite small dimension of the embedding space. In addition, we also changed to dimension of the data-dependent prior of Trans-P-RGF to match the dimension of TREMBA, whose performance is also not better than before. They show that simply diminishing the size of the embedding space may not lead to better performance. The performance gain of TREMBA comes beyond the effect of diminishing the dimension of the embedding space.
+
+![](images/17cfbe81f4cd64c6141a4277c8d4b3cc88d04e190595c75b6298a2417586b7ee.jpg)  
+Figure 7: We show the success rate at different query levels for attack at different $\varepsilon$ for ImageNet.
+
+Table 6: Success rate and average queries of un-targeted attack on ImageNet. $\varepsilon = 0 . 0 5$   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">VGG19</td><td colspan="2">Resnet34</td><td colspan="2">DenseNet121</td><td colspan="2">MobilenetV2</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>NES</td><td>100%</td><td>651</td><td>100%</td><td>850</td><td>100%</td><td>840</td><td>99.86%</td><td>640</td></tr><tr><td>Trans-NESPGD</td><td>100%</td><td>74</td><td>100%</td><td>196</td><td>100%</td><td>235</td><td>100%</td><td>169</td></tr><tr><td>Trans-NESFGSM</td><td>100%</td><td>232</td><td>100%</td><td>401</td><td>100%</td><td>361</td><td>100%</td><td>272</td></tr><tr><td>AutoZOOM</td><td>99.72%</td><td>1743</td><td>99.58%</td><td>1481</td><td>99.32%</td><td>1730</td><td>99.29%</td><td>1672</td></tr><tr><td>P-RGF</td><td>100%</td><td>178</td><td>100%</td><td>328</td><td>100%</td><td>436</td><td>100%</td><td>402</td></tr><tr><td>Trans-P-RGF</td><td>100%</td><td>44</td><td>99.44%</td><td>418</td><td>98.09%</td><td>1049</td><td>100%</td><td>157</td></tr><tr><td>TREMBA</td><td>100%</td><td>8</td><td>100%</td><td>27</td><td>100%</td><td>19</td><td>100%</td><td>8</td></tr></table>
+
+Table 7: Success rate and average queries of targeted attack on ImageNet. $\varepsilon = 0 . 0 5$   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">VGG19</td><td colspan="2">Resnet34</td><td colspan="2">DenseNet121</td><td colspan="2">MobilenetV2</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td> Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>NES</td><td>99.03%</td><td>6364</td><td>98.89%</td><td>8003</td><td>99.32%</td><td>7525</td><td>99.72$</td><td>5610</td></tr><tr><td>Trans-NESPGD</td><td>99.31%</td><td>1968</td><td>99.31%</td><td>3549</td><td>99.46%</td><td>3731</td><td>99.86%</td><td>3223</td></tr><tr><td>Trans-NESFGSM</td><td>99.03%</td><td>4997</td><td>98.33%</td><td>7298</td><td>98.23%</td><td>6874</td><td>99.16%</td><td>5034</td></tr><tr><td>AutoZOOM</td><td>51.04%</td><td>30032</td><td>52.36%</td><td>28547</td><td>60.00%</td><td>25836</td><td>53.78%</td><td>28356</td></tr><tr><td>P-RGF</td><td>99.17%</td><td>3704</td><td>98.05%</td><td>5498</td><td>97.96%</td><td>5769</td><td>98.17%</td><td>6896</td></tr><tr><td>Trans-P-RGF</td><td>99.58%</td><td>662</td><td>99.31%</td><td>1896</td><td>99.05%</td><td>2267</td><td>99.16%</td><td>3192</td></tr><tr><td>TREMBA</td><td>99.72%</td><td>285</td><td>99.44%</td><td>443</td><td>99.72%</td><td>224</td><td>99.72%</td><td>422</td></tr></table>
+
+# A.8 EXAMPLES OF ATTACKING GOOGLE CLOUD VISION API
+
+Figure 11 shows one example of attacking Google Cloud Vision API. TREMBA successfully make the shark to be classified as green. Compared with Trans- ${ \bf \cdot N E S _ { P G D } }$ , TREMBA hugely changes the
+
+![](images/66473406521a67388c57f8479e1b6594b24878ea18c9bbafbb649b4e02d7f015.jpg)  
+Figure 8: We show the success rate at different query levels for targeted and un-targeted attack at $\varepsilon = 0 . 0 5$ for ImageNet.
+
+Table 8: Hyperparameter sweep over $b$ on Densenet121 for un-targeted attack on ImageNet   
+
+<table><tr><td rowspan="2">Sweep over b</td><td colspan="2">b=10</td><td colspan="2">b=30</td><td colspan="2">b=40</td><td colspan="2">b= 50</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>NES</td><td>100%</td><td>1323</td><td>100%</td><td>1284</td><td>100%</td><td>1433</td><td>100%</td><td>1639</td></tr><tr><td>Trans-NESPGD</td><td>100%</td><td>915</td><td>100%</td><td>791</td><td>100%</td><td>707</td><td>100%</td><td>639</td></tr><tr><td>Trans-NESFGSM</td><td>100%</td><td>1037</td><td>100%</td><td>916</td><td>100%</td><td>879</td><td>100%</td><td>886</td></tr><tr><td>AutoZOOM</td><td>90.9%</td><td>6052</td><td>96.2%</td><td>4148</td><td>97.1%</td><td>4066</td><td>97.3%</td><td>4366</td></tr><tr><td>P-RGF</td><td>99.73%</td><td>717</td><td>99.86%</td><td>860</td><td>99.86%</td><td>949</td><td>99.86%</td><td>1095</td></tr><tr><td>Trans-P-RGF</td><td>98.50%</td><td>1139</td><td>99.86%</td><td>479</td><td>99.86%</td><td>487</td><td>100%</td><td>427</td></tr><tr><td>TREMBA</td><td>100%</td><td>150</td><td>100%</td><td>205</td><td>100%</td><td>274</td><td>100%</td><td>299</td></tr></table>
+
+Table 9: Change of dimension of the embedding space of AutoZOOM. The task is un-targeted attack on ImageNet.   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">VGG19</td><td colspan="2">Resnet34</td><td colspan="2">DenseNet121</td><td colspan="2">MobilenetV2</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>AutoZ0OM</td><td>64.35%</td><td>19684</td><td>71.94%</td><td>16931</td><td>68.44%</td><td>17871</td><td>71.15%</td><td>16134</td></tr><tr><td>Trans-P-RGF</td><td>99.86%</td><td>194</td><td>99.58%</td><td>508</td><td>99.59%</td><td>610</td><td>99.58%</td><td>705</td></tr></table>
+
+labels of the image. It is hard to say the overall classification of Trans- $\mathbf { \cdot N E S _ { P G D } }$ is wrong. However, the labels of TREMBA are definitely not correct.
+
+![](images/3f2f8df2f6a73b87639c5c3c58772f2f61fb3f141de9473cf7895fee3543fb43.jpg)  
+Figure 9: The success rate at different query levels for attack targeted at different class. Targeted classes are: (a)Dipper; (b)American chameleon; (c)Night snake; (d)Ruffed grouse; (e)Black swan
+
+![](images/cb446ab0a9f6ed206ea6d2284aa3175e01a28c6c4c504837f1e1a89473ab112c.jpg)  
+Figure 10: Visualization of adversarial perturbations for targeted attack on ImageNet. The first column shows one example of the target class. Other columns show the adversarial perturbations.
+
+![](images/793e2caa32be1917242f6ff648d498241539ddaf408bcfabccfe8ce57ea0feb6.jpg)  
+Figure 11: One example of adversarial image for attacking Google Cloud Vision API
+
+Table 10: Comparision between CombOpt and TREMBA for un-targeted attack on Imagenet.   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">VGG19</td><td colspan="2">Resnet34</td><td colspan="2">DenseNet121</td><td colspan="2">MobilenetV2</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>CombOpt</td><td>100%</td><td>567</td><td>100%</td><td>499</td><td>100%</td><td>569</td><td>100%</td><td>522</td></tr><tr><td>TREMBA</td><td>100%</td><td>88</td><td>100%</td><td>183</td><td>100%</td><td>172</td><td>100%</td><td>61</td></tr></table>
+
+Table 11: Comparision between CombOpt and TREMBA for targeted attack on Imagenet.   
+
+<table><tr><td rowspan="2">Attack</td><td colspan="2">VGG19</td><td colspan="2">Resnet34</td><td colspan="2">DenseNet121</td><td colspan="2">MobilenetV2</td></tr><tr><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td><td>Success</td><td>Queries</td></tr><tr><td>CombOpt</td><td>93.76%</td><td>9767</td><td>94.86%</td><td>8024</td><td>97.41%</td><td>6970</td><td>96.92%</td><td>8575</td></tr><tr><td>TREMBA</td><td>98.47%</td><td>853</td><td>96.38%</td><td>1206</td><td>98.50%</td><td>1124</td><td>99.16%</td><td>1210</td></tr></table>
+
+# A.9 COMPARISION BETWEEN TREMBA AND COMBOPT
+
+CombOpt is one of the SOTA score-based black-box attack. We compared our method with it on the targeted and un-targeted attack on Imagenet. The targeted attack is 0 and $\varepsilon = 0 . 0 3 1 2 5$ . As shown in Table 10 and Table 11, TREMBA requires much lower queries than CombOpt. It demonstrates the great improvement by combining the transfer-based and score-based attack.
+
+# B ARCHITECTURE OF CLASSIFIERS AND GENERATORS
+
+# B.1 CLASSIFIER
+
+Table 12: Model architectures for the MNIST   
+
+<table><tr><td>ConvNet1</td><td>ConvNet2</td><td>FCNet</td></tr><tr><td>Conv(64, 5, 5)+ReLU MaxPool(2,2)</td><td>Conv(16,3,3)+ReLU Conv(16,3,3)+ReLU</td><td>FC(512)+ReLU FC(10)+Softmax</td></tr><tr><td>Conv(64,5,5)+ReLU</td><td>MaxPool(2,2)</td><td></td></tr><tr><td>MaxPool(2,2)</td><td>Conv(32,3,3)+ReLU</td><td></td></tr><tr><td>Dropout(0.25)</td><td>Conv(32,3, 3)+ReLU</td><td></td></tr><tr><td>FC(128)+ReLU</td><td>Conv(32,3,3)+ReLU</td><td></td></tr><tr><td>Dropout(0.5)</td><td>MaxPool(2,2)</td><td></td></tr><tr><td>FC(10)+Softmax</td><td>FC(512)+ReLU</td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td>FC(10)+Softmax</td><td></td></tr></table>
+
+Table 12 lists the architectures of ConvNet1, ConvNet2 and FCNet. The architecture of ResNeXt used in CIFAR10 is from https://github.com/prlz77/ResNeXt.pytorch. We set the depth to be 20, the cardinality to be 8 and the widen factor to be 4. Other architectures of classifiers are specified in the corresponding paper.
+
+# B.2 GENERATOR
+
+Table 13 lists the architectures of generator for three datasets. For AutoZOOM, we find our architectures are not suitable and use the same generators in the corresponding paper.
+
+# C HYPERPARAMETERS
+
+# C.1 TRAINING GENERATOR
+
+We trained the generators with learning rate starting at 0.01 and decaying half every 50 epochs. The whole training process was 500 epochs. The batch size was determined by the memory of GPU. Specifically, we set batch size to be 256 for MNIST and CIFAR10 defense model, 64 for ImageNet model. All large $\kappa$ will work well for our method and we chose $\kappa = 2 0 0 . 0$ . All the experiments were performed using pytorch on NVIDIA RTX 2080Ti.
+
+Table 13: Architectures of encoder and decoder. ConvReLUBN and DeconvReLUBN represent convolution or deconvolution followed by ReLU and batch normalization. The parameters $( c , m , n )$ used in ConvReLUBN or DeconvReLUBN mean $c$ channels with $m \times n$ kernel size. $\mathbf { M a x P o o l } ( m , n )$ represents max pooling with $( m , n )$ kernel size and $( m , n )$ stride.   
+
+<table><tr><td></td><td>MNIST ConvReLUBN(16,3,3)</td><td>CIFAR10 ConvReLUBN(16,3,3)</td><td>ImageNet ConvReLUBN(16,3,3)</td></tr><tr><td>Encoder</td><td>ConvReLUBN(32,3,3) ConvReLUBN(32,3,3) MaxPool(2,2) ConvReLUBN(32,3,3) ConvReLUBN(16,3,3) ConvReLUBN(2,3,3) MaxPool(2,2)</td><td>ConvReLUBN(32,3,3) ConvReLUBN(32,3,3) MaxPool(2,2) ConvReLUBN(32,3,3) ConvReLUBN(32,3,3) ConvReLUBN(8,3,3) MaxPool(2,2)</td><td>ConvReLUBN(32,3,3) MaxPool(2,2) ConvReLUBN(64,3,3) ConvReLUBN(64,3,3) MaxPool(2,2) ConvReLUBN(128,3,3) ConvReLUBN(128,3,3) MaxPool(2,2) ConvReLUBN(32,3,3)</td></tr><tr><td>Decoder</td><td>ConvReLUBN(32,3,3) ConvReLUBN(32,3,3) DeconvReLUBN(64,3,3) ConvReLUBN(64,3,3) ConvReLUBN(64,3,3) DeconvReLUBN(16,3,3) Conv(1,1,1)</td><td>ConvReLUBN(32,3,3) ConvReLUBN(32,3,3) DeconvReLUBN(64,3,3) ConvReLUBN(64,3,3) ConvReLUBN(64,3,3) DeconvReLUBN(16,3,3) Conv(3,1,1)</td><td>ConvReLUBN(8,3,3) MaxPool(2,2) ConvReLUBN(32,3,3) DeconvReLUBN(64,3,3) ConvReLUBN(128,3,3) DeconvReLUBN(128,3,3) ConvReLUBN(128,3,3) DeconvReLUBN(64,3,3) ConvReLUBN(32,3,3) DeconvReLUBN(16,3,3) ConvReLUBN(3,1,1)</td></tr></table>
+
+# C.2 EVALUATION
+
+Table 14 to 19 list the hyperparameters for all the algorithms. The learning rate was fine-tuned for all the algorithms. We set sample size $b = 2 0$ for all the algorithms for fair comparisons.
+
+Table 14: Hyperparameters for NES   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">MNIST</td><td rowspan="2">CIFAR10</td><td colspan="3">ImageNet</td></tr><tr><td>Un-targeted</td><td>Targeted</td><td>Un-targeted Defense</td></tr><tr><td>Sample size (b)</td><td>20</td><td>20</td><td>20</td><td>20</td><td>20</td></tr><tr><td>Learning rate (n)</td><td>0.2</td><td>0.05</td><td>0.1</td><td>0.05</td><td>0.1</td></tr></table>
+
+Table 15: Hyperparameters for Trans- ${ \cdot } \mathrm { N E S } _ { \mathrm { P G D } }$ and Trans-NESFGSM. White-box iteration, white-box margin and white-box learning rate mean the hyperparameters for generating the starting point on the source network for Trans-NESPGD.   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">MNIST</td><td rowspan="2">CIFAR10</td><td colspan="3">ImageNet</td></tr><tr><td>Un-targeted</td><td>Targeted</td><td>Un-targeted Defense</td></tr><tr><td>Sample size (b)</td><td>20</td><td>20</td><td>20</td><td>20</td><td>20</td></tr><tr><td>Learning rate (n)</td><td>0.2</td><td>0.05</td><td>0.1</td><td>0.05</td><td>0.1</td></tr><tr><td>White-box iteration</td><td>50</td><td>100</td><td>50</td><td>50</td><td>100</td></tr><tr><td>White-box margin(κ)</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td></tr><tr><td>White-box learning rate</td><td>0.05</td><td>0.1</td><td>0.01</td><td>0.005</td><td>0.1</td></tr></table>
+
+Table 16: Hyperparameters for AutoZOOM.   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">MNIST</td><td rowspan="2">CIFAR10</td><td colspan="3">ImageNet</td></tr><tr><td>Un-targeted</td><td>Targeted</td><td>Un-targeted Defense</td></tr><tr><td>Sample size (b)</td><td>20</td><td>20</td><td>20</td><td>20</td><td>20</td></tr><tr><td>Learning rate (n)</td><td>5.0</td><td>20.0</td><td>5.0</td><td>3.0</td><td>5.0</td></tr></table>
+
+Table 17: Hyperparameters for P-RGF and Trans-P-RGF.   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">MNIST</td><td rowspan="2">CIFAR10</td><td colspan="3">ImageNet</td></tr><tr><td>Un-targeted</td><td>Targeted</td><td>Un-targeted Defense</td></tr><tr><td>Sample size (b)</td><td>20</td><td>20</td><td>20</td><td>20</td><td>20</td></tr><tr><td>Learning rate (n)</td><td>0.1</td><td>0.05</td><td>0.005</td><td>0.003</td><td>0.005</td></tr><tr><td>White-box iteration</td><td>50</td><td>100</td><td>50</td><td>50</td><td>100</td></tr><tr><td>White-box margin(κ)</td><td>100</td><td>100</td><td>100</td><td>100</td><td>100</td></tr><tr><td>White-box learning rate</td><td>0.05</td><td>0.1</td><td>0.01</td><td>0.01</td><td>0.1</td></tr></table>
+
+Table 18: Hyperparameters for TREMBA.   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">MNIST</td><td rowspan="2">CIFAR10</td><td colspan="3">ImageNet</td></tr><tr><td>Un-targeted</td><td>Targeted</td><td>Un-targeted Defense</td></tr><tr><td>Sample size (b)</td><td>20</td><td>20</td><td>20</td><td>20</td><td>20</td></tr><tr><td>Learning rate (n)</td><td>0.3</td><td>2.0</td><td>5.0</td><td>3.0</td><td>5.0</td></tr></table>
+
+Table 19: Hyperparameters for TREMBAOSP .   
+
+<table><tr><td></td><td>CIFAR10 Defense</td><td>ImageNet Defense</td></tr><tr><td>Sample size (b)</td><td>20</td><td>20</td></tr><tr><td>Learning rate (n)</td><td>2.0</td><td>5.0</td></tr><tr><td>White-box iteration</td><td>100</td><td>100</td></tr><tr><td>White-box margin(κ)</td><td>100</td><td>100</td></tr><tr><td>White-box learning rate</td><td>1.0</td><td>2.0</td></tr></table>

md/train/YSzTMntO1KY/YSzTMntO1KY.md

@@ -0,0 +1,232 @@
+# SIMONe: View-Invariant, Temporally-Abstracted Object Representations via Unsupervised Video Decomposition
+
+Rishabh Kabra1, Daniel Zoran1, Goker Erdogan1, Loic Matthey1 Antonia Creswell1, Matthew Botvinick1, Alexander Lerchner1, Christopher P. Burgess2∗
+
+1DeepMind, 2Wayve, ∗Work done at DeepMind {rkabra, danielzoran, gokererdogan, lmatthey, tonicreswell, botvinick, lerchner}@deepmind.com, chrisburgess@wayve.ai
+
+# Abstract
+
+To help agents reason about scenes in terms of their building blocks, we wish to extract the compositional structure of any given scene (in particular, the configuration and characteristics of objects comprising the scene). This problem is especially difficult when scene structure needs to be inferred while also estimating the agent’s location/viewpoint, as the two variables jointly give rise to the agent’s observations. We present an unsupervised variational approach to this problem. Leveraging the shared structure that exists across different scenes, our model learns to infer two sets of latent representations from RGB video input: a set of "object" latents, corresponding to the time-invariant, object-level contents of the scene, as well as a set of "frame" latents, corresponding to global time-varying elements such as viewpoint. This factorization of latents allows our model, SIMONe, to represent object attributes in an allocentric manner which does not depend on viewpoint. Moreover, it allows us to disentangle object dynamics and summarize their trajectories as time-abstracted, view-invariant, per-object properties. We demonstrate these capabilities, as well as the model’s performance in terms of view synthesis and instance segmentation, across three procedurally generated video datasets.
+
+# 1 Introduction
+
+The problem of unsupervised visual scene understanding has become an increasingly central topic in machine learning [1, 2]. The attention is merited by potential gains to reasoning, autonomous navigation, and myriad tasks. However, within the current literature, different studies frame the problem in different ways. One approach aims to decompose images into component objects and object features, supporting (among other things) generation of alternative data that permits insertion, deletion, or repositioning of individual objects [3–6]. Another approach aims at a very different form of decomposition—between allocentric scene structure and a variable viewpoint—supporting generation of views of a scene from new vantage points [7–9] and, if not supplied as input, estimation of camera pose [10]. Although there is work pursuing both of these approaches concurrently in the supervised setting [11–13], very few previous studies have approached the combined challenge in the unsupervised case. In this work, we introduce the Sequence-Integrating Multi-Object Net (SIMONe), a model which pursues that goal of object-level and viewpoint-level scene decomposition and synthesis without supervision. SIMONe is designed to handle these challenges without privileged information concerning camera pose, and in dynamic scenes.
+
+Given a video of a scene our model is able to decouple scene structure from viewpoint information (see Figure 1). To do so, it utilizes video-based cues, and a structured latent space which separates time-invariant per-object features from time-varying global features. These features are inferred using a transformer-based network which integrates information jointly across space and time.
+
+![](images/474ef165df2ffbd0478d6a7e3fa573cff337922fa05bcf1f109a4235f98414d0.jpg)  
+Figure 1: Decomposition (A): SIMONe factorizes a scene sequence $\mathbf { X }$ into scene content (“object latents,” constant across the sequence) and view/global content (“frame latents,” one per frame) without supervision. Its spatio-temporal attention-based inference naturally allows stable object tracking (e.g. the green sphere is assigned the same segment across frames). Recomposition (B): Object latents of a given sequence X can be recomposed with the frame latents of a different (i.i.d.) sequence $\mathbf { X } ^ { \prime }$ to generate a consistent rendering of the same scene (i.e. objects and their properties, relative arrangements, and segmentation assignments) from entirely different viewpoints. Notice that both camera pose and lighting are transferred, as evidenced by the wall corners in the background and the shadows of the green sphere.
+
+Second, our method seeks to summarize objects’ dynamics. It learns to disentangle not only static object attributes (and their 2D spatial masks), but also object trajectories, without any prior notion of these objects, from videos alone. The learnt trajectory features are temporally abstract and per object; they are captured independently of the dynamics of camera pose, which being a global property, is captured in the model’s per-frame (time-varying) latents.1
+
+Our model thus advances the state of the art in unsupervised, object-centric scene understanding by satisfying the following desiderata: (1) decomposition of multi-object scenes from RGB videos alone; (2) handling of changing camera pose, and simultaneous inference of scene contents and viewpoint from correlated views (i.e. sequential observations of a moving agent); (3) learning of structure across diverse scene instances (i.e. procedurally sampled contents); (4) object representations which summarize static object attributes like color or shape, view-dissociated properties like position or size, as well as time-abstracted trajectory features like direction of motion; (5) no explicit assumptions of 3D geometry, no explicit dynamics model, no specialized renderer, and few a priori modeling assumptions about the objects being studied; and (6) simple, scalable modules (for inference and rendering) to enable large-scale use.
+
+# 2 Related Work
+
+Given the multifaceted problem it tackles, SIMONe connects across several areas of prior work. We describe its nearest neighbors from three scene understanding domains below:
+
+Scene decomposition models. (1) Our work builds on a recent surge of interest in unsupervised scene decomposition and understanding, especially using slot structure to capture the objects in a scene [14]. One line of work closely related to SIMONe includes methods like [3–6, 15], which all share SIMONe’s Gaussian mixture pixel likelihood model. While these prior methods handled only static scenes, more recent work [16–18, 12] has extended them to videos with promising results. Nevertheless, these approaches have no mechanism or inductive bias to separate view information from scene contents. Moreover, many of them are conditioned on extra inputs like the actions of an agent/camera to simplify inference. (2) Another family of decomposition models originated with Attend, Infer, Repeat (AIR) [19]. AIR’s recurrent attention mechanism does split images into components with separate appearance and pose latents each. Later work [6, 20–23] also extended the model to videos. Despite their structured latents, these models do not learn to distill object appearance into a time-invariant representation (as their appearance and pose latents are free to vary as a function of time). They also require separate object discovery and propagation modules to handle appearing/disappearing objects. In contrast, SIMONe processes a full sequence of images using spatio-temporal attention and produces a single time-invariant latent for each object, hence requiring no explicit transition model or discovery/propagation modules.
+
+Multi-view scene rendering models. Models which assume viewpoint information for each image like GQN [7], SRNs [8], and NeRF [9] have shown impressive success at learning implicit scene representations and generating novel views from different viewpoints. Recent work [24–27] has further extended these models to videos using deformation fields to model changes in scene geometry over time. In contrast to SIMONe, these models can achieve photorealistic reconstructions by assuming camera parameters (viewpoint information). To allow a direct comparison, we use a view-supervised version of SIMONe in Section 4.1. There is also recent work [28, 29] that relaxes the known viewpoint constraint, but they still model single scenes at a time, which prevents them from exploiting regularities over multiple scenes. A more recent line of work [30–32] explored amortizing inference by mapping from a given set of images to scene latents, but they cannot handle videos yet. Note that all of these models treat the whole scene as a single entity and avoid decomposing it into objects. One exception here is [33], which represents objects with separate pose and appearance latents. However, this model is purely generative and cannot infer object latents from a given scene. Another exception is [13], which can in fact infer object representations, but nevertheless depends on view supervision.
+
+Simultaneous localization and mapping. The problem of inferring scene representations in a novel environment by exploring it (rather than assuming given views and viewpoint information) is well studied in robotics and vision [10]. Classic SLAM techniques often rely on EM [34, 35] or particle filters [36] to infer viewpoint and scene contents jointly. While our problem is slightly simpler (we can leverage shared structure across scene instances; certain elements such as the shape of the room are held constant; and we use offline data rather than active exploration), our approach of using a factorized variational posterior provides a learning-based solution to the same computational problem. Our simplified setting is perhaps justified by our unsupervised take on the problem. On the other hand, we don’t assume simplifications which may be common in robotics practice (e.g. known camera properties like field of view; or the use of multiple cameras or depth sensors). Most popular SLAM benchmarks [37–39] are on unstructured 3D scenes and hence it was not straightforward for us to compare directly to classic methods. But an encouraging point of overlap is that object-centric SLAM formulations [11] as well as learning-based solutions [40, 41] are active topics of research. Our work could open new avenues in object-centric scene mapping without supervision.
+
+# 3 Model
+
+SIMONe is a variational auto-encoder [42] consisting of an inference network (encoder) which infers latent variables from a given input sequence, and a generative process (decoder) which decodes these latents back into pixels. Using the Evidence Lower Bound (ELBO), the model is trained to minimize a pixel reconstruction loss and latent compression KL loss. Crucially, SIMONe relies on a factorized latent space which enforces a separation of static object attributes from global, dynamic properties such as camera pose. We introduce our latent factorization and generative process in Section 3.1. Then in Section 3.2, we describe how the latents can be inferred using a transformer-based encoder, significantly simplifying the (recurrent or autoregressive) architectures used in prior work. Finally, we fully specify the training scheme in Section 3.3.
+
+![](images/ce156cadcf2724beb8d18887fd8697c8c846570c23660240b4d9540c10f68d0b.jpg)  
+Figure 2: Architecture of the SIMONe inference network $\mathcal { E } _ { \phi }$ . The transformers integrate information jointly across space and time to infer (the posterior parameters of) the object and frame latents.
+
+# 3.1 Latent Structure and Generative Process
+
+Our model aims to capture the structure of a scene, observed as a sequence of images from multiple viewpoints (often along a smooth camera trajectory, though this is not a requirement). Like many recently proposed object-centric models we choose to represent the scene as a set of $K$ object latent variables $\mathbf { O } ^ { \mathsf { ^ { \prime } } } : = \{ \mathbf { o } _ { k } \} _ { k = 1 } ^ { K }$ . These are invariant by construction across all frames in the sequence (i.e. their distribution is constant through time, and expected to summarize information across the whole sequence). We also introduce $T$ frame latents $\mathbf { F } : = \{ \mathbf { f } _ { t } \} _ { t = 1 } ^ { T }$ , one for each frame in the sequence, that capture time-varying information. Note that by choosing this factorization we reduce the number of required latent variables from $K \cdot T$ to $K + T$ . The latent prior $\begin{array} { r } { p ( \mathbf { O } , \mathbf { F } ) = \prod _ { k } \mathcal { N } ( \mathbf { o } _ { k } \mid \mathbf { \Lambda } } \end{array}$ $\mathbf { 0 } , \mathbf { I } ) \prod _ { t } \mathcal { N } ( \mathbf { f } _ { t } \mid \bar { \mathbf { 0 } } , \mathbf { I } )$ is a unit spherical Gaussian, assuming and enforcing independence between object latents, frame latents, and their feature dimensions.
+
+Given the latent variables, we assume all pixels and all frames to be independent. Each pixel is modeled as a Gaussian mixture with $K$ components. The mixture weights for pixel $\mathbf { x } _ { t , i }$ capture which component $k$ “explains” that pixel $( 1 \leq i \leq H W$ ). The mixture logits $\hat { m } _ { k , t , i }$ and RGB (reconstruction) means $\mu _ { k , t , i }$ are computed for every component $k$ at a specific time-step $t$ and specific pixel location $\mathbf { l } _ { i }$ using a decoder $\mathcal { D } _ { \theta }$ :
+
+$$
+\begin{array} { c } { \hat { m } _ { k , t , i } , \pmb { \mu } _ { k , t , i } = \mathcal { D } _ { \theta } ( \mathbf { o } _ { k } , \mathbf { f } _ { t } ; \mathrm { \mathbf { l } } _ { i } , t ) } \\ { p ( \mathbf { x } _ { t , i } \mid \mathbf { o } _ { 1 } , . . . , \mathbf { o } _ { K } , \mathbf { f } _ { t } ; t , \mathrm { \mathbf { l } } _ { i } ) = \displaystyle \sum _ { k } m _ { k , t , i } \mathcal { N } ( \mathbf { x } _ { t , i } \mid \pmb { \mu } _ { k , t , i } ; \sigma _ { x } ) } \end{array}
+$$
+
+We decode each pixel independently, "querying" our pixel-wise decoder using the sampled latents, coordinates $\mathbf l _ { i } \in [ - 1 , 1 ] ^ { 2 }$ of the pixel, and time-step $t \in [ 0 , 1 )$ being decoded as inputs. The decoder’s architecture is an MLP or 1x1 CNN. (See Appendix A.3.1 for the exact parameterization as well as a diagram of the generative process). By constraining the decoder to work on individual pixels, we can use a subset of pixels as training targets (as opposed to full images; this is elaborated in Section 3.3). Once they are decoded, we obtain the mixture weights $m _ { k , t , i }$ by taking the softmax of the logits across the $K$ components: $m _ { k , t , i } = \tt s o f t m a x _ { k } ( \hat { m } _ { k , t , i } )$ . Equation 2 specifies the full pixel likelihood, where $\sigma _ { x }$ is a scalar hyperparameter.
+
+# 3.2 Inference
+
+Given a sequence of frames $\mathbf { X } : = \{ \mathbf { x } _ { t } \} _ { t = 1 } ^ { T }$ we now wish to infer the corresponding object latents $\mathbf { O }$ and frame latents $\mathbf { F }$ . The exact posterior distribution $p ( \mathbf { O } , \mathbf { F } \mid \mathbf { X } )$ is intractable so we resort to using a Gaussian approximate posterior $q ( \mathbf { O } , \mathbf { F } \mid \mathbf { X } )$ . The approximate posterior is parameterized as the output of an inference (encoder) network $\mathcal { E } _ { \phi } ( \mathbf { X } )$ which outputs the mean and (diagonal) log scale for all latent variables given the input sequence.
+
+SIMONe’s inference network is based on the principle that spatio-temporal data can be processed jointly across space and time using transformers. Beyond an initial step, we don’t need the translation invariance of a CNN, which forces spatial features to interact gradually via a widening receptive field. Nor do we need the temporal invariance of an RNN which forces sequential processing. Instead, we let feature maps interact simultaneously across the cross-product of space and time. See Figure 2 for an overview of our encoder architecture implementing this.
+
+Concretely, each frame $\mathbf { x } _ { t }$ in the sequence is passed through a CNN which outputs $I J$ spatial feature maps at each time-step (containing $C$ channels each). $I J$ can be larger than the number of object latents $K$ . (For all results in the paper, we set $I$ and $J$ to 8 each, and $K = 1 6$ .) The rest of the inference network consists of two transformers $\mathcal { T } _ { 1 }$ and $\mathcal { T } _ { 2 }$ . $\mathcal { T } _ { 1 }$ takes in all $T I J$ feature maps. Each feature map attends to all others as described. $\mathcal { T } _ { 1 }$ outputs $T I J$ transformed feature maps. When $I J > K$ , we apply a spatial pool to reduce the number of slots to $T K$ (see Appendix A.3.2 for details). These slots serve as the input to $\mathcal { T } _ { 2 }$ , which produces an equal number of output slots. Both transformers use absolute (rather than relative) positional embeddings, but these are 3D to denote the spatio-temporal position of each slot. We denote the output of $\mathcal { T } _ { 2 }$ as $\hat { \mathbf { e } } _ { k , t }$ . This intermediate output is aggregated along separate axes (and passed through MLPs) to obtain $T$ frame and $K$ object posterior parameters respectively. Specifically, $\lambda _ { \mathbf { o } _ { k } } = \mathrm { m l p } _ { o } ( 1 / T \sum _ { t } \hat { \mathbf { e } } _ { k , t } )$ while $\lambda _ { \mathbf { f } _ { t } } = \mathrm { m l p } _ { f } ( 1 / K \sum _ { k } \hat { \mathbf { e } } _ { k , t } )$ Using these posterior parameters we can sample the object latents $\mathbf { o } _ { k } \sim \mathcal { N } ( \lambda _ { \mathbf { o } _ { k } } ^ { \mu } , \mathrm { e x p } ( \lambda _ { \mathbf { o } _ { k } } ^ { \sigma } ) \mathbb { 1 } )$ , and the frame latents $\mathbf { f } _ { t } \sim \mathcal { N } ( \lambda _ { \mathbf { f } _ { t } } ^ { \mu } , \exp ( \lambda _ { \mathbf { f } _ { t } } ^ { \sigma } ) \mathbb { 1 } )$ .
+
+# 3.3 Loss and Training
+
+The model is trained end to end by minimizing the following negative-ELBO derivative:
+
+$$
+\begin{array} { l } { \displaystyle \frac { - \alpha } { T _ { d } H _ { d } W _ { d } } \sum _ { t = 1 } ^ { T _ { d } } \sum _ { i = 1 } ^ { H _ { d } W _ { d } } \log p ( \mathbf { x } _ { t , i } \mid \mathbf { o } _ { 1 } , . . . , \mathbf { o } _ { K } , \mathbf { f } _ { t } ; t , \mathbf { l } _ { i } ) + \displaystyle \frac { \beta _ { o } } { K } \sum _ { k } D _ { K L } ( q ( \mathbf { o } _ { k } \mid \mathbf { X } ) \parallel p ( \mathbf { o } _ { k } ) ) } \\ { + \displaystyle \frac { \beta _ { f } } { T } \sum _ { t } D _ { K L } ( q ( \mathbf { f } _ { t } \mid \mathbf { X } ) \parallel p ( \mathbf { f } _ { t } ) ) } \end{array}
+$$
+
+We normalize the data log-likelihood by the number of decoded pixels $\left( T _ { d } H _ { d } W _ { d } \right)$ to allow for decoding fewer than all input pixels $( T H W )$ . This helps scale the size of the decoder (without reducing the learning signal, due to the correlations prevalent between adjacent pixels). Normalizing by $1 / \bar { T _ { d } } \bar { H _ { d } } \bar { W _ { d } }$ ensures consistent learning dynamics regardless of the choice of how many pixels are decoded. $\alpha$ is generally set to 1, but available to tweak in case the scale of $\beta _ { o }$ and $\beta _ { f }$ is too small to be numerically stable. Unless explicitly mentioned, we set $\beta _ { o } = \beta _ { f }$ . See Appendix A.3 for details.
+
+# 4 Comparative Evaluation
+
+To evaluate the model we focus on two tasks: novel view synthesis and video instance segmentation. On the first task (Section 4.1), we highlight the benefit of view information when it is provided as ground truth to a simplified version of our model (denoted “SIMONe-VS” for view supervised), as well as baseline models like GQN [7] and NeRF-VAE [43]. On the second task (Section 4.2), we deploy the fully unsupervised version of our model; we showcase not only the possibility of inferring viewpoint from data, but also its benefit to extracting object-level structure in comparison to methods like MONet [3], Slot Attention [15], and Sequential IODINE [4].
+
+Our results are based on three procedurally generated video datasets of multi-object scenes. In increasing order of difficulty, they are: Objects Room 9 [44], CATER (moving camera) [45], and Playroom [46]. These were chosen to meet a number of criteria: we wanted at least 9-10 objects per scene (there can be fewer in view, or as many as 30 in the case of Playroom). We wanted a moving camera with a randomized initial position (the only exception is CATER, where the camera moves rapidly but is initialized at a fixed position to help localization). We wanted ground-truth object masks to evaluate our results quantitatively. We also wanted richness in terms of lighting, texture, object attributes, and other procedurally sampled elements. Finally, we wanted independently moving objects in one dataset (to evaluate trajectory disentangling and temporal abstraction), and unpredictable camera trajectories in another (the Playroom dataset is sampled using an arbitrary agent policy, so the agent is not always moving). Details on all datasets are in Appendix A.2.
+
+# 4.1 View synthesis (with viewpoint supervision)
+
+We first motivate view-invariant object representations by considering the case when ground-truth camera pose is provided to our model (a simplified variant we call “SIMONe-VS”). In this scenario, we don’t infer any frame latents. Rather, the encoder and decoder are conditioned on the viewpoint directly. This view-supervised setting is similar to models like GQN and NeRF which represent the contents of a scene implicitly and can be queried in different directions.
+
+![](images/04b14bb591866ade30a797d55eb4e50d260a7425b92b27c5488464ef25af4457.jpg)  
+Figure 3: Comparison of scene representation and view synthesis capabilities between SIMONeVS, NeRF-VAE, and GQN. All models partially observe a procedurally generated Playroom from a given sequence of frames (we visualize 4 of the 16 input frames fed to the models). Then, we decode novel views on a circular trajectory around the room, with the yaw linearly spaced in $[ - \pi , \pi ]$ . NeRF-VAE retains very little object structure, while GQN hallucinates content. SIMONe-VS can produce fine reconstructions of objects that it observes even partially or at a distance (such as the bed or shelves in the scene). SIMONe-VS also segments the scene as a bonus. See Appendix A.5.1 for similar plots from different scenes/input sequences.
+
+We compare three such models on view synthesis in the Playroom. The models are provided a set of 16 consecutive frames as context, partially revealing a generated room. Having inferred a scene representation from the input context, the models are then tasked with generating unobserved views of the scene. This extrapolation task is performed without any retraining, and tests the coherence of the models’ inferred representations. The task is challenging given the compositional structure of each Playroom scene, as well as the variation across scenes (the color, position, size, and choice of all objects are procedurally sampled per scene; only the L-shaped layout of the room is shared across scenes in the dataset). Because each model is trained on and learns to represent many Playroom instances, NeRF itself is not directly suitable for the task. It needs to be retrained on each scene, whereas we want to infer the specifics of any given room at evaluation time. NeRF-VAE addresses this issue and makes it directly comparable to our model.
+
+To set up the comparison, we first trained SIMONe-VS and evaluated its log-likelihood on Playroom sequences. Then, we trained GQN and NeRF-VAE using constrained optimization (GECO [47]) to achieve roughly the same log likelihood per pixel. See Appendix A.5.1 for a comparison of the models in terms of the reconstruction-compression trade-off.
+
+Qualitatively, the models show vast differences in their perceived structure (see Figure 3). NeRF-VAE blurs out nearly all objects in the scene but understands the geometry of the room and is able to infer wall color. GQN produces more detailed reconstructions, but overfits to particular views and does not interpolate smoothly. SIMONe-VS on the other hand finely reproduces the object structure of the room. Even when it observes objects at a distance or up close, it places and sizes them correctly in totally novel views. This makes SIMONe-VS a powerful choice over NeRF-VAE and GQN-style models when the priority is to capture scene structure across diverse examples.
+
+# 4.2 Instance segmentation (fully unsupervised)
+
+Having shown the benefit of view information to inferring scene structure in the Section 4.1, we now turn to the added challenge of inferring viewpoint directly and simultaneously with scene contents (without any supervision).
+
+<table><tr><td></td><td colspan="3">Static ARI-F</td><td colspan="4">Video ARI-F</td></tr><tr><td></td><td>MONet</td><td>SA</td><td>S-IODINE</td><td>MONet</td><td>SA</td><td>S-IODINE</td><td>SIMONe</td></tr><tr><td>Objects Room 9</td><td>0.886 (±0.061)</td><td>0.784 (±0.138)</td><td>0.695 (±0.007)</td><td>0.865 (±0.007)</td><td>0.066 (±0.014)</td><td>0.673 (±0.0.002)</td><td>0.936</td></tr><tr><td>CATER</td><td>0.937</td><td>0.923</td><td>0.728</td><td>0.412</td><td>0.073</td><td>0.668</td><td>(±0.010) 0.918</td></tr><tr><td>Playroom</td><td>(±0.004) 0.647 (±0.012)</td><td>(±0.076) 0.653 (±0.024)</td><td>(±0.032) 0.439 (±0.009)</td><td>(±0.012) 0.442 (±0.010)</td><td>(±0.006) 0.059 (±0.002)</td><td>(±0.033) 0.356 (±0.006)</td><td>(±0.036) 0.800 (±0.043)</td></tr></table>
+
+Table 1: SIMONe segmentation performance (in terms of Adjusted Rand Index for foreground objects, ARI-F) compared to state-of-the-art unsupervised baselines: two static-frame models (MONet and Slot Attention, SA) and a video model (S-IODINE). We calculate static and video ARI-F scores separately. For static ARI-F, we evaluate the models per still image. For video ARI-F, we evaluate the models across space and time, taking an object’s full trajectory as a single class. The video ARI-F thus penalizes models (especially Slot Attention) which fail to track objects stably. We report the mean and standard deviation of scores across 5 random seeds in each case.
+
+![](images/0c7466d809c6bf3df48a2ccc0d1e8c7f5114c36d36595842e0cab66e7c99378d.jpg)  
+Figure 4: Segmentations and reconstructions produced by SIMONe on CATER and Playroom. SIMONe copes well with clutter and different-sized objects. It learns to use object motion as a segmentation signal on CATER, evident from the fact that an object’s shadow is correctly assigned to that object’s segment as it moves. This is true even when there’s multiple shadows per object (due to multiple lights in the scene). SIMONe also overcomes color-based cues to segment two-toned objects such as beds in the Playroom as single objects. See Appendix A.5.2 to compare with baseline models.
+
+We compare SIMONe to a range of competitive but viewpoint-unaware scene decomposition approaches. First, we train two static-frame models: MONet and Slot Attention. MONet uses a similar generative process and training loss to our model, achieving segmentation by modeling the scene as a spatial mixture of components, and achieving disentangled representations using a $\beta$ -weighted KL information bottleneck. On the other hand, it uses a deterministic, recurrent attention network to infer object masks. Slot Attention is a transformer-based autoencoding model which focuses on segmentation performance rather than representation learning. Finally, we also compare against Sequential IODINE (“S-IODINE”), which applies a refinement network to amortize inference over time, separating objects by processing them in parallel. It also uses a $\beta$ -weighted KL loss to disentangle object representations. Note that S-IODINE is a simplified version of OP3 [17], which additionally attempts to model (pairwise) object dynamics using an agent’s actions as inputs. SIMONe and S-IODINE both avoid relying on this privileged information. Table 1 contains a quantitative comparison of segmentation performance across these models, while Figure 4 shows qualitative results.
+
+![](images/4bbe453caa2296f7c2e11f984cd4f4c05d0d48cd785a3a686e3cdb83baeb21db.jpg)  
+Figure 5: Object attributes learnt by SIMONe. In each row, we manipulate a particular object latent attribute for an arbitrary target object (circled in red) in two scenes. This reveals the attributes’ relationship to interpretable object characteristics like color, size, position and identity.
+
+# 5 Analysis
+
+We take a closer look at the representations learnt by our model by decoding them in various ways. First, we manipulate latent attributes individually to assess the interpretability of object representations visually in Section 5.1. Next, we exploit SIMONe’s latent factorization to render views of a given scene using the camera trajectory of a different input sequence. These cross-over visualizations help identify how the model encodes object dynamics in Section 5.2. Finally, we measure the predictability of ground-truth camera dynamics and object dynamics from the two types of latents in Section 5.3. These analyses use a single, fully unsupervised model per dataset.
+
+# 5.1 Latent attribute traversals
+
+We visualize the object representations learnt by SIMONe on Playroom to highlight their disentanglement, across latent attributes and across object slots, in Figure 5. We seed all latents using a given input sequence, then manipulate one object latent attribute at a time by adding fixed offsets.
+
+Note that object position and size are well disentangled in each direction. Aided by the extraction of view-specific information in the frame latents, SIMONe also learns object features corresponding to identity. The decoder nevertheless obeys the biases in the dataset–for instance, shelves will slide along a wall when their position latent is traversed. The rubber duck does not morph into a chest of drawers because those are always located against a wall. This further suggests a well-structured latent representation, which the decoder can adapt to.
+
+# 5.2 Object and frame latent cross-overs
+
+We expect SIMONe to encode object trajectories and camera trajectories independently of each other. In fact, each object’s trajectory should be summarized in its own time-invariant latent code. To examine this, we recompose object latents from one sequence with frame latents from other sequences in the CATER dataset. The result, in Figure 6, is that we can observe object motion trajectories from multiple camera trajectories.
+
+Note the consistency of relative object positions (at any time-step) from all camera angles. In the single moving object case, its motion could in fact be interpreted as a time-varying global property of the scene. Despite this challenge, SIMONe is able to encode the object’s motion as desired in its specific time-invariant code. In Section 5.3, we further confirm that object trajectories are summarized in the object latents, which can be queried with time to recover allocentric object positions.
+
+![](images/898e0b3941c04bad1f27e5edb95e93f0dd4c2ceea8de314f4c150297097c6158.jpg)  
+Figure 6: Separation of object trajectories from camera trajectories. Left: When encoding a sequence with consistent (i.i.d.) object dynamics, this information is extracted in the object latents and is unaffected by changing frame latents (see green cone). Right: Movement events are sequenced correctly; object relative positions also remain consistent (see pattern of shadows on the floor circled in yellow). See Appendix A.5.3 for cross-over plots showing more object trajectories.
+
+# 5.3 Camera pose and object trajectory prediction
+
+We assessed SIMONe’s frame latents by decoding the true camera position and orientation from them. We trained linear and MLP regressors to predict the camera pose at time $t$ from the corresponding frame latent $\mathbf { f } _ { t }$ on a subset of CATER sequences. We also trained an MLP on the time-invariant object latents $\mathbf { o } _ { 1 : K }$ for the same task. We evaluated these decoders on held-out data. Table 2 shows that frame latents describe the viewpoint almost perfectly.
+
+We also assessed if the object latents contain precise information about allocentric object positions (to be clear, position information is not provided in any form while training SIMONe). Table 3 shows that the correct object latent is predictive of the allocentric position of a dynamic object (when queried along with the timestep). Adding the frame latent does not provide more information, and using
+
+Table 2: Decoding camera pose. We show that ground-truth camera location or orientation is predictable from the corresponding frame latent, but cannot be predicted from all object latents put together. We report the test $\mathrm { \dot { ~ } R ^ { 2 } }$ score across 5 independently trained decoders per input type.   
+
+<table><tr><td></td><td>Linear(ft)</td><td>MLP(ft)</td><td>MLP(0.1,..,.·0K)</td></tr><tr><td>Camera location</td><td>0.832 ± 0.0</td><td>0.949 ± 0.002</td><td>0.044 ± 0.026</td></tr><tr><td>Camera orientation (Rodrigues)</td><td>0.800 ± 0.0</td><td>0.946±0.002</td><td>0.292±0.025</td></tr></table>
+
+<table><tr><td></td><td>MLP(Ok)</td><td>MLP(Ok,t)</td><td>MLP(Ok,ft,t)</td><td>MLP({oj : j≠k})</td></tr><tr><td>Trained on all objects</td><td>0.710± 0.006</td><td>0.871 ± 0.006</td><td>0.876 ± 0.003</td><td>-0.062±0.006</td></tr><tr><td>Trained on moving objects</td><td>0.724± 0.007</td><td>0.894± 0.004</td><td>0.898± 0.005</td><td>一 -0.022 ± 0.025</td></tr></table>
+
+Table 3: Decoding object trajectories. We test MLP decoders on predicting allocentric object positions (of moving object in unseen scenes) based on the following inputs: (a) the corresponding object latent, (b) the timestep as well, and (c) the frame latent corresponding to that timestep as well, and (d) remaining object latents from the scene (not pertaining to the object of interest). The decoders were trained on arbitrary objects or a subset containing moving objects only. We report the test $R ^ { 2 }$ score across 5 independently trained decoders per input type.
+
+the “wrong” objects (from the same scene) is completely uninformative. To perform this analysis, we needed to align SIMONe’s inferred objects with the ground-truth set of objects. We used the Hungarian matching algorithm on the MSE of inferred object masks and ground-truth object masks to perform the alignment. Given SIMONe’s disentangling of object dynamics, its time-abstracted object representations could prove helpful for a variety of downstream tasks (e.g. “catch the flying ball!”).
+
+Taken together, Table 2 and Table 3 show the separation of information that is achieved between the object and frame latents, helping assert our two central aims of view-invariant and temporally abstracted object representations.
+
+# 6 Discussion and Future Work
+
+Scalability. The transformer-based inference network in SIMONe makes it amenable to processing arbitrarily large videos, just as transformer-based language models can process long text. SIMONe could be trained on windows of consecutive frames sampled from larger videos (aka "chunks"). For inference over a full video, one could add memory slots which carry information over time from one window to the next. Applying SIMONe on sliding windows of frames also presents the opportunity to amortize inference at any given time-step if the windows are partially overlapping (so the model could observe every given frame as part of two or more sequences). Our use of the standard transformer architecture also makes SIMONe amenable to performance improvements via alternative implementations.
+
+Limitations. (1) SIMONe cannot generate novel videos (e.g. sample a natural camera trajectory via consecutive frame latents) in its current version. This could be addressed in a similar fashion to the way GENESIS [5] built on MONet [3]–it should be possible (e.g. using recurrent networks) to learn conditional priors for objects in a scene and for successive frame latents, which would make SIMONe fully generative. (2) We see another possible limitation arising from our strict latent factorization. We have shown that temporally abstracted object features can predict object trajectories when queried by time. This can cover a lot of interesting cases (even multiple object-level "events" over time), but will start to break as object trajectories get more stochastic (i.e. objects transition considerably/chaotically through time). We leave it to future work to explore how temporal abstraction can be combined with explicit per-step dynamics modeling in those cases. For simpler settings, our approach to encoding object trajectories (distilling them across time) is surprisingly effective.
+
+# 7 Conclusion
+
+We’ve presented SIMONe, a latent variable model which separates the time-invariant, object-level properties of a scene video from the time-varying, global properties. Our choice of scalable modules such as transformers for inference, and a pixel-wise decoder, allow the model to extract this information effectively.
+
+SIMONe can learn the common structure across a variety of procedurally instantiated scenes. This enables it to recognize and generalize to novel scene instances from a handful of correlated views, as we showcased via 360-degree view traversal in the view-supervised setting. More significantly, SIMONe can learn to infer the two sets of latent variables jointly without supervision. Aided by crossframe spatio-temporal attention, it achieves state-of-the-art segmentation performance on complex 3D scenes. Our latent factorization (and information bottleneck pressures) further help with learning meaningful object representations. SIMONe can not only separate static object attributes (like size and position), but it can also separate the dynamics of different objects (as time-invariant localized properties) from global changes in view.
+
+We have discussed how the model can be applied to much longer videos in the future. It also has potential for applications in robotics (e.g. sim-to-real transfer) and reinforcement learning, where view-invariant object information (and summarizing their dynamics) could dramatically improve how agents reason about objects.
+
+# Acknowledgements
+
+We thank Michael Bloesch, Markus Wulfmeier, Arunkumar Byravan, Claudio Fantacci, and Yusuf Aytar for valuable discussions on the purview of our work. We are also grateful for David Ding’s support on the CATER dataset. The authors received no specific funding for this work.
+
+# References
+
+[1] Jitendra Malik. Scene understanding in the era of deep learning, Jun 2015. URL https://www.robots. ox.ac.uk/seminars/Extra/2015_06_22_JitendraMalik.pdf.   
+[2] Farzad Husain, Babette Dellen, and Carme Torras. Chapter 20 - Scene Understanding Using Deep Learning, pages 373–382. Academic Press, 2017. ISBN 978-0-12-811318-9. doi: https://doi.org/10.1016/ B978-0-12-811318-9.00020-X.   
+[3] Christopher P Burgess, Loic Matthey, Nicholas Watters, Rishabh Kabra, Irina Higgins, Matt Botvinick, and Alexander Lerchner. Monet: Unsupervised scene decomposition and representation. arXiv preprint arXiv:1901.11390, 2019.   
+[4] Klaus Greff, Raphaël Lopez Kaufman, Rishabh Kabra, Nick Watters, Christopher Burgess, Daniel Zoran, Loic Matthey, Matthew Botvinick, and Alexander Lerchner. Multi-object representation learning with iterative variational inference. In International Conference on Machine Learning, pages 2424–2433. PMLR, 2019.   
+[5] Martin Engelcke, Adam R. Kosiorek, Oiwi Parker Jones, and Ingmar Posner. Genesis: Generative scene inference and sampling with object-centric latent representations. In International Conference on Learning Representations, 2020.   
+[6] Zhixuan Lin, Yi-Fu Wu, Skand Vishwanath Peri, Weihao Sun, Gautam Singh, Fei Deng, Jindong Jiang, and Sungjin Ahn. Space: Unsupervised object-oriented scene representation via spatial attention and decomposition. In International Conference on Learning Representations, 2020.   
+[7] S M Ali Eslami, Danilo Jimenez Rezende, Frederic Besse, Fabio Viola, Ari S Morcos, Marta Garnelo, Avraham Ruderman, Andrei A Rusu, Ivo Danihelka, Karol Gregor, David P Reichert, Lars Buesing, Theophane Weber, Oriol Vinyals, Dan Rosenbaum, Neil Rabinowitz, Helen King, Chloe Hillier, Matt Botvinick, Daan Wierstra, Koray Kavukcuoglu, and Demis Hassabis. Neural scene representation and rendering. Science, 360(6394):1204–1210, June 2018.   
+[8] Vincent Sitzmann, Michael Zollhoefer, and Gordon Wetzstein. Scene representation networks: Continuous 3D-Structure-Aware neural scene representations. In H Wallach, H Larochelle, A Beygelzimer, F d’Alché Buc, E Fox, and R Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.   
+[9] Ben Mildenhall, Pratul P Srinivasan, Matthew Tancik, Jonathan T Barron, Ravi Ramamoorthi, and Ren Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. In European Conference on Computer Vision, pages 405–421. Springer, 2020.   
+[10] C. Cadena, L. Carlone, H. Carrillo, Y. Latif, D. Scaramuzza, J. Neira, I. Reid, and J.J. Leonard. Past, present, and future of simultaneous localization and mapping: Towards the robust-perception age. IEEE Transactions on Robotics, 32(6):1309–1332, 2016.   
+[11] Binbin Xu, Wenbin Li, Dimos Tzoumanikas, Michael Bloesch, Andrew Davison, and Stefan Leutenegger. Mid-fusion: Octree-based object-level multi-instance dynamic slam. In 2019 International Conference on Robotics and Automation (ICRA), pages 5231–5237. IEEE, 2019.   
+[12] Li Nanbo, Cian Eastwood, and Robert B Fisher. Learning object-centric representations of multi-object scenes from multiple views. In Advances in Neural Information Processing Systems, 2020.   
+[13] Chang Chen, Fei Deng, and Sungjin Ahn. Object-centric representation and rendering of 3d scenes. arXiv preprint arXiv:2006.06130, 2020.   
+[14] Klaus Greff, Sjoerd van Steenkiste, and Jürgen Schmidhuber. On the binding problem in artificial neural networks. arXiv preprint arXiv:2012.05208, 2020.   
+[15] Francesco Locatello, Dirk Weissenborn, Thomas Unterthiner, Aravindh Mahendran, Georg Heigold, Jakob Uszkoreit, Alexey Dosovitskiy, and Thomas Kipf. Object-centric learning with slot attention. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 11525–11538. Curran Associates, Inc., 2020.   
+[16] Antonia Creswell, Rishabh Kabra, Chris Burgess, and Murray Shanahan. Unsupervised object-based transition models for 3d partially observable environments. arXiv preprint arXiv:2103.04693, 2021.   
+[17] Rishi Veerapaneni, John D Co-Reyes, Michael Chang, Michael Janner, Chelsea Finn, Jiajun Wu, Joshua Tenenbaum, and Sergey Levine. Entity abstraction in visual model-based reinforcement learning. In Conference on Robot Learning, pages 1439–1456. PMLR, 2020.   
+[18] Polina Zablotskaia, Edoardo A Dominici, Leonid Sigal, and Andreas M Lehrmann. Unsupervised video decomposition using spatio-temporal iterative inference. arXiv preprint arXiv:2006.14727, 2020.   
+[19] S M Ali Eslami, Nicolas Heess, Theophane Weber, Yuval Tassa, David Szepesvari, Koray Kavukcuoglu, and Geoffrey E Hinton. Attend, infer, repeat: fast scene understanding with generative models. In Proceedings of the 30th International Conference on Neural Information Processing Systems, NIPS’16, pages 3233–3241, Red Hook, NY, USA, December 2016. Curran Associates Inc.   
+[20] Adam Kosiorek, Hyunjik Kim, Yee Whye Teh, and Ingmar Posner. Sequential attend, infer, repeat: Generative modelling of moving objects. Adv. Neural Inf. Process. Syst., 31, 2018.   
+[21] Eric Crawford and Joelle Pineau. Exploiting spatial invariance for scalable unsupervised object tracking. arXiv preprint arXiv:1911.09033, 2019.   
+[22] Eric Crawford and Joelle Pineau. Spatially invariant unsupervised object detection with convolutional neural networks. AAAI, 33(01):3412–3420, July 2019.   
+[23] Jindong Jiang, Sepehr Janghorbani, Gerard de Melo, and Sungjin Ahn. SCALOR: Generative world models with scalable object representations. arXiv preprint arXiv:1910.02384, October 2019.   
+[24] Albert Pumarola, Enric Corona, Gerard Pons-Moll, and Francesc Moreno-Noguer. D-NeRF: Neural radiance fields for dynamic scenes. arXiv preprint arXiv:2011.13961, November 2020.   
+[25] Keunhong Park, Utkarsh Sinha, Jonathan T Barron, Sofien Bouaziz, Dan B Goldman, Steven M Seitz, and Ricardo Martin-Brualla. Nerfies: Deformable neural radiance fields. arXiv preprint arXiv:2011.12948, 2020.   
+[26] Zhengqi Li, Simon Niklaus, Noah Snavely, and Oliver Wang. Neural scene flow fields for Space-Time view synthesis of dynamic scenes. arXiv preprint arXiv:2011.13084, November 2020.   
+[27] Yilun Du, Yinan Zhang, Hong-Xing Yu, Joshua B Tenenbaum, and Jiajun Wu. Neural radiance flow for 4D view synthesis and video processing. arXiv preprint arXiv:2012.09790, December 2020.   
+[28] Chen-Hsuan Lin, Wei-Chiu Ma, Antonio Torralba, and Simon Lucey. BARF: Bundle-Adjusting neural radiance fields. arXiv preprint arXiv:2104.06405, April 2021.   
+[29] Zirui Wang, Shangzhe Wu, Weidi Xie, Min Chen, and Victor Adrian Prisacariu. NeRF–: Neural radiance fields without known camera parameters. arXiv preprint arXiv:2102.07064, February 2021.   
+[30] Adam Kosiorek, Heiko Strathmann, Daniel Zoran, Pol Moreno, Rosalia Schneider, Sona Mokrá, and ˇ Danilo Jimenez Rezende. NeRF-VAE: A geometry aware 3D scene generative model. In International Conference on Machine Learning. PMLR, 2021.   
+[31] Alex Trevithick and Bo Yang. GRF: Learning a general radiance field for 3D scene representation and rendering. arXiv preprint arXiv:2010.04595, October 2020.   
+[32] Alex Yu, Vickie Ye, Matthew Tancik, and Angjoo Kanazawa. pixelNeRF: Neural radiance fields from one or few images. arXiv preprint arXiv:2012.02190, December 2020.   
+[33] Michael Niemeyer and Andreas Geiger. GIRAFFE: Representing scenes as compositional generative neural feature fields. arXiv preprint arXiv:2011.12100, November 2020.   
+[34] H. Durrant-Whyte and T. Bailey. Simultaneous localization and mapping: part i. IEEE Robotics Automation Magazine, 13(2):99–110, 2006. doi: 10.1109/MRA.2006.1638022.   
+[35] T. Bailey and H. Durrant-Whyte. Simultaneous localization and mapping (slam): part ii. IEEE Robotics Automation Magazine, 13(3):108–117, 2006. doi: 10.1109/MRA.2006.1678144.   
+[36] Josep Aulinas, Yvan Petillot, Joaquim Salvi, and Xavier Lladó. The slam problem: A survey. In Proceedings of the 2008 Conference on Artificial Intelligence Research and Development: Proceedings of the 11th International Conference of the Catalan Association for Artificial Intelligence, page 363–371, NLD, 2008. IOS Press. ISBN 9781586039257.   
+[37] Michael Burri, Janosch Nikolic, Pascal Gohl, Thomas Schneider, Joern Rehder, Sammy Omari, Markus W Achtelik, and Roland Siegwart. The euroc micro aerial vehicle datasets. The International Journal of Robotics Research, 2016. doi: 10.1177/0278364915620033.   
+[38] Andreas Geiger, Philip Lenz, and Raquel Urtasun. Are we ready for autonomous driving? the kitti vision benchmark suite. In Conference on Computer Vision and Pattern Recognition (CVPR), 2012.   
+[39] J. Sturm, N. Engelhard, F. Endres, W. Burgard, and D. Cremers. A benchmark for the evaluation of rgb-d slam systems. In Proc. of the International Conference on Intelligent Robot Systems (IROS), Oct. 2012.   
+[40] Ruihao Li, Sen Wang, and Dongbing Gu. Deepslam: A robust monocular slam system with unsupervised deep learning. IEEE Transactions on Industrial Electronics, 68(4):3577–3587, 2021. doi: 10.1109/TIE. 2020.2982096.   
+[41] Mingyang Geng, Suning Shang, Bo Ding, Huaimin Wang, and Pengfei Zhang. Unsupervised learningbased depth estimation-aided visual slam approach. Circuits, Systems, and Signal Processing, 39(2): 543–570, 2020.   
+[42] Diederik P Kingma and Max Welling. An introduction to variational autoencoders. arXiv preprint arXiv:1906.02691, 2019.   
+[43] Adam R Kosiorek, Heiko Strathmann, Daniel Zoran, Pol Moreno, Rosalia Schneider, Sona Mokrá, ˇ and Danilo J Rezende. Nerf-vae: A geometry aware 3d scene generative model. arXiv preprint arXiv:2104.00587, 2021.   
+[44] Rishabh Kabra, Chris Burgess, Loic Matthey, Raphael Lopez Kaufman, Klaus Greff, Malcolm Reynolds, and Alexander Lerchner. Multi-object datasets. https://github.com/deepmind/multi-object-datasets/, 2019.   
+[45] Rohit Girdhar and Deva Ramanan. CATER: A diagnostic dataset for compositional actions & temporal reasoning. In International Conference on Learning Representations, 2020.   
+[46] Josh Abramson, Arun Ahuja, Arthur Brussee, Federico Carnevale, Mary Cassin, Stephen Clark, Andrew Dudzik, Petko Georgiev, Aurelia Guy, Tim Harley, et al. Imitating interactive intelligence. arXiv preprint arXiv:2012.05672, 2020.   
+[47] Danilo Jimenez Rezende and Fabio Viola. Taming vaes. arXiv preprint arXiv:1810.00597, 2018.   
+[48] Vasu Parameswaran and Rama Chellappa. View invariance for human action recognition. International Journal of Computer Vision, 66(1):83–101, 2006.   
+[49] Yang Liu, Zhaoyang Lu, Jing Li, and Tao Yang. Hierarchically learned view-invariant representations for cross-view action recognition. IEEE Transactions on Circuits and Systems for Video Technology, 29(8): 2416–2430, 2018.   
+[50] Ting Liu, Jennifer J Sun, Long Zhao, Jiaping Zhao, Liangzhe Yuan, Yuxiao Wang, Liang-Chieh Chen, Florian Schroff, and Hartwig Adam. View-invariant, occlusion-robust probabilistic embedding for human pose. arXiv preprint arXiv:2010.13321, 2020.   
+[51] Jennifer J Sun, Jiaping Zhao, Liang-Chieh Chen, Florian Schroff, Hartwig Adam, and Ting Liu. Viewinvariant probabilistic embedding for human pose. In European Conference on Computer Vision, pages 53–70. Springer, 2020.   
+[52] Yana Hasson, Bugra Tekin, Federica Bogo, Ivan Laptev, Marc Pollefeys, and Cordelia Schmid. Leveraging photometric consistency over time for sparsely supervised hand-object reconstruction. In CVPR, 2020.   
+[53] Emily L Denton and Vighnesh Birodkar. Unsupervised learning of disentangled representations from video. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017.   
+[54] Yizhe Zhu, Martin Renqiang Min, Asim Kadav, and Hans Peter Graf. S3VAE: Self-supervised sequential VAE for representation disentanglement and data generation. In 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). IEEE, June 2020.   
+[55] Emily Denton and Rob Fergus. Stochastic video generation with a learned prior. arXiv preprint arXiv:1802.07687, February 2018.   
+[56] Ruben Villegas, Jimei Yang, Seunghoon Hong, Xunyu Lin, and Honglak Lee. Decomposing motion and content for natural video sequence prediction. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.   
+[57] Li Yingzhen and Stephan Mandt. Disentangled sequential autoencoder. In Jennifer Dy and Andreas Krause, editors, Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 5670–5679. PMLR, 2018.   
+[58] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Ł ukasz Kaiser, and Illia Polosukhin. Attention is all you need. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017.   
+[59] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, and Neil Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. In International Conference on Learning Representations, 2021.   
+[60] Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-End object detection with transformers. In Computer Vision – ECCV 2020, pages 213–229. Springer International Publishing, 2020.   
+[61] Huiyu Wang, Yukun Zhu, Hartwig Adam, Alan Yuille, and Liang-Chieh Chen. MaX-DeepLab: End-to-End panoptic segmentation with mask transformers. arXiv preprint arXiv:2012.00759, December 2020.   
+[62] Sixiao Zheng, Jiachen Lu, Hengshuang Zhao, Xiatian Zhu, Zekun Luo, Yabiao Wang, Yanwei Fu, Jianfeng Feng, Tao Xiang, Philip H S Torr, and Li Zhang. Rethinking semantic segmentation from a Sequence-toSequence perspective with transformers. arXiv preprint arXiv:2012.15840, December 2020.   
+[63] Mathilde Caron, Hugo Touvron, Ishan Misra, Hervé Jégou, Julien Mairal, Piotr Bojanowski, and Armand Joulin. Emerging properties in self-supervised vision transformers. arXiv preprint arXiv:2104.14294, 2021.   
+[64] Gedas Bertasius, Heng Wang, and Lorenzo Torresani. Is Space-Time attention all you need for video understanding? arXiv preprint arXiv:2102.05095, February 2021.   
+[65] Daniel Neimark, Omri Bar, Maya Zohar, and Dotan Asselmann. Video transformer network. arXiv preprint arXiv:2102.00719, February 2021.   
+[66] Anurag Arnab, Mostafa Dehghani, Georg Heigold, Chen Sun, Mario Luciˇ c, and Cordelia Schmid. ViViT: ´ A video vision transformer. arXiv preprint arXiv:2103.15691, March 2021.   
+[67] Yuqing Wang, Zhaoliang Xu, Xinlong Wang, Chunhua Shen, Baoshan Cheng, Hao Shen, and Huaxia Xia. End-to-End video instance segmentation with transformers. arXiv preprint arXiv:2011.14503, November 2020.   
+[68] Fabio Viola, Louise Deason, and Marcel Büsching. Datasets used to train generative query networks (gqns) in the ‘neural scene representation and rendering’ paper. https://github.com/deepmind/gqn-datasets, 2018.   
+[69] Felix Hill, Olivier Tieleman, Tamara von Glehn, Nathaniel Wong, Hamza Merzic, and Stephen Clark. Grounded language learning fast and slow. arXiv preprint arXiv:2009.01719, 2020.   
+[70] Nicholas Watters, Loic Matthey, Christopher P Burgess, and Alexander Lerchner. Spatial broadcast decoder: A simple architecture for learning disentangled representations in vaes. arXiv preprint arXiv:1901.07017, 2019.

md/train/o_V-MjyyGV_/o_V-MjyyGV_.md

@@ -0,0 +1,367 @@
+# SELF-SUPERVISED POLICY ADAPTATION DURING DEPLOYMENT
+
+Nicklas Hansen12, Rishabh Jangir13, Yu Sun4, Guillem Alenya\`3, Pieter Abbeel4, Alexei A Efros4, Lerrel Pinto5, Xiaolong Wang1 1UC San Diego 2Technical University of Denmark ${ } ^ { 3 } \mathrm { I R I }$ , CSIC-UPC 4UC Berkeley 5NYU
+
+# ABSTRACT
+
+In most real world scenarios, a policy trained by reinforcement learning in one environment needs to be deployed in another, potentially quite different environment. However, generalization across different environments is known to be hard. A natural solution would be to keep training after deployment in the new environment, but this cannot be done if the new environment offers no reward signal. Our work explores the use of self-supervision to allow the policy to continue training after deployment without using any rewards. While previous methods explicitly anticipate changes in the new environment, we assume no prior knowledge of those changes yet still obtain significant improvements. Empirical evaluations are performed on diverse simulation environments from DeepMind Control suite and ViZDoom, as well as real robotic manipulation tasks in continuously changing environments, taking observations from an uncalibrated camera. Our method improves generalization in 31 out of 36 environments across various tasks and outperforms domain randomization on a majority of environments.
+
+# 1 INTRODUCTION
+
+Deep reinforcement learning (RL) has achieved considerable success when combined with convolutional neural networks for deriving actions from image pixels (Mnih et al., 2013; Levine et al., 2016; Nair et al., 2018; Yan et al., 2020; Andrychowicz et al., 2020). However, one significant challenge for real-world deployment of vision-based RL remains: a policy trained in one environment might not generalize to other new environments not seen during training. Already hard for RL alone, the challenge is exacerbated when a policy faces high-dimensional visual inputs.
+
+A well explored class of solutions is to learn robust policies that are simply invariant to changes in the environment (Rajeswaran et al., 2016; Tobin et al., 2017; Sadeghi & Levine, 2016; Pinto et al., 2017b; Lee et al., 2019). For example, domain randomization (Tobin et al., 2017; Peng et al., 2018; Pinto et al., 2017a; Yang et al., 2019) applies data augmentation in a simulated environment to train a single robust policy, with the hope that the augmented environment covers enough factors of variation in the test environment. However, this hope may be difficult to realize when the test environment is truly unknown. With too much randomization, training a policy that can simultaneously fit numerous augmented environments requires much larger model and sample complexity. With too little randomization, the actual changes in the test environment might not be covered, and domain randomization may do more harm than good since the randomized factors are now irrelevant. Both phenomena have been observed in our experiments. In all cases, this class of solutions requires human experts to anticipate the changes before the test environment is seen. This cannot scale as more test environments are added with more diverse changes.
+
+Instead of learning a robust policy invariant to all possible environmental changes, we argue that it is better for a policy to keep learning during deployment and adapt to its actual new environment. A naive way to implement this in RL is to fine-tune the policy in the new environment using rewards as supervision (Rusu et al., 2016; Kalashnikov et al., 2018; Julian et al., 2020). However, while it is relatively easy to craft a dense reward function during training (Gu et al., 2017; Pinto & Gupta, 2016), during deployment it is often impractical and may require substantial engineering efforts.
+
+In this paper, we tackle an alternative problem setting in vision-based RL: adapting a pre-trained policy to an unknown environment without any reward. We do this by introducing self-supervision to obtain “free” training signal during deployment. Standard self-supervised learning employs auxiliary tasks designed to automatically create training labels using only the input data (see Section 2 for details). Inspired by this, our policy is jointly trained with two objectives: a standard RL objective and, additionally, a self-supervised objective applied on an intermediate representation of the policy network. During training, both objectives are active, maximizing expected reward and simultaneously constraining the intermediate representation through self-supervision. During testing / deployment, only the self-supervised objective (on the raw observational data) remains active, forcing the intermediate representation to adapt to the new environment.
+
+We perform experiments both in simulation and with a real robot. In simulation, we evaluate on two sets of environments: DeepMind Control suite (Tassa et al., 2018) and the CRLMaze ViZDoom (Lomonaco et al., 2019; Wydmuch et al., 2018) navigation task. We evaluate generalization by testing in new environments with visual changes unknown during training. Our method improves generalization in 19 out of 22 test environments across various tasks in DeepMind Control suite, and in all considered test environments on CRLMaze. Besides simulations, we also perform Sim2Real transfer on both reaching and pushing tasks with a Kinova Gen3 robot. After training in simulation, we successfully transfer and adapt policies to 6 different environments, including continuously changing disco lights, on a real robot operating solely from an uncalibrated camera. In both simulation and real experiments, our approach outperforms domain randomization in most environments.
+
+# 2 RELATED WORK
+
+Self-supervised learning is a powerful way to learn visual representations from unlabeled data (Vincent et al., 2008; Doersch et al., 2015; Wang & Gupta, 2015; Zhang et al., 2016; Pathak et al., 2016; Noroozi & Favaro, 2016; Zhang et al., 2017; Gidaris et al., 2018). Researchers have proposed to use auxiliary data prediction tasks, such as undoing rotation (Gidaris et al., 2018), solving a jigsaw puzzle (Noroozi & Favaro, 2016), tracking (Wang et al., 2019), etc. to provide supervision in lieu of labels. In RL, the idea of learning visual representations and action at the same time has been investigated (Lange & Riedmiller, 2010; Jaderberg et al., 2016; Pathak et al., 2017; Ha & Schmidhuber, 2018; Yarats et al., 2019; Srinivas et al., 2020; Laskin et al., 2020; Yan et al., 2020). For example, Srinivas et al. (2020) use self-supervised contrastive learning techniques (Chen et al., 2020; Henaff ´ et al., 2019; Wu et al., 2018; He et al., 2020) to improve sample efficiency in RL by jointly training the self-supervised objective and RL objective. However, this has not been shown to generalize to unseen environments. Other works have applied self-supervision for better generalization across environments (Pathak et al., 2017; Ebert et al., 2018; Sekar et al., 2020). For example, Pathak et al. (2017) use a self-supervised prediction task to provide dense rewards for exploration in novel environments. While results on environment exploration from scratch are encouraging, how to transfer a trained policy (with extrinsic reward) to a novel environment remains unclear. Hence, these methods are not directly applicable to the proposed problem in our paper.
+
+Generalization across different distributions is a central challenge in machine learning. In domain adaptation, target domain data is assumed to be accessible (Geirhos et al., 2018; Tzeng et al., 2017; Ganin et al., 2016; Gong et al., 2012; Long et al., 2016; Sun et al., 2019; Julian et al., 2020). For example, Tzeng et al. (2017) use adversarial learning to align the feature representations in both the source and target domain during training. Similarly, the setting of domain generalization (Ghifary et al., 2015; Li et al., 2018; Matsuura & Harada, 2019) assumes that all domains are sampled from the same meta distribution, but the same challenge remains and now becomes generalization across meta-distributions. Our work focuses instead on the setting of generalizing to truly unseen changes in the environment which cannot be anticipated at training time.
+
+There have been several recent benchmarks in our setting for image recognition (Hendrycks & Dietterich, 2018; Recht et al., 2018; 2019; Shankar et al., 2019). For example, in Hendrycks & Dietterich (2018), a classifier trained on regular images is tested on corrupted images, with corruption types unknown during training; the method of Hendrycks et al. (2019) is proposed to improve robustness on this benchmark. Following similar spirit, in the context of RL, domain randomization (Tobin et al., 2017; Pinto et al., 2017a; Peng et al., 2018; Ramos et al., 2019; Yang et al., 2019; James et al., 2019) helps a policy trained in simulation to generalize to real robots. For example, Tobin et al. (2017); Sadeghi & Levine (2016) propose to render the simulation environment with random textures and train the policy on top. The learned policy is shown to generalize to real robot manipulation tasks. Instead of deploying a fixed policy, we train and adapt the policy to the new environment with observational data that is naturally revealed during deployment.
+
+![](images/57b2c63b42fbd5db91f946cce8e82fe594fcd240b2336a571da5151324e65062.jpg)  
+Figure 1. Left: Training before deployment. Observations are sampled from a replay buffer for off-policy methods and are collected during roll-outs for on-policy methods. We optimize the RL and self-supervised objectives jointly. Right: Policy adaptation during deployment. Observations are collected from the test environment online, and we optimize only the self-supervised objective.
+
+Test-time adaptation for deep learning is starting to be used in computer vision (Shocher et al., 2017; 2018; Bau et al., 2019; Mullapudi et al., 2019; Sun et al., 2020; Wortsman et al., 2018). For example, Shocher et al. (2018) shows that image super-resolution can be learned at test time (from scratch) simply by trying to upsample a downsampled version of the input image. Bau et al. (2019) show that adapting the prior of a generative adversarial network to the statistics of the test image improves photo manipulation tasks. Our work is closely related to the test-time training method of Sun et al. (2020), which performs joint optimization of image recognition and self-supervised learning with rotation prediction (Gidaris et al., 2018), then uses the self-supervised objective to adapt the representation of individual images during testing. Instead of image recognition, we perform test-time adaptation for RL with visual inputs in an online fashion. As the agent interacts with an environment, we keep obtaining new observational data in a stream for training the visual representations.
+
+# 3 METHOD
+
+In this section, we describe our proposed Policy Adaptation during Deployment (PAD) approach. It can be implemented on top of any policy network and standard RL algorithm (both on-policy and off-policy) that can be described by minimizing some RL objective $J ( \theta )$ w.r.t. the collection of parameters $\theta$ using stochastic gradient descent.
+
+# 3.1 NETWORK ARCHITECTURE
+
+We design the network architecture to allow the policy and the self-supervised prediction to share features. For the collection of parameters $\theta$ of a given policy network $\pi$ , we split it sequentially into $\theta = \left( \theta _ { e } , \theta _ { a } \right)$ , where $\theta _ { e }$ collects the parameters of the feature extractor, and $\theta _ { a }$ is the head that outputs a distribution over actions. We define networks $\pi _ { e }$ with parameters $\theta _ { e }$ and $\pi _ { a }$ with parameters $\theta _ { a }$ such that $\pi ( \mathbf { s } ; \theta ) = \pi _ { a } ( \pi _ { e } ( \mathbf { s } ) )$ , where s represents an image observation. Intuitively, one can think of $\pi _ { e }$ as a feature extractor, and $\pi _ { a }$ as a controller based on these features. The goal of our method is to update $\pi _ { e }$ at test-time using gradients from a self-supervised task, such that $\pi _ { e }$ (and consequently $\pi _ { \theta }$ ) can generalize. Let $\pi _ { s }$ with parameters $\theta _ { s }$ be the self-supervised prediction head and its collection of parameters, and the input to $\pi _ { s }$ be the output of $\pi _ { e }$ (as illustrated in Figure 1). In this work, the self-supervised task is inverse dynamics prediction for control, and rotation prediction for navigation.
+
+# 3.2 INVERSE DYNAMICS PREDICTION AND ROTATION PREDICTION
+
+At each time step, we always observe a transition sequence in the form of $\left( \mathbf { s } _ { t } , \mathbf { a } _ { t } , \mathbf { s } _ { t + 1 } \right)$ , during both training and testing. Naturally, self-supervision can be derived from taking parts of the sequence and predicting the rest. An inverse dynamics model takes the states before and after transition, and predicts the action in between. In this work, the inverse dynamics model $\pi _ { s }$ operates on the feature space extracted by $\pi _ { e }$ . We can write the inverse dynamics prediction objective formally as
+
+$$
+L ( \theta _ { s } , \theta _ { e } ) = \ell \big ( \mathbf { a } _ { t } , \pi _ { s } ( \pi _ { e } ( \mathbf { s } _ { t } ) , \pi _ { e } ( \mathbf { s } _ { t + 1 } ) ) \big ) .
+$$
+
+For continuous actions, $\ell$ is the mean squared error between the ground truth and the model output. For discrete actions, the output is a soft-max distribution over the action space, and $\ell$ is the crossentropy loss. Empirically, we find this self-supervised task to be most effective with continuous actions, possibly because inverse dynamics prediction in a small space of discrete actions is not as challenging. Note that we predict the inverse dynamics instead of the forward dynamics, because when operating in feature space, the latter can produce trivial solutions such as the constant zero feature for every state2. If we instead performed prediction with forward dynamics in pixel space, the task would be extremely challenging given the large uncertainty in pixel prediction.
+
+As an alternative self-supervised task, we use rotation prediction (Gidaris et al., 2018). We rotate an image by one of 0, 90, 180 and 270 degrees as input to the network, and cast this as a four-way classification problem to determine which one of these four ways the image has been rotated. This task is shown to be effective for learning representations for object configuration and scene structure, which is beneficial for visual recognition (Hendrycks et al., 2019; Doersch & Zisserman, 2017).
+
+# 3.3 TRAINING AND TESTING
+
+Before deployment of the policy, because we have signals from both the reward and self-supervised auxiliary task, we can train with both in the fashion of multi-task learning. This corresponds to the following optimization problem during training $\begin{array} { r } { \operatorname* { m i n } _ { \theta _ { a } , \theta _ { s } , \theta _ { e } } J ( \theta _ { a } , \theta _ { e } ) + \alpha L ( \theta _ { s } , \theta _ { e } ) } \end{array}$ , where $\alpha > 0$ is a trade-off hyperparameter. During deployment, we cannot optimize $J$ anymore since the reward is unavailable, but we can still optimize $L$ to update both $\theta _ { s }$ and $\theta _ { e }$ . Empirically, we find only negligible difference with keeping $\theta _ { s }$ fixed at test-time, so we update both since the gradients have to be computed regardless; we ablate this decision in appendix C. As we obtain new images from the stream of visual inputs in the environment, $\theta$ keeps being updated until the episode ends. This corresponds to, for each iteration $t = 1 . . . T$ :
+
+$$
+\begin{array} { r l } & { \quad \mathbf s _ { t } \sim p ( \mathbf s _ { t } | \mathbf a _ { t - 1 } , \mathbf s _ { t - 1 } ) } \\ & { \quad \theta _ { s } ( t ) = \theta _ { s } ( t - 1 ) - \nabla _ { \theta _ { s } } L ( \mathbf s _ { t } ; \theta _ { s } ( t - 1 ) , \theta _ { e } ( t - 1 ) ) } \\ & { \quad \theta _ { e } ( t ) = \theta _ { e } ( t - 1 ) - \nabla _ { \theta _ { e } } L ( \mathbf s _ { t } ; \theta _ { s } ( t - 1 ) , \theta _ { e } ( t - 1 ) ) } \\ & { \quad \mathbf a _ { t } = \pi ( \mathbf s _ { t } ; \theta ( t ) ) \mathrm { ~ w i t h ~ } \theta ( t ) = ( \theta _ { e } ( t ) , \theta _ { a } ) , } \end{array}
+$$
+
+where $\theta _ { s } ( 0 ) = \theta _ { s } , \theta _ { e } ( 0 ) = \theta _ { e }$ , $\mathbf { s } _ { 0 }$ is the initial condition given by the environment, $\mathbf { a } _ { 0 } = \pi _ { \theta } ( \mathbf { s } _ { 0 } )$ , $p$ is the unknown environment transition, and $L$ is the self-supervised objective as previously introduced.
+
+# 4 EXPERIMENTS
+
+In this work, we investigate how well an agent trained in one environment (denoted the training environment) generalizes to unseen and diverse test environments. During evaluation, agents have no access to reward signals and are expected to generalize without trials nor prior knowledge about the test environments. In simulation, we evaluate our method (PAD) and baselines extensively on continuous control tasks from DeepMind Control (DMControl) suite (Tassa et al., 2018) as well as the CRLMaze (Lomonaco et al., 2019) navigation task, and experiment with both stationary (colors, objects, textures, lighting) and non-stationary (videos) environment changes. We further show that PAD transfers from simulation to a real robot and successfully adapts to environmental differences during deployment in two robotic manipulation tasks. Samples from DMControl and CRLMaze environments are shown in Figure 2, and samples from the robot experiments are shown in Figure 4. Implementation is available at https://nicklashansen.github.io/PAD/.
+
+Network details. For DMControl and the robotic manipulation tasks we implement PAD on top of Soft Actor-Critic (SAC) (Haarnoja et al., 2018), and adopt both network architecture and hyperparameters from Yarats et al. (2019), with minor modifications: the feature extractor $\pi _ { e }$ has 8 convolutional layers shared between the RL head $\pi _ { a }$ and self-supervised head $\pi _ { s }$ , and we split the network into architecturally identical heads following $\pi _ { e }$ . Each head consists of 3 convolutional layers followed by 4 fully connected layers. For CRLMaze, we use Advantage Actor-Critic (A2C) as base algorithm (Mnih et al., 2016) and apply the same architecture as for the other experiments, but implement $\pi _ { e }$ with only 6 convolutional layers. Observations are stacks of $k$ colored frames $k = 3$ on DMControl and CRLMaze; $k = 1$ in robotic manipulation) of size $1 0 0 \times 1 0 0$ and time-consistent random crop is applied as in Srinivas et al. (2020). During deployment, we optimize the self-supervised objective online w.r.t. $\theta _ { e } , \theta _ { s }$ for one gradient step per time iteration. See appendix F for implementation details.
+
+![](images/bc62cee880a17c8b0b2832092fcc074bd1b01dcd8fb62086e20850e09ae21b15.jpg)  
+Figure 2. Left: Training environments of DMControl (top) and CRLMaze (bottom). Right: Test environments of DMControl (top) and CRLMaze (bottom). Changes to DMControl include randomized colors, video backgrounds, and distractors; changes to CRLMaze include textures and lighting.
+
+Table 1. Episodic return in test environments with randomized colors, mean and std. dev. for 10 seeds. Best method on each task is in bold and blue compares $\mathrm { S A C + I D M }$ with and without PAD.
+
+10x episode length   
+
+<table><tr><td>Random colors</td><td>SAC</td><td>+DR</td><td>+IDM</td><td>+IDM (PAD)</td><td>+IDM</td><td>+IDM (PAD)</td></tr><tr><td>Walker, walk</td><td>414±74</td><td>594±104</td><td>406±29</td><td>468±47</td><td>3830±547</td><td>5505±592</td></tr><tr><td>Walker, stand</td><td>719±74</td><td>715±96</td><td>743±37</td><td>797±46</td><td>7832±209</td><td>8566±121</td></tr><tr><td>Cartpole, swingup</td><td>592±50</td><td>647±48</td><td>585±73</td><td>630±63</td><td>6528±539</td><td>7093±592</td></tr><tr><td>Cartpole,balance</td><td>857±60</td><td>867±37</td><td>835±40</td><td>848±29</td><td>7746±526</td><td>7670±293</td></tr><tr><td>Ball in cup,catch</td><td>411±183</td><td>470±252</td><td>471±75</td><td>563±50</td><td></td><td></td></tr><tr><td>Finger, spin</td><td>626±163</td><td>465±314</td><td>757±62</td><td>803±72</td><td>7249±642</td><td>7496±655</td></tr><tr><td>Finger, turn_easy</td><td>270±43</td><td>167±26</td><td>283±51</td><td>304±46</td><td>1</td><td></td></tr><tr><td>Cheetah, run</td><td>154±41</td><td>145±29</td><td>121±38</td><td>159±28</td><td>1117±530</td><td>1208±487</td></tr><tr><td>Reacher, easy</td><td>163±45</td><td>105±37</td><td>201±32</td><td>214±44</td><td>1788±441</td><td>2152±506</td></tr></table>
+
+# 4.1 DEEPMIND CONTROL
+
+DeepMind Control (DMControl) (Tassa et al., 2018) is a collection of continuous control tasks where agents only observe raw pixels. Generalization benchmarks on DMControl represent diverse real-world tasks for motor control, and contain distracting surroundings not correlated with the reward signals.
+
+Experimental setup. We experiment with 9 tasks from DMControl and measure generalization to four types of test environments: (i) randomized colors; (ii) natural videos as background; (iii) distracting objects placed in the scene; and (iv) the unmodified training environment. For each test environment, we evaluate methods across 10 seeds and 100 random initializations. If a given test environment is not applicable to certain tasks, e.g. if a task has no background for the video background setting, they are excluded. Tasks are selected on the basis of diversity, as well as the success of vision-based RL in prior work (Yarats et al., 2019; Srinivas et al., 2020; Laskin et al., 2020; Kostrikov et al., 2020). We implement PAD on top of SAC and use an Inverse Dynamics Model (IDM) for self-supervision, as we find that learning a model of the dynamics works well for motor control. For completeness, we ablate the choice of self-supervision. Learning curves are provided in appendix B.
+
+![](images/1d57abcc32301ede5d2b8455a03059fd30b9cd73bdc63abef544626395d0fffc.jpg)  
+Figure 3. Relative improvement in instantaneous reward over time for PAD on the random color env.
+
+We compare our method to the following baselines: (i) SAC with no changes (denoted $S A C$ ); (ii) SAC trained with domain randomization on a fixed set of 100 colors (denoted $+ D R$ ); and (iii) SAC trained jointly with an IDM but without PAD (denoted $+ I D M )$ ). Our method using an IDM with PAD is denoted by $+ I D M \left( P A D \right)$ . For domain randomization, colors are sampled from the same distribution as in evaluation, but with lower variance, as we find that training directly on the test distribution does not converge.
+
+Random perturbation of color. Robustness to subtle changes such as color is essential to realworld deployment of RL policies. We evaluate generalization on a fixed set of 100 colors of foreground, background and the agent itself, and report the results in Table 1 (first 4 columns). We find PAD to improve generalization in all tasks considered, outperforming SAC trained with domain randomization in 6 out of 9 tasks. Surprisingly, despite a substantial overlap between training and test domains of domain randomization, it generalizes no better than vanilla SAC on a majority of tasks.
+
+Long-term stability. We find the relative improvement of PAD to improve over time, as shown in Figure 3. To examine the long-term stability of PAD, we further evaluate on $1 0 \mathrm { x }$ episode lengths and summarize the results in the last two columns in Table 1 (goal-oriented tasks excluded). While we do not explicitly prevent the embedding from drifting away from the RL task, we find empirically that PAD does not degrade the performance of the policy, even over long horizons, and when PAD does not improve, we find it to hurt minimally. We conjecture this is because we are not learning a new task, but simply continue to optimize the same (self-supervised) objective as during joint training, where both two tasks are compatible. In this setting, PAD still improves generalization in 6 out of 7 tasks, and thus naturally extends beyond episodic deployment. For completeness, we also evaluate methods in the environment in which they were trained, and report the results in appendix A. We find that, while PAD improves generalization to novel environments, performance is virtually unchanged on the training environment. We conjecture this is because the self-supervised task is already fully learned and any continued training on the same data distribution thus has little impact.
+
+Non-stationary environments. To investigate whether PAD can adapt in non-stationary environments, we evaluate generalization to diverse video backgrounds (refer to Figure 2). We find PAD to outperform all baselines on 7 out of 8 tasks, as shown in Table 2, by as much as $104 \%$ over domain randomization on Finger, spin. Domain randomization generalizes comparably worse to videos, which we conjecture is not because the environments are non-stationary, but rather because the image statistics of videos are not covered by its training domain of randomized colors. In fact, domain randomization is outperformed by the vanilla SAC in most tasks with video back
+
+Table 2. Episodic return in test environments with video backgrounds (top) and distracting objects (bottom), mean and std. dev. for 10 seeds. Best method on each task is in bold and blue compares $\mathrm { S A C + I D M }$ with and without PAD.   
+
+<table><tr><td>Video backgrounds</td><td>SAC</td><td>+DR</td><td>+IDM</td><td>+IDM (PAD)</td></tr><tr><td>Walker, walk</td><td>616±80</td><td>655±55</td><td>694±85</td><td>717±79</td></tr><tr><td>Walker, stand</td><td>899±53</td><td>869±60</td><td>902±51</td><td>935±20</td></tr><tr><td>Cartpole, swingup</td><td>375±90</td><td>485±67</td><td>487±90</td><td>521±76</td></tr><tr><td>Cartpole, balance</td><td>693±109</td><td>766±92</td><td>691±76</td><td>687±58</td></tr><tr><td>Ball in cup, catch</td><td>393±175</td><td>271±189</td><td>362±69</td><td>436±55</td></tr><tr><td>Finger, spin</td><td>447±102</td><td>338±207</td><td>605±61</td><td>691±80</td></tr><tr><td>Finger, turn_easy</td><td>355±108</td><td>223±91</td><td>355±110</td><td>362±101</td></tr><tr><td>Cheetah, run</td><td>194±30</td><td>150±34</td><td>164±42</td><td>206±34</td></tr><tr><td>Distracting objects</td><td>SAC</td><td>+DR</td><td>+IDM</td><td>+IDM (PAD)</td></tr><tr><td>Cartpole, swingup</td><td>815±60</td><td>809±24</td><td>776±58</td><td>771±64</td></tr><tr><td>Cartpole,balance</td><td>969±20</td><td>938±35</td><td>964±26</td><td>960±29</td></tr><tr><td>Ball in cup, catch</td><td>177±111</td><td>331±189</td><td>482±128</td><td>545±173</td></tr><tr><td>Finger, spin</td><td>652±184</td><td>564±288</td><td>836±62</td><td>867±72</td></tr><tr><td>Finger, turn_easy</td><td>302±68</td><td>165±12</td><td>326±101</td><td>347±48</td></tr></table>
+
+grounds, which is in line with the findings of Packer et al. (2018).
+
+Scene content. We hypothesize that: (i) an agent trained with an IDM is comparably less distracted by scene content since objects uncorrelated to actions yield no predictive power; and (ii) that PAD can adapt to unexpected objects in the scene. We test these hypotheses by measuring robustness to colored shapes at a variety of positions in both the foreground and background of the scene (no physical interaction). Results are summarized in Table 2. PAD outperforms all baselines in 3 out of 5 tasks, with a relative improvement of $20 \%$ over SAC on Ball in cup, catch. In the two cartpole tasks in which PAD does not improve, all methods are already relatively unaffected by the distractors.
+
+Choice of self-supervised task. We investigate how much the choice of self-supervised task contributes to the overall success of our method, and consider the following ablations: (i) replacing inverse dynamics with the rotation prediction task described in Section 3.2; and (ii) replacing it with the recently proposed CURL (Srinivas et al., 2020) contrastive learning algorithm for RL. As shown in Table 3, PAD improves generalization of CURL in a majority of tasks on the randomized color benchmark, and in 4 out of 9 tasks using rotation prediction. However, inverse dynamics as auxiliary task produces more consistent results and offers better generalization overall. We argue that learning an IDM produces better representations for motor control since it connects observations directly to actions, whereas CURL and rotation prediction operates purely on observations. In general, we find the improvement of PAD to be bigger in tasks that benefit significantly from visual information (see appendix A), and conjecture that selecting a self-supervised task that learns features useful to the RL task is crucial to the success of PAD, which we discuss further in Section 4.2.
+
+Table 3. Ablations on the randomized color domain of DMC. All methods use SAC. CURL represents RL with a contrastive learning task (Srinivas et al., 2020) and Rot represents the rotation prediction (Gidaris et al., 2018). Offline PAD is here denoted O-PAD for brevity, whereas the default usage of PAD is in an online setting. Best method is in bold and blue compares $+ \mathrm { I D M }$ w/ and w/o PAD.   
+
+<table><tr><td>Random colors</td><td>CURL</td><td>CURL (PAD)</td><td>Rot</td><td>Rot (PAD)</td><td>IDM</td><td>IDM (O-PAD)</td><td>IDM (PAD)</td></tr><tr><td>Walker, walk</td><td>445±99</td><td>495±70</td><td>335±7</td><td>330±30</td><td>406±29</td><td>441±16</td><td>468±47</td></tr><tr><td>Walker, stand</td><td>662±54</td><td>753±49</td><td>673±4</td><td>653±27</td><td>743±37</td><td>727±21</td><td>797±46</td></tr><tr><td>Cartpole, swingup</td><td>454±110</td><td>413±67</td><td>493±52</td><td>477±38</td><td>585±73</td><td>578±69</td><td>630±63</td></tr><tr><td>Cartpole,balance</td><td>782±13</td><td>763±5</td><td>710±72</td><td>734±81</td><td>835±40</td><td>796±37</td><td>848±29</td></tr><tr><td>Ball in cup, catch</td><td>231±92</td><td>332±78</td><td>291±54</td><td>314±60</td><td>471±75</td><td>490±16</td><td>563±50</td></tr><tr><td>Finger, spin</td><td>691±12</td><td>588±22</td><td>695±36</td><td>689±20</td><td>757±62</td><td>767±43</td><td>803±72</td></tr><tr><td>Finger, turn_easy</td><td>202±32</td><td>186±2</td><td>283±68</td><td>230±53</td><td>283±51</td><td>321±10</td><td>304±46</td></tr><tr><td>Cheetah, run</td><td>202±22</td><td>211±20</td><td>127±3</td><td>135±12</td><td>121±38</td><td>112±35</td><td>159±28</td></tr><tr><td>Reacher, easy</td><td>325±32</td><td>378±62</td><td>99±29</td><td>120±7</td><td>201±32</td><td>241±24</td><td>214±44</td></tr></table>
+
+Table 4. Episodic return of PAD and baselines in CRLMaze environments. PAD improves generalization in all considered environments and outperforms both A2C and domain randomization by a large margin. All methods use A2C. We report mean and std. error of 10 seeds. Best method in each environment is in bold and blue compares rotation prediction with and without PAD.   
+
+<table><tr><td>CRLMaze</td><td>Random</td><td>A2C</td><td>+DR</td><td>+IDM</td><td>+IDM (PAD)</td><td>+Rot</td><td>+Rot (PAD)</td></tr><tr><td>Walls</td><td>-870±30</td><td>-380±145</td><td>-260±137</td><td>-302±150</td><td>-428±135</td><td>-206±166</td><td>-74±116</td></tr><tr><td>Floor</td><td>-868±23</td><td>-320±167</td><td>-438±59</td><td>-47±198</td><td>-530±106</td><td>-294±123</td><td>-209±94</td></tr><tr><td>Ceiling</td><td>-872±30</td><td>-171±175</td><td>-400±74</td><td>166±215</td><td>-508±104</td><td>128±196</td><td>281±83</td></tr><tr><td>Lights</td><td>-900±29</td><td>-30±213</td><td>-310±106</td><td>239±270</td><td>-460±114</td><td>-84±53</td><td>312±104</td></tr></table>
+
+Offline versus online learning. Observations that arrive sequentially are highly correlated, and we thus hypothesize that our method benefits significantly from learning online. To test this hypothesis, we run an offline variant of our method in which network updates are forgotten after each step. In this setting, our method can only adapt to single observations and does not benefit from learning over time. Results are shown in Table 3. We find that our method benefits substantially from online learning, but learning offline still improves generalization on select tasks.
+
+# 4.2 CRLMAZE
+
+CRLMaze (Lomonaco et al., 2019) is a time-constrained, discrete-action 3D navigation task for ViZDoom (Wydmuch et al., 2018), in which an agent is to navigate a maze and collect objects. There is a positive reward associated with green columns, and a negative reward for lanterns as well as for living. Readers are referred to the respective papers for details on the task and environment.
+
+Experimental setup. We train agents on a single environment and measure generalization to environments with novel textures for walls, floor, and ceiling, as well as lighting, as shown in Figure 2. We implement PAD on top of A2C (Mnih et al., 2016) and use rotation prediction (see Section 3.2) as self-supervised task. Learning to navigate novel scenes requires a generalized scene understanding, and we find that rotation prediction facilitates that more so than an IDM. We compare to the following baselines: (i) a random agent (denoted Random); (ii) A2C with no changes (denoted $A 2 C$ ); (iii) A2C trained with domain randomization (denoted $+ D R$ ); (iv) A2C with an IDM as auxiliary task (denoted $+ I D M )$ ; and (v) A2C with rotation prediction as auxiliary task (denoted $+ R o t )$ . We denote Rot with PAD as $+ R o t \ ( P A D )$ . Domain randomization uses 56 combinations of diverse textures, partially overlapping with the test distribution, and we find it necessary to train domain randomization for twice as many episodes in order to converge. We closely follow the evaluation procedure of (Lomonaco et al., 2019) and evaluate methods across 20 starting positions and 10 random seeds.
+
+Results. We report performance on the CRLMaze environments in Table 4. PAD improves generalization in all considered test environments, outperforming both A2C and domain randomization by a large margin. Domain randomization performs consistently across all environments but is less successful overall. We further examine the importance of selecting appropriate auxiliary tasks by a simple ablation: replacing rotation prediction with an IDM for the navigation task. We conjecture that, while an auxiliary task can enforce structure in the learned representations, its features (and consequently gradients) need to be sufficiently correlated with the primary RL task for PAD to be
+
+![](images/7a75facacf5c2ac9f0591865730aa213a149b2aae09f6d5a1610fc3b0f899d74.jpg)  
+(a) Simulation. (b) Default transfer. (c) Table cloth. (d) Disco lights.
+
+Figure 4. Samples from the push robotic manipulation task. The task is to push the yellow cube to the location of the red disc. Agents are trained in setting (a) and evaluated in settings (b-d).
+
+successful during deployment. While PAD with rotation prediction improves generalization across all test environments considered, IDM does not, which suggests that rotation prediction is more suitable for tasks that require scene understanding, whereas IDM is useful for tasks that require motor control. We leave it to future work to automate the process of selecting appropriate auxiliary tasks.
+
+# 4.3 ROBOTIC MANIPULATION TASKS
+
+We deploy our method and baselines on a real Kinova Gen3 robot and evaluate on two manipulation tasks: (i) reach, a task in which the robot reaches for a goal marked by a red disc; and (ii) push, a task in which the robot pushes a cube to the location of the red disc. Both tasks use an XY action space, where the Z position of the actuator is fixed. Agents operate purely from pixel observations with no access to state information. During deployment, we make no effort to calibrate camera, lighting, or
+
+Table 5. Success rate of PAD and baselines on a real robotic arm. Best method in each environment is in bold and blue compares $+ \mathrm { I D M }$ with and without PAD.   
+
+<table><tr><td>Real robot</td><td>SAC</td><td>+DR</td><td>+IDM</td><td>+IDM (PAD)</td></tr><tr><td>Reach (default)</td><td>100%</td><td>100%</td><td>100%</td><td>100%</td></tr><tr><td>Reach (cloth)</td><td>48%</td><td>80%</td><td>56%</td><td>80%</td></tr><tr><td>Reach (disco)</td><td>72%</td><td>76%</td><td>88%</td><td>92%</td></tr><tr><td>Push (default)</td><td>88%</td><td>88%</td><td>92%</td><td>100%</td></tr><tr><td>Push (cloth)</td><td>60%</td><td>64%</td><td>64%</td><td>88%</td></tr><tr><td>Push (disco)</td><td>60%</td><td>68%</td><td>72%</td><td>84%</td></tr></table>
+
+physical properties such as dimensions, mass, and friction, and policies are expected to generalize with no prior knowledge of the test environment. Samples from the push task are shown in Figure 4, and samples from reach are shown in appendix E.
+
+Experimental setup. We implement PAD on top of SAC (Haarnoja et al., 2018) and apply the same experimental setup as in Section 4.1 using an Inverse Dynamics Model (IDM) for self-supervision, but without frame-stacking (i.e. $k = 1$ ). Agents are trained in simulation with dense rewards and randomized initial configurations of arm, goal, and box, and we measure generalization to 3 novel environments in the real-world: (i) default environment with pixel observations that roughly mimic the simulation; (ii) a patterned table cloth that
+
+Table 6. Success rate of PAD and baselines for the push task on a simulated robotic arm in test environments with changes to dynamics. Changes include object mass, size, and friction, arm mount position, and end effector velocity. Best method in each environment is in bold and blue compares $+ \mathrm { I D M }$ with and without PAD.
+
+<table><tr><td>Simulated robot</td><td>SAC</td><td>+DR</td><td>+IDM</td><td>+IDM (PAD)</td></tr><tr><td>Push (object)</td><td>66%</td><td>64%</td><td>72%</td><td>82%</td></tr><tr><td>Push (mount)</td><td>68%</td><td>58%</td><td>86%</td><td>84%</td></tr><tr><td>Push (velocity)</td><td>70%</td><td>68%</td><td>70%</td><td>78%</td></tr><tr><td>Push (all)</td><td>56%</td><td>50%</td><td>48%</td><td>76%</td></tr></table>
+
+distracts visually and greatly increases friction; and (iii) disco, an environment with non-stationary visual disco light distractions. Notably, all 3 environments also feature subtle differences in dynamics compared to the training environment, such as object dimensions, mass, friction, and uncalibrated actions. In each setting, we evaluate the success rate across 25 test runs spanning across 5 pre-defined goal locations throughout the table. The goal locations vary between the two tasks, and the robot is reset after each run. We perform comparison against direct transfer and domain randomization baselines as in Section 4.1. We further evaluate generalization to changes in dynamics by considering a variant of the simulated environment in which object mass, size, and friction, arm mount position, and end effector velocity is modified. We consider each setting both individually and jointly, and evaluate success rate across 50 unique configurations with the robot reset after each run.
+
+Results. We report transfer results in Table 5. While all methods transfer successfully to reach (default), we observe PAD to improve generalization in all settings in which the baselines show sub-optimal performance. We find PAD to be especially powerful for the push task that involves dynamics, improving by as much as $24 \%$ in push (cloth). While domain randomization proves highly effective in reach (cloth), we observe no significant benefit in the other settings, which suggests that PAD can be more suitable in challenging tasks like push. To isolate the effect of dynamics, we further evaluate generalization to a number of simulated changes in dynamics on the push task. Results are shown in Table 6. We find PAD to improve generalization to changes in the physical properties of the object and end effector, whereas both $S A C { + } I D M$ and PAD are relatively unaffected by changes to the mount position. Consistent with the real robot results in Section 5, PAD is found to be most effective when changes in dynamics are non-trivial, improving by as much as $28 \%$ in the push (all) setting, where all 3 environmental changes are considered jointly. These results suggest that PAD can be a simple, yet effective method for generalization to diverse, unseen environments that vary in both visuals and dynamics.
+
+# 5 CONCLUSION
+
+While previous work addresses generalization in RL by learning policies that are invariant to any environment changes that can be anticipated, we formulate an alternative problem setting in visionbased RL: can we instead adapt a pretrained-policy to new environments without any reward. We propose Policy Adaptation during Deployment, a self-supervised framework for online adaptation at test-time, and show empirically that our method improves generalization of policies to diverse simulated and real-world environmental changes across a variety of tasks. We find our approach benefits greatly from learning online, and we systematically evaluate how the choice of self-supervised task impacts performance. While the current framework relies on prior knowledge on selecting selfsupervised tasks for policy adaptation, we see our work as the initial step in addressing the problem of adapting vision-based policies to unknown environments. We ultimately envision embodied agents in the future to be learning all the time, with the flexibility to learn both with and without rewards, before and during deployment.
+
+Acknowledgements. This work was supported, in part, by grants from DARPA, NSF 1730158 CI-New: Cognitive Hardware and Software Ecosystem Community Infrastructure (CHASE-CI), NSF ACI-1541349 CC\*DNI Pacific Research Platform, and gifts from Qualcomm and TuSimple. This work was also funded, in part, by grants from Berkeley DeepDrive, SAP and European Research Council (ERC) from the European Union Horizon 2020 Programme under grant agreement no. 741930 (CLOTHILDE). We would like to thank Fenglu Hong and Joey Hejna for helpful discussions.
+
+# REFERENCES
+
+OpenAI: Marcin Andrychowicz, Bowen Baker, Maciek Chociej, Rafal Jozefowicz, Bob McGrew, Jakub Pachocki, Arthur Petron, Matthias Plappert, Glenn Powell, Alex Ray, et al. Learning dexterous in-hand manipulation. The International Journal of Robotics Research, 39(1):3–20, 2020. 1   
+David Bau, Hendrik Strobelt, William Peebles, Jonas Wulff, Bolei Zhou, Jun-Yan Zhu, and Antonio Torralba. Semantic photo manipulation with a generative image prior. ACM Trans. Graph., 38(4), 2019. ISSN 0730-0301. 3   
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations, 2020. 2   
+Carl Doersch and Andrew Zisserman. Multi-task self-supervised visual learning. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2051–2060, 2017. 4   
+Carl Doersch, Abhinav Gupta, and Alexei A Efros. Unsupervised visual representation learning by context prediction. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1422–1430, 2015. 2   
+Frederik Ebert, Chelsea Finn, Sudeep Dasari, Annie Xie, Alex Lee, and Sergey Levine. Visual foresight: Model-based deep reinforcement learning for vision-based robotic control, 2018. 2
+
+Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, Franc¸ois Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. The Journal of Machine Learning Research, 17(1):2096–2030, 2016. 2
+
+Robert Geirhos, Carlos R. Medina Temme, Jonas Rauber, Heiko H. Schutt, Matthias Bethge, and ¨ Felix A. Wichmann. Generalisation in humans and deep neural networks. In NeurIPS, 2018. 2
+
+Muhammad Ghifary, W. Bastiaan Kleijn, Mengjie Zhang, and David Balduzzi. Domain generalization for object recognition with multi-task autoencoders. In Proceedings of the 2015 IEEE International Conference on Computer Vision (ICCV), ICCV ’15, pp. 2551–2559. IEEE Computer Society, 2015. ISBN 9781467383912. 2
+
+Spyros Gidaris, Praveer Singh, and Nikos Komodakis. Unsupervised representation learning by predicting image rotations, 2018. 2, 3, 4, 7
+
+Boqing Gong, Yuan Shi, Fei Sha, and Kristen Grauman. Geodesic flow kernel for unsupervised domain adaptation. In 2012 IEEE Conference on Computer Vision and Pattern Recognition, pp. 2066–2073. IEEE, 2012. 2
+
+Shixiang Gu, Ethan Holly, Timothy Lillicrap, and Sergey Levine. Deep reinforcement learning for robotic manipulation with asynchronous off-policy updates. In 2017 IEEE international conference on robotics and automation (ICRA), pp. 3389–3396. IEEE, 2017. 1
+
+David Ha and Jurgen Schmidhuber. Recurrent world models facilitate policy evolution. In ¨ Advances in Neural Information Processing Systems 31, pp. 2451–2463. Curran Associates, Inc., 2018. 2
+
+Tuomas Haarnoja, Aurick Zhou, Kristian Hartikainen, George Tucker, Sehoon Ha, Jie Tan, Vikash Kumar, Henry Zhu, Abhishek Gupta, Pieter Abbeel, and Sergey Levine. Soft actor-critic algorithms and applications, 2018. 4, 8, 17
+
+Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2020. 2
+
+Dan Hendrycks and Thomas G. Dietterich. Benchmarking neural network robustness to common corruptions and surface variations. arXiv: Learning, 2018. 2
+
+Dan Hendrycks, Mantas Mazeika, Saurav Kadavath, and Dawn Song. Using self-supervised learning can improve model robustness and uncertainty. ArXiv, abs/1906.12340, 2019. 2, 4
+
+Olivier J. Henaff, Aravind Srinivas, Jeffrey De Fauw, Ali Razavi, Carl Doersch, S. M. Ali Eslami, and ´ Aaron van den Oord. Data-efficient image recognition with contrastive predictive coding, 2019. 2
+
+Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks, 2016. 2
+
+Stephen James, Paul Wohlhart, Mrinal Kalakrishnan, D. Kalashnikov, A. Irpan, J. Ibarz, S. Levine, Raia Hadsell, and Konstantinos Bousmalis. Sim-to-real via sim-to-sim: Data-efficient robotic grasping via randomized-to-canonical adaptation networks. 2019 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 12619–12629, 2019. 2
+
+R. Julian, B. Swanson, G. Sukhatme, Sergey Levine, Chelsea Finn, and Karol Hausman. Never stop learning: The effectiveness of fine-tuning in robotic reinforcement learning. arXiv: Learning, 2020. 1, 2, 15
+
+D. Kalashnikov, A. Irpan, P. Pastor, J. Ibarz, A. Herzog, Eric Jang, Deirdre Quillen, Ethan Holly, Mrinal Kalakrishnan, V. Vanhoucke, and S. Levine. Qt-opt: Scalable deep reinforcement learning for vision-based robotic manipulation. ArXiv, abs/1806.10293, 2018. 1
+
+Ilya Kostrikov, Denis Yarats, and Rob Fergus. Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. 2020. 5, 17
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012. 17
+
+Sascha Lange and Martin A. Riedmiller. Deep auto-encoder neural networks in reinforcement learning. In The 2010 International Joint Conference on Neural Networks (IJCNN), pp. 1–8, 2010. 2
+
+Michael Laskin, Kimin Lee, Adam Stooke, Lerrel Pinto, Pieter Abbeel, and Aravind Srinivas. Reinforcement learning with augmented data. arXiv preprint arXiv:2004.14990, 2020. 2, 5, 17
+
+Kimin Lee, Kibok Lee, Jinwoo Shin, and Honglak Lee. A simple randomization technique for generalization in deep reinforcement learning. ArXiv, abs/1910.05396, 2019. 1
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. The Journal of Machine Learning Research, 17(1):1334–1373, 2016.
+
+Ya Feng Li, Mingming Gong, Xinmei Tian, Tongliang Liu, and Dacheng Tao. Domain generalization via conditional invariant representations. In AAAI, 2018. 2
+
+Vincenzo Lomonaco, Karen Desai, Eugenio Culurciello, and Davide Maltoni. Continual reinforcement learning in 3d non-stationary environments. arXiv preprint arXiv:1905.10112, 2019. 2, 4, 7, 16, 17
+
+Mingsheng Long, Han Zhu, Jianmin Wang, and Michael I Jordan. Unsupervised domain adaptation with residual transfer networks. In Advances in Neural Information Processing Systems, pp. 136–144, 2016. 2
+
+Toshihiko Matsuura and Tatsuya Harada. Domain generalization using a mixture of multiple latent domains, 2019. 2
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013. 1
+
+Volodymyr Mnih, Adria Puigdom \` enech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim \` Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning, 2016. 4, 7, 17
+
+Ravi Teja Mullapudi, Steven Chen, Keyi Zhang, Deva Ramanan, and Kayvon Fatahalian. Online model distillation for efficient video inference. 2019 IEEE/CVF International Conference on Computer Vision (ICCV), Oct 2019. doi: 10.1109/iccv.2019.00367. 3
+
+Ashvin V Nair, Vitchyr Pong, Murtaza Dalal, Shikhar Bahl, Steven Lin, and Sergey Levine. Visual reinforcement learning with imagined goals. In Advances in Neural Information Processing Systems, pp. 9191–9200, 2018. 1
+
+Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In European Conference on Computer Vision, pp. 69–84. Springer, 2016. 2
+
+Charles Packer, Katelyn Gao, Jernej Kos, Philipp Krahenb ¨ uhl, Vladlen Koltun, and Dawn Song. ¨ Assessing generalization in deep reinforcement learning, 2018. 6
+
+Deepak Pathak, Philipp Krahenbuhl, Jeff Donahue, Trevor Darrell, and Alexei A Efros. Context encoders: Feature learning by inpainting. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2536–2544, 2016. 2
+
+Deepak Pathak, Pulkit Agrawal, Alexei A. Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In ICML, 2017. 2
+
+Xue Bin Peng, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Sim-to-real transfer of robotic control with dynamics randomization. 2018 IEEE International Conference on Robotics and Automation (ICRA), May 2018. 1, 2
+
+Lerrel Pinto and Abhinav Gupta. Supersizing self-supervision: Learning to grasp from 50k tries and 700 robot hours. In 2016 IEEE international conference on robotics and automation (ICRA), pp. 3406–3413. IEEE, 2016. 1
+
+Lerrel Pinto, Marcin Andrychowicz, Peter Welinder, Wojciech Zaremba, and Pieter Abbeel. Asymmetric actor critic for image-based robot learning. arXiv preprint arXiv:1710.06542, 2017a. 1, 2
+
+Lerrel Pinto, James Davidson, Rahul Sukthankar, and Abhinav Gupta. Robust adversarial reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2817–2826. JMLR. org, 2017b. 1
+
+Aravind Rajeswaran, Sarvjeet Ghotra, Balaraman Ravindran, and Sergey Levine. Epopt: Learning robust neural network policies using model ensembles. arXiv preprint arXiv:1610.01283, 2016. 1
+
+Fabio Ramos, Rafael Possas, and Dieter Fox. Bayessim: Adaptive domain randomization via probabilistic inference for robotics simulators. Robotics: Science and Systems XV, Jun 2019. 2
+
+Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do cifar-10 classifiers generalize to cifar-10? arXiv preprint arXiv:1806.00451, 2018. 2
+
+Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do imagenet classifiers generalize to imagenet? arXiv preprint arXiv:1902.10811, 2019. 2
+
+Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016. 1
+
+Fereshteh Sadeghi and Sergey Levine. Cad2rl: Real single-image flight without a single real image. arXiv preprint arXiv:1611.04201, 2016. 1, 2
+
+Ramanan Sekar, Oleh Rybkin, Kostas Daniilidis, Pieter Abbeel, Danijar Hafner, and Deepak Pathak. Planning to explore via self-supervised world models, 2020. 2
+
+Vaishaal Shankar, Achal Dave, Rebecca Roelofs, Deva Ramanan, Benjamin Recht, and Ludwig Schmidt. A systematic framework for natural perturbations from videos. arXiv preprint arXiv:1906.02168, 2019. 2
+
+Assaf Shocher, Nadav Cohen, and Michal Irani. Zero-shot super-resolution using deep internal learning, 2017. 3
+
+Assaf Shocher, Shai Bagon, Phillip Isola, and Michal Irani. Ingan: Capturing and remapping the ”dna” of a natural image, 2018. 3
+
+Aravind Srinivas, Michael Laskin, and Pieter Abbeel. Curl: Contrastive unsupervised representations for reinforcement learning. arXiv preprint arXiv:2004.04136, 2020. 2, 4, 5, 6, 7, 17
+
+Yu Sun, Eric Tzeng, Trevor Darrell, and Alexei A Efros. Unsupervised domain adaptation through self-supervision. arXiv preprint, 2019. 2
+
+Yu Sun, Xiaolong Wang, Zhuang Liu, John Miller, Alexei A. Efros, and Moritz Hardt. Test-time training with self-supervision for generalization under distribution shifts. ICML, 2020. 3
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1–9, 2015. 17
+
+Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, Timothy Lillicrap, and Martin Riedmiller. DeepMind control suite. Technical report, DeepMind, January 2018. 2, 4, 5, 16, 17
+
+Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. 2017 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), Sep 2017. 1, 2
+
+Eric Tzeng, Judy Hoffman, Kate Saenko, and Trevor Darrell. Adversarial discriminative domain adaptation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 7167–7176, 2017. 2
+
+Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In Proceedings of the 25th international conference on Machine learning, pp. 1096–1103. ACM, 2008. 2
+
+Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In ICCV, 2015. 2
+
+Xiaolong Wang, Allan Jabri, and Alexei A. Efros. Learning correspondence from the cycleconsistency of time. In CVPR, 2019. 2
+
+Mitchell Wortsman, Kiana Ehsani, Mohammad Rastegari, Ali Farhadi, and Roozbeh Mottaghi. Learning to learn how to learn: Self-adaptive visual navigation using meta-learning, 2018. 3
+
+Zhirong Wu, Yuanjun Xiong, Stella X Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance discrimination. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3733–3742, 2018. 2
+
+Marek Wydmuch, Michał Kempka, and Wojciech Jaskowski. Vizdoom competitions: Playing doom ´ from pixels. IEEE Transactions on Games, 2018. 2, 7, 16
+
+Wilson Yan, Ashwin Vangipuram, Pieter Abbeel, and Lerrel Pinto. Learning predictive representations for deformable objects using contrastive estimation. arXiv preprint arXiv:2003.05436, 2020. 1, 2
+
+Jiachen Yang, Brenden Petersen, Hongyuan Zha, and Daniel Faissol. Single episode policy transfer in reinforcement learning, 2019. 1, 2
+
+Denis Yarats, Amy Zhang, Ilya Kostrikov, Brandon Amos, Joelle Pineau, and Rob Fergus. Improving sample efficiency in model-free reinforcement learning from images, 2019. 2, 4, 5, 17
+
+Richard Zhang, Phillip Isola, and Alexei A Efros. Colorful image colorization. In European conference on computer vision, pp. 649–666. Springer, 2016. 2
+
+Richard Zhang, Phillip Isola, and Alexei A Efros. Split-brain autoencoders: Unsupervised learning by cross-channel prediction. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1058–1067, 2017. 2
+
+# A PERFORMANCE ON THE TRAINING ENVIRONMENT
+
+Historically, agents have commonly been trained and evaluated in the same environment when benchmarking RL algorithms exclusively in simulation. Although such an evaluation procedure does not consider generalization, it is still a useful metric for comparison of sample efficiency and stability of algorithms. For completeness, we also evaluate our method and baselines in this setting on both DMControl and CRLMaze. DMControl results are reported in Table 7 and results on the CRLMaze environment are shown in Table 8. In this setting, we also compare to an additional baseline on DMControl: a blind SAC agent that operates purely on its previous actions. The performance of a blind agent indicates to which degree a given task benefits from visual information. We find that, while PAD improves generalization to novel environments, performance is virtually unchanged when evaluated on the same environment as in training. We conjecture that this is because the algorithm already is adapted to the training environment and any continued training on the same data distribution thus has little influence. We further emphasize that, even when evaluated on the training environment, PAD still outperforms baselines on most tasks. For example, we observe a $15 \%$ relative improvement over SAC on the Finger, spin task. We hypothesize that this gain in performance is because the selfsupervised objective improves learning by constraining the intermediate representation of policies. A blind agent is no better than random on this particular task, which would suggest that agents benefit substantially from visual information in Finger, spin. Therefore, learning a good intermediate representation of that information is highly beneficial to the RL objective, which we find PAD to facilitate through its self-supervised learning framework. Likewise, the SAC baseline only achieves a $51 \%$ improvement over the blind agent on Cartpole, balance, which indicates that extracting visual information from observations is not as crucial on this task. Consequently, both PAD and baselines achieve similar performance on this task.
+
+Table 7. Episodic return on the training environment for each of the 9 tasks considered in DMControl, mean and std. dev. for 10 seeds. Best method on each task is in bold and blue compares $+ \mathrm { I D M }$ with and without PAD. It is shown that PAD hurts minimally when the environment is unchanged.   
+
+<table><tr><td>Training env.</td><td>Blind</td><td>SAC</td><td>+DR</td><td>+IDM</td><td>+IDM (PAD)</td></tr><tr><td>Walker, walk</td><td>235±17</td><td>847±71</td><td>756±71</td><td>911±24</td><td>895±28</td></tr><tr><td>Walker, stand</td><td>388±10</td><td>959±11</td><td>928±36</td><td>966±8</td><td>956±20</td></tr><tr><td>Cartpole, swingup</td><td>132±41</td><td>850±28</td><td>807±36</td><td>849±30</td><td>845±34</td></tr><tr><td>Cartpole,balance</td><td>646±131</td><td>978±22</td><td>971±30</td><td>982±20</td><td>979±21</td></tr><tr><td>Ball in cup, catch</td><td>150±96</td><td>725±355</td><td>469±339</td><td>919±118</td><td>910±129</td></tr><tr><td>Finger, spin</td><td>3±2</td><td>809±138</td><td>686±295</td><td>928±45</td><td>927±45</td></tr><tr><td>Finger, turn_easy</td><td>172±27</td><td>462±146</td><td>243±124</td><td>462±152</td><td>455±160</td></tr><tr><td>Cheetah, run</td><td>264±75</td><td>387±74</td><td>195±46</td><td>384±88</td><td>380±91</td></tr><tr><td>Reacher, easy</td><td>107±11</td><td>264±113</td><td>92±45</td><td>390±126</td><td>365±114</td></tr></table>
+
+Table 8. Episodic return of PAD and baselines in the CRLMaze training environment. All methods use A2C. We report mean and std. error of 10 seeds. Best method is in bold and blue compares rotation prediction with and without PAD.   
+
+<table><tr><td>CRLMaze</td><td>Random</td><td>A2C</td><td>+DR</td><td>+IDM</td><td>+IDM (PAD)</td><td>+Rot</td><td>+Rot (PAD)</td></tr><tr><td>Training env.</td><td>-868±34</td><td>371±198</td><td>-355±93</td><td>585±246</td><td>-416±135</td><td>729±148</td><td>681±99</td></tr></table>
+
+# B LEARNING CURVES ON DEEPMIND CONTROL
+
+All methods are trained until convergence (500,000 frames) on DMControl. While we do not consider the sample efficiency of our method and baselines in this study, we report learning curves for SAC, $\mathrm { S A C + I D M }$ and SAC trained with domain randomization on three tasks in Figure 5 for completeness. SAC trained with and without an IDM are similar in terms of sample efficiency and final performance, whereas domain randomization consistently displays worse sample efficiency, larger variation between seeds, and converges to sub-optimal performance in two out of the three tasks shown.
+
+![](images/9988caa8b9a55fc3afee7ef0f724429fd455ed6f365e57a9ccd860a250478099.jpg)  
+Figure 5. Learning curves for SAC, SAC trained with domain randomization (denoted $S A C ( D R )$ here), and $\mathrm { S A C + I D M }$ on three tasks from the DeepMind Control suite (DMControl). Episodic return is averaged across 10 seeds and the $9 5 \%$ confidence intervals are visualized as shaded regions. SAC and $\mathrm { S A C + I D M }$ exhibit similar sample efficiency and final performance, whereas domain randomization consistently displays worse sample efficiency, larger variation between seeds, and converges to sub-optimal performance in two out of the three tasks shown.
+
+# C KEEPING $\pi _ { s }$ FIXED DURING POLICY ADAPTATION
+
+We now consider a variant of PAD where the self-supervised task head $\pi _ { s }$ is fixed at test-time such that the self-supervised objective $L$ is optimized only wrt $\pi _ { e }$ , as discussed in Section 3.3. We measure generalization to test environments with randomized colors and report the results in Table 9 for three tasks from the DeepMind Control suite. We empirically find the difference between updating $\pi _ { s }$ and keeping it fixed negligible, and we choose to update $\pi _ { s }$ by default since its gradients are computed by back-propagation regardless.
+
+Table 9. Episodic return in test environments with randomized colors, mean and std. dev. for 10 seeds. All methods use SAC. IDM (PAD, fixed $\pi _ { s . }$ ) considers a variant of PAD where $\pi _ { s }$ is fixed at test-time, whereas $I D M \left( P A D \right)$ denotes the default usage of PAD in which both $\pi _ { e }$ and $\pi _ { s }$ are optimized at test-time using the self-supervised objective.   
+
+<table><tr><td>Random colors</td><td>IDM</td><td>IDM (PAD, fixed π s)</td><td>IDM (PAD)</td></tr><tr><td>Walker, walk</td><td>406±29</td><td>452±38</td><td>468±47</td></tr><tr><td>Walker, stand</td><td>743±37</td><td>802±41</td><td>797±46</td></tr><tr><td>Cartpole, swingup</td><td>585±73</td><td>623±57</td><td>630±63</td></tr></table>
+
+# D COMPARISON TO ADAPTATION WITH REWARDS
+
+While our method does not require data collected prior to deployment and does not assume access to a reward signal, we additionally compare our method to a na¨ıve fine-tuning approach using transitions and rewards collected from the target environment prior to deployment. To fine-tune the pre-trained policy using rewards, we collect datasets consisting of 1, 10, and 100 episodes in each target environment using the learned policy while keeping its parameters fixed, and then subsequently fine-tune both $\pi _ { e }$ and $\pi _ { a }$ on the collected data, following the same training procedure as during the training phase. This fine-tuning approach is analogous to Julian et al. (2020) but does not use data from the original environment during adaptation. Results are shown in Table 10. We find that na¨ıvely fine-tuning the policy using data collected prior to deployment can improve generalization but requires comparably more data than PAD, as well as access to a reward signal in the target environment. This finding suggests that PAD may be a more suitable method for settings where data from the target environment is scarce and not easily accessible prior to deployment.
+
+# E ADDITIONAL ROBOTIC MANIPULATION SAMPLES
+
+Figure 6 provides samples from the training and test environments for the reach robotic manipulation task. Agents are trained in simulation and deployed on a real robot. Samples from the push task are shown in Figure 4.
+
+Table 10. Episodic return in test environments with randomized colors, mean and std. dev. for 10 seeds. All methods use SAC trained with an inverse dynamics model (IDM) as auxiliary task. Our method is denoted IDM (PAD), and we compare to a na¨ıve fine-tuning approach that assumes access to transitions and rewards collected from 1, 10, and 100 episodes, respectively, from target environments prior to deployment.
+
+Fine-tuning w/ rewards   
+
+<table><tr><td>Random colors</td><td>IDM</td><td>IDM (PAD)</td><td>1 episode</td><td>10 episodes</td><td>100 episodes</td></tr><tr><td>Walker, walk</td><td>406±29</td><td>468±47</td><td>395±78</td><td>489±104</td><td>561±62</td></tr><tr><td>Walker, stand</td><td>743±37</td><td>797±46</td><td>661±65</td><td>728±44</td><td>784±31</td></tr><tr><td>Cartpole, swingup</td><td>585±73</td><td>630±63</td><td>538±53</td><td>605±51</td><td>650±58</td></tr></table>
+
+![](images/bb8251dc060f2862ca990a7216bf7fd39204605009caf6d0e9e8d640e1c1e5a1.jpg)  
+Figure 6. Samples from the reach robotic manipulation task. The task is to move the robot gripper to the location of the red disc. Agents are trained in setting (a) and evaluated in settings (b-d) on a real robot, taking observations from an uncalibrated camera.
+
+# F IMPLEMENTATION DETAILS
+
+In this section, we elaborate on implementation details for our experiments on DeepMind Control (DMControl) suite (Tassa et al., 2018) and CRLMaze (Lomonaco et al., 2019) for ViZDoom (Wydmuch et al., 2018). Our implementation for the robotic manipulation experiments closely follows that of DMControl. Code is available at https://nicklashansen.github.io/PAD/.
+
+![](images/9e0be3b5d460fc2992f725ba0dd7adde3d5e70bc06c843e908bf8d4d2266f9a5.jpg)  
+Figure 7. Network architecture for the DMControl, CRLMaze, and robotic manipulation experiments. $\pi ^ { s }$ and $\pi ^ { a }$ uses a shared feature extractor $\pi ^ { e }$ . Observations are stacks of $1 0 0 \times 1 0 0$ colored frames. Implementation of policy and value function depends on the learning algorithm.
+
+Architecture. Our network architecture is illustrated in Figure 7. Observations are stacked frames $k = 3 ,$ ) rendered at $1 0 0 \times 1 0 0$ and cropped to $8 4 \times 8 4$ , i.e. inputs to the network are of dimensions $9 \times 8 4 \times 8 4$ , where the first dimension indicates the channel numbers and the following ones represent spatial dimensions. The same crop is applied to all frames in a stack. The shared feature extractor $\pi ^ { e }$ consists of 8 (DMControl, robotic manipulation) or 6 (CRLMaze) convolutional layers and outputs features of size $3 2 \times 2 1 \times 2 1$ in DMControl and robotic manipulation, and size $3 2 \times 2 5 \times 2 5$ in CRLMaze. The output from $\pi ^ { e }$ is used as input to both the self-supervised head $\pi ^ { s }$ and RL head $\pi ^ { a }$ , both of which consist of 3 convolutional layers followed by 3 fully-connected layers. All convolutional layers use 32 filters and all fully connected layers use a hidden size of 1024, as in Yarats et al. (2019).
+
+Table 11. Hyperparameters used for the DMControl (Tassa et al., 2018) tasks.   
+
+<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>Frame rendering</td><td>3 ×100×100</td></tr><tr><td>Frame after crop</td><td>3×84×84</td></tr><tr><td>Stacked frames</td><td>3</td></tr><tr><td>Action repeat</td><td>2 (finger)</td></tr><tr><td></td><td>8 (cartpole) 4(otherwise)</td></tr><tr><td>Discount factor y</td><td>0.99</td></tr><tr><td>Episode length</td><td>1,000</td></tr><tr><td>Learning algorithm</td><td>Soft Actor-Critic</td></tr><tr><td>Self-supervised task</td><td>Inverse Dynamics Model</td></tr><tr><td>Number of training steps</td><td>500,000</td></tr><tr><td>Replay buffer size</td><td>500,000</td></tr><tr><td>Optimizer(πe,πä,π)</td><td>Adam (β=0.9,β=0.999)</td></tr><tr><td>Optimizer (α)</td><td>Adam(β=0.5,β=0.999)</td></tr><tr><td>Learning rate (πe,π,π$)</td><td>3e-4 (cheetah)</td></tr><tr><td>Learning rate (α)</td><td>le-3 (otherwise) 1e-4</td></tr><tr><td>Batch size</td><td>128</td></tr><tr><td>Batch size (test-time)</td><td>32</td></tr><tr><td>πe,π update freq.</td><td>2</td></tr><tr><td>πe,π update freq. (test-time)</td><td>1</td></tr></table>
+
+Table 12. Hyperparameters used for the CRLMaze (Lomonaco et al., 2019) navigation task.   
+
+<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>Frame rendering</td><td>3×100×100</td></tr><tr><td>Frame after crop</td><td>3×84×84</td></tr><tr><td>Stacked frames</td><td>3</td></tr><tr><td>Action repeat</td><td>4</td></tr><tr><td>Discount factor y</td><td>0.99</td></tr><tr><td>Episode length</td><td>1,000</td></tr><tr><td>Learning algorithm</td><td>Advantage Actor-Critic</td></tr><tr><td>Self-supervised task</td><td>Rotation Prediction</td></tr><tr><td>Number of training episodes</td><td>1,000 (dom. rand.) 500 (otherwise)</td></tr><tr><td>Number of processes</td><td>20</td></tr><tr><td>Optimizer</td><td>Adam (β=0.9,β=0.999)</td></tr><tr><td>Learning rate</td><td>1e-4</td></tr><tr><td>Learning rate (test-time)</td><td>1e-5</td></tr><tr><td>Batch size</td><td>20</td></tr><tr><td></td><td>32</td></tr><tr><td>Batch size (test-time) π,πloss coefficient</td><td>0.5</td></tr><tr><td></td><td>1</td></tr><tr><td>πe,πloss coefficient (test-time)</td><td>1</td></tr><tr><td>πe,π update freq. πe,π update freq.(test-time)</td><td>1</td></tr></table>
+
+Learning algorithm. We use Soft Actor-Critic (SAC) (Haarnoja et al., 2018) for DMControl and robotic manipulation, and Advantage Actor-Critic (A2C) for CRLMaze. Network outputs depend on the task and learning algorithm. As the action spaces of both DMControl and robotic manipulation are continuous, the policy learned by SAC outputs the mean and variance of a Gaussian distribution over actions. CRLMaze has a discrete action space and the policy learned by A2C thus learns a soft-max distribution over actions. For details on the critics learned by SAC and A2C, the reader is referred to Haarnoja et al. (2018) and Mnih et al. (2016), respectively.
+
+Hyperparameters. When applicable, we adopt our hyperparameters from Yarats et al. (2019) (DMControl, robotic manipulation) and Lomonaco et al. (2019) (CRLMaze). For the robotic manipulation experiments, our implementation closely follows that of DMControl, only differing by number of frames in an observation. We use a frame stack of $k = 3$ frames for DMControl and CRLMaze, and only $k = 1$ frame for robotic manipulation. For completeness, we detail all hyperparameters used for the DMControl and CRLMaze environments in Table 11 and Table 12.
+
+Data augmentation. Random cropping is a commonly used data augmentation used in computer vision systems (Krizhevsky et al., 2012; Szegedy et al., 2015) but has only recently gained interest as a stochastic regularization technique in the RL literature (Srinivas et al., 2020; Kostrikov et al., 2020; Laskin et al., 2020). We adopt the random crop proposed in Srinivas et al. (2020): crop rendered observations of size $1 0 0 \times 1 0 0$ to $8 4 \times 8 4$ , applying the same crop to all frames in a stacked observation. This has the added benefits of regularization while still preserving spatio-temporal patterns between frames. When learning an inverse dynamics model, we apply the same crop to all frames of a given observation but apply two different crops to the consecutive observations $\left( \mathbf { s } _ { t } , \mathbf { s } _ { t + 1 } \right)$ used to predict action $\mathbf { a } _ { t }$ .
+
+Policy Adaptation during Deployment. We evaluate our method and baselines by episodic return of an agent trained in a single environment and tested in a collection of test environments, each with distinct changes from the training environment. We assume no reward signal at test-time and agents are expected to generalize without pre-training or resetting in the new environment. Therefore, we make updates to the policy using a self-supervised objective, and we train using observations from the environment in an online manner without memory, i.e. we make one update per step using the most-recent observation.
+
+Empirically, we find that: (i) the random crop data augmentation used during training helps regularize learning at test-time; and (ii) our algorithm benefits from learning from a batch of randomly cropped observations rather than single observations, even when all observations in the batch are augmented copies of the most-recent observation. As such, we apply both of these techniques when performing Policy Adaptation during Deployment and use a batch size of 32. When using the policy to take actions, however, inputs to the policy are simply center-cropped.

md/train/rylhToC5YQ/rylhToC5YQ.md

@@ -0,0 +1,420 @@
+# UNSUPERVISED NEURAL MULTI-DOCUMENT ABSTRACTIVE SUMMARIZATION OF REVIEWS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Abstractive summarization has been studied using neural sequence transduction methods with datasets of large, paired document-summary examples. However, such datasets are rare and the models trained from them do not generalize to other domains. Recently, some progress has been made in learning sequenceto-sequence mappings with only unpaired examples. In our work, we consider the setting where there are only documents (product or business reviews) with no summaries provided, and propose an end-to-end, neural model architecture to perform unsupervised abstractive summarization. Our proposed model consists of an auto-encoder trained so that the mean of the representations of the input reviews decodes to a reasonable summary-review. We consider variants of the proposed architecture and perform an ablation study to show the importance of specific components. We show through metrics and human evaluation that the generated summaries are highly abstractive, fluent, relevant, and representative of the average sentiment of the input reviews.
+
+# 1 INTRODUCTION
+
+Supervised, neural sequence-transduction models have seen wide success in many language-related tasks such as translation (Wu et al., 2016; Vaswani et al., 2017) and speech-recognition (Chiu et al., 2017). In these two cases, the model training is typically focused on the translation of sentences or recognition of short utterances, for which there is an abundance of parallel data. The application of such models to longer sequences (multi-sentence documents or long audio) works reasonably well in production systems because the sequences can be naturally decomposed into the shorter ones the models are trained on and thus sequence-transduction can be done piece-meal.
+
+Similar neural models have also been applied to abstractive summarization, where large numbers of document-summary pairs are used to generate news headlines (Rush et al., 2015) or bullet-points (Nallapati et al., 2016; See et al., 2017). Work in this vein has been extended by Liu et al. (2018) to the multi-document1 case to produce Wikipedia article text from references documents.
+
+However, unlike translation or speech recognition, adapting such summarization models to different types of documents without re-training is much less reasonable; for example, in general documents do not decompose into parts that look like news articles, nor can we expect our idea of saliency or desired writing style to correspond with that of particular news publishers. Re-training or at least fine-tuning such models on many in-domain document-summary pairs should be expected to get desirable performance. Unfortunately, it is very expensive to create a large parallel summarization corpus and the most common case in our experience is that we have many documents to summarize, but have few or no examples of summaries.
+
+We side-step these difficulties by completely avoiding the need for example summaries. Although there has been previous work on extractive summarization without supervision, we describe, to our knowledge, the first end-to-end, neural-abstractive, unsupervised summarization model. Unlike recent approaches to unsupervised translation (Artetxe et al., 2017; Lample et al., 2017), we do not only assume there is no parallel data, but also assume no dataset of output sequences.
+
+In this paper, we study the problem of abstractively summarizing multiple reviews about a business or product without any examples (in fact they do not exist in our dataset) and apply our method to publically available $\mathrm { Y e l p } ^ { 2 }$ and Amazon reviews (McAuley et al., 2015). We describe an architecture for summarizing multiple reviews in the form of a single review, perform multiple ablation experiments to justify the architecture chosen, and define proxy metrics to evaluate our generated summaries in the absence of ground-truth. Through these metrics, crowd-sourced human evaluation, and qualitative analysis, we show that the generated summaries are often fluent, relevant, and representative of the summarized reviews.
+
+![](images/23128dfc7f2eb01e9643230f0fd3262eb7aaec39c066ee3ba6010f8e950b585e.jpg)  
+Figure 1: The proposed model architecture.
+
+# 2 MODELS AND METHODS
+
+The model consists of two main components: (1) an auto-encoder module that learns representations for each review and constrains the generated summaries to be in the language domain, and (2) a summarization module that learns to generate summaries that are semantically similar to each of the input documents. These contribute a reconstruction loss and similarity loss, respectively. Both components contain an LSTM encoder and decoder – the two encoders’ weights are tied, and the two decoders’ weights are tied. The encoder and decoder are also initialized with the same pre-trained language model trained on the reviews of the dataset. The overall architecture is shown in Figure 1.
+
+Suppose we have an invertible tokenizer, $T$ , that maps text documents, $\mathbb { D }$ , to sequences of tokens (from a fixed vocabulary), $T ( \mathbb { D } )$ . Let $\mathbb { V } \subset T ( \mathbb { D } )$ represent the tokenized reviews in our dataset with a maximum length of $L$ . Given a set of $k$ reviews about an entity (business or product), $\{ x _ { 1 } , x _ { 2 } , . . . , x _ { k } \} \subset \mathbb { V }$ , we would like to produce a document tokenized using the same vocabulary, $s \in T ( \mathbb { D } )$ , that summarizes them.
+
+In the auto-encoder sub-module, an encoder $\phi _ { E } : \mathbb { V } \mapsto \mathbb { R } ^ { n }$ , maps reviews to real-vector codes, $z _ { j } = \phi _ { E } ( x _ { j } )$ . $\phi _ { E } ( x ) = [ h , c ]$ is implemented as the concatenation of the final hidden and cell states of an LSTM (Hochreiter & Schmidhuber, 1997) after processing $x$ one token at a time. A second decoder LSTM defines a distribution over $\mathbb { V }$ conditioned on the latent code, $p ( x | z _ { j } ) = \phi _ { D } ( z _ { j } )$ , by initializing its state with $z _ { j }$ , and is trained using teacher-forcing (Williams & Zipser, 1989) with a standard cross-entropy loss to reconstruct the original reviews, i.e. the auto-encoder is implemented as a sequence-to-sequence model (Sutskever et al., 2014).
+
+$$
+\ell _ { r e c } ( \{ x _ { 1 } , x _ { 2 } , . . . , x _ { k } \} , \phi _ { E } , \phi _ { D } ) = \sum _ { j = 1 } ^ { k } \ell _ { c r o s s \_ e n t r o p y } ( x _ { j } , \phi _ { D } ( \phi _ { E } ( x _ { j } ) ) )
+$$
+
+In the summarization module, $\{ z _ { 1 } , z _ { 2 } , . . . , z _ { k } \}$ are combined using a simple mean over the hidden and cell states, $\bar { z } = [ \bar { h } , \bar { c } ]$ , which is decoded by $\phi _ { D }$ into the summary $s$ . By using the same decoder as the auto-encoder, $\phi _ { D }$ , we constrain the output summary to the space of reviews, $s \in \mathbb { V }$ , and can think of it as a canonical review. We then re-encode the summary and compute a similarity loss that further constrains the summary to be semantically similar to the original reviews; we use average cosine distance, $d _ { c o s }$ , between the hidden states $h _ { j }$ of each encoded review and $h _ { s }$ of the encoded
+
+summary, $\phi _ { E } ( s ) = [ h _ { s } , c _ { s } ]$ .
+
+$$
+s \sim \phi _ { D } ( \bar { z } )
+$$
+
+$$
+\ell _ { s i m } ( \{ x _ { 1 } , x _ { 2 } , . . . , x _ { k } \} , \phi _ { E } , \phi _ { D } ) = \frac { 1 } { k } \sum _ { j = 1 } ^ { k } d _ { c o s } ( h _ { j } , h _ { s } )
+$$
+
+As we lack ground truth summaries, we cannot use teacher forcing to generate the summary in Equation (2). Instead, we generate the summary using the Straight Through Gumbel-Softmax trick (Jang et al., 2016; Maddison et al., 2016), which approximates sampling from a categorical distribution (in this case a softmax over the vocabulary) and allows gradients to be backpropagated through this discrete generation process. We note that this sampling procedure allows us to avoid the exposure bias (Ranzato et al., 2015) of teacher-forcing, as the summary is generated through the same procedure during training and as in inference.
+
+The final loss we optimize is simply $\ell _ { m o d e l } = \ell _ { r e c } + \ell _ { s i m }$ . We explored non-equal weighting of the losses but did not find a meaningful difference in outcomes.
+
+# 2.1 METRICS AND EVALUATION
+
+Though we have no ground truth summaries to compute traditional summarization metrics, we calculate three automatic statistics to guide model development and conduct a final human evaluation of summary quality.
+
+Rating accuracy. As reviews are used by consumers to guide purchasing decisions, a useful summary should reflect the overall sentiment of the reviews. We first separately train a CNN-based classification model that given a review $x$ , predicts the star rating of a review, an integer from 1 to 5. For each summary, we check whether the classifier’s max predicted rating is equal to the average rating of the reviews being summarized (rounded to the nearest star rating). This binary accuracy is averaged across all the data points.
+
+$$
+{ \mathrm { R a t i n g ~ a c c u r a c y } } = { \frac { 1 } { N } } \sum _ { i = 1 } ^ { N } \left[ \mathbf { C L F } ( s ^ { ( i ) } ) = = r o u n d { \Big ( } { \frac { 1 } { k } } \sum _ { j = 1 } ^ { k } r _ { j } ^ { ( i ) } { \Big ) } \right]
+$$
+
+where $N$ is the number of data points, CLF is the trained classifier, $\mathbf { C L F } ( s ^ { ( i ) } )$ is the rating with the highest predicted probability, $s ^ { ( i ) }$ is the summary for the $i$ -th data point, and $r _ { j } ^ { ( i ) }$ is the rating for the $j$ -th review in the $i$ -th data point.
+
+Word Overlap (WO) score. It is possible that a summary has the appropriate sentiment but is not grounded in information found in the reviews. As a sanity check that the summary is on-topic, we compute a measure of word overlap using the ROUGE-1 score (Lin, 2004) between the summary and each review and then average these scores, as shown in Equation 5. ROUGE is typically used between a candidate summary and a reference summary (which we lack), but its use here similarly captures how much the candidate summary encapsulates the original documents. We note that in our use case, this metric is highly biased towards extractive summaries, as the “reference” is the original reviews themselves and maximizing it is not necessarily appropriate; however, very little word overlap is likely pathological.
+
+$$
+\mathrm { W o r d ~ O v e r l a p ~ s c o r e } = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \left[ \frac { 1 } { k } \sum _ { j = 1 } ^ { k } \mathbf { R O U G E } ( s ^ { ( i ) } , r _ { j } ^ { ( i ) } ) \right]
+$$
+
+Negative Log-Likelihood (NLL). Generated summaries should also be fluent language. To measure this, we compute the negative log-likelihood of the summary according to a language model trained on the reviews. This metric is used to compare the outputs from different variations of our abstractive model.
+
+Human Evaluation. To further assess the summaries and the validity of our metrics, we ran Mechanical Turk experiments (more details in Appendix B) asking workers to rate 100 summaries on a scale of 1 (very poor) to 5 (very good):
+
+1. how well the sentiment of the summary agrees with the overall sentiment of the original review;   
+2. how well information is summarized across reviews;   
+3. the fluency of the summary based on five dimensions previously used in DUC-2005 Dang (2005): Grammaticality, Non-redundancy, Referential clarity, Focus, and Structure and Coherence.
+
+# 2.2 BASELINE MODELS
+
+No training. Perhaps the language model alone would be sufficient for generating summaries. This variant has the same architecture and language model initialization as our model, but we do not optimize $\ell _ { m o d e l }$ . The intent of this baseline is to show whether optimizing $\ell _ { m o d e l }$ improves the quality of summaries beyond pre-training. As in the full model, the summary is generated by encoding the original reviews with $\phi _ { E }$ , computing the combined review representation, and decoding the summary using $\phi _ { D }$ .
+
+Extractive. We use a recent, near state-of-the-art, centroid-based multi-document summarization method that uses word embeddings (Mikolov et al., 2013) instead of TF-IDF to represent each sentence (Rossiello et al., 2017). The maximum length of summaries was set to the $9 9 . { \dot { 5 } } ^ { t h }$ percentile of reviews less than length $L$ . This was chosen after evaluating various ceilings (e.g. $7 5 ^ { t h }$ percentile, $9 0 ^ { t h }$ percentile, no ceiling) on the validation set.
+
+Best Review. It could be the case that one of the reviews would be a good summary. We thus compute the WO scores using each review as a summary. The review with the highest average (not including itself) WO score is selected.
+
+Worst Review. We use the same procedure as the Best Review baseline, except we select the review with the lowest average WO score to get an idea of what is a bad word overlap score.
+
+Multi-Lead-1. The Lead- $m$ baseline is often a strong baseline in single document summarization tasks and consists of the first $m$ sentences in the document (See et al., 2017). We create an analog by first randomly shuffling the reviews, and then adding the first sentence from each review until the maximum length $L$ is reached. If $L$ is not reached, then the summary is composed of the first sentence from each review.
+
+# 2.3 MODEL VARIATIONS
+
+To investigate the importance of different components and features, we evaluated the following variations of our model:
+
+No pre-trained language model. Instead of initializing the encoders and decoders with the weights of a pre-trained language model, the entire model was trained from scratch.
+
+No auto-encoder. To test our belief that the auto-encoder is critical for (a) keeping the summaries in the review-language domain, $\mathbb { V }$ , and (b) producing review representations that actually reflect the review, we tested a variant without the auto-encoder. This model is shown in Appendix A.
+
+Reconstruction cycle loss. A perhaps more straightforward model architecture would be to encode the reviews, compute $\bar { z }$ , generate the summary $s$ , and then use $s$ to decode into the reconstructed reviews ${ \hat { x } } ^ { j }$ , which would be used in a reconstruction loss with the original reviews. This last step would enforce the same constraint as the auto-encoding loss and the cosine similarity loss. This model is shown in Appendix A.
+
+Early cosine loss. In the similarity loss, instead of computing distance between encoded reviews and the encoded summary, $\phi _ { E } ( s )$ , we use $\bar { z }$ :
+
+$$
+\ell _ { s i m } ( \{ x _ { 1 } , x _ { 2 } , . . . , x _ { k } \} , \phi _ { E } , \phi _ { D } ) = \frac { 1 } { k } \sum _ { j = 1 } ^ { k } d _ { c o s } ( z _ { j } , \bar { z } )
+$$
+
+Perhaps this alone would be enough to push $\bar { z }$ into a latent space suitable for decoding into a summary. This would also preclude the need for back-propagating gradients through the discrete sampling step – we only need to decode the summary at test time, which we do through greedy decoding. In contrast to our model, summary generation here suffers from the exposure bias of teacher-forcing. This model is shown in Appendix A.
+
+Untied decoders/encoders. We relax the constraint that the review and summary decoders/encoders share weights.
+
+# 3 RELATED WORK
+
+Many popular extractive summarization techniques do not require example summaries and instead consider summarization as a sentence-selection problem. Sentences may be selected based on scores computed from the presence of topic-words or word-frequencies (Nenkova & Vanderwende, 2005). Centroid-based methods try to select sentences such that the resulting summary is close to the centroid of the input documents in the representation space (Radev et al., 2004). Rossiello et al. (2017) extend this approach by mapping sentences to their representation using word2vec embeddings rather than using TF-IDF weights. The main disadvantage of extractive methods is their limitation in copying text from the input, which is not how humans summarize. Banko & Vanderwende (2004) in particular found human-authored summaries of multiple documents to be much more abstractive.
+
+Liu et al. (2015) present a framework for doing abstractive summarization in three stages. First text is parsed to an Abstract Meaning Representation (AMR) graph; then a graph-summarization procedure is carried out, which extracts an AMR sub-graph; finally, text is generated from this subgraph. All three components require separate training and also AMR annotations, for which there is very little data. It is unclear how to generalize this to the multi-document setting.
+
+Miao & Blunsom (2016) train an auto-encoder to do extractive sentence compression and combines it with a model trained on parallel data to do semi-supervised summarization.
+
+Recently, there has been progress in learning to translate between languages using only unpaired example sentences from each language (Artetxe et al., 2017; Lample et al., 2017). Gomez et al. (2018) train CycleGan-like (Zhu et al., 2017) models to map between unpaired examples of ciphertext and decrypted-text. In contrast to this line of interesting work, we only have examples of the input sequence and thus cannot apply such techniques.
+
+Review summarization systems have been designed with domain-specific choices. Liu et al. (2005); Ly et al. (2011) focus on producing a highly-structured summary consisting of facets and example positive and negative sentences for each. Zhuang et al. (2006) incorporate external databases to construct simiarly structured, movie-specific review summaries. In contrast our summaries have no explicit constraints or templates.
+
+# 4 EXPERIMENTAL SETUP
+
+# 4.1 DATASETS
+
+We tuned our models primarily on a dataset of customer reviews provided in the Yelp Dataset Challenge, where each review is accompanied by a 5-star rating. We used a data-driven, wordpiece tokenizer (Wu et al., 2016) with a vocabulary size of 32,000 and filtered reviews to those with tokenized length, $L \leq 1 5 0$ . Businesses were then filtered to those with at least 50 reviews, so that every business had enough reviews to be summarized. Finally, we removed businesses above the $9 0 ^ { t \bar { h } }$ percentile in review count in order to prevent the dataset from being dominated by a small percent of hugely popular businesses. The final training, validation, and test splits consist of 10695, 1337, and 1337 businesses, and 1038184, 129856, and 129840 reviews, respectively.
+
+# 4.2 EXPERIMENTAL DETAILS
+
+The language model, encoders, and decoders were multiplicative LSTM’s (Krause et al., 2016) with 512 hidden units, a 0.1 dropout rate, a word embedding size of 256, and layer normalization (Ba et al., 2016). We used Adam (Kingma & Ba, 2014) to train, a learning rate of 0.001 for the language model, a learning rate of 0.0001 for the classifier, and a learning rate of 0.0005 for the summarization model, with $\beta _ { 1 } = 0 . 9$ and $\beta _ { 2 } = 0 . 9 9 9$ . The initial temperature for the Gumbel-softmax was set to 2.0.
+
+Table 1: Yelp results with $k = 8$ reviews being summarized. Note for Best/Worst Review WO scores: we exclude the best/worst review when calculating the average. Numbers are not provided for models that degenerated into non-natural language. As noted earlier, the NLL’s are only provided for our abstractive models.   
+
+<table><tr><td>Model</td><td>Rating Accuracy</td><td>Word Overlap</td><td>NLL</td></tr><tr><td>Abstractive (ours)</td><td>52.09</td><td>26.48</td><td>1.19</td></tr><tr><td>No training</td><td></td><td>19.68</td><td></td></tr><tr><td>Extractive (Rossiello et al., 2017)</td><td>24.44 42.95</td><td>28.59</td><td>1.29</td></tr><tr><td>Best review</td><td>38.48</td><td>23.86</td><td>1</td></tr><tr><td>parneerg Worst review</td><td></td><td>13.14</td><td>1</td></tr><tr><td>Multi-Lead-1</td><td>30.01 40.69</td><td>31.64</td><td>1</td></tr><tr><td></td><td></td><td></td><td>1</td></tr><tr><td>Wouiirrtipts No pre-trained language model No auto-encoder</td><td>48.97</td><td>23.67</td><td>1.14</td></tr><tr><td></td><td>1</td><td>1</td><td>1</td></tr><tr><td>Reconstruction cycle loss</td><td>43.65</td><td>22.26</td><td>1.14</td></tr><tr><td>Early cosine loss</td><td>19.32</td><td>14.28</td><td>1.71</td></tr><tr><td>Untied decoders</td><td>1</td><td>1</td><td>1</td></tr><tr><td>Untied encoders</td><td>50.89</td><td>26.29</td><td>1.20</td></tr></table>
+
+One input item to the language model was $k = 8$ reviews from the same business or product concatenated together with end-of-review delimiters, with each update step operating on a subsequence of 256 subtokens. The initial states were set to zero and persisted across update steps for that set of $k = 8$ reviews in order to simulate full back-propagation through the entire sequence. The reviewrating classifier was a multi-channel text convolutional neural network similar to Kim (2014) with 3,4,5 width filters, 128 feature maps per filter, and a 0.5 dropout rate. The classifier achieves $72 \%$ accuracy, which is similar to current state-of-the-art performance on the Yelp dataset.
+
+# 5 RESULTS
+
+# 5.1 MAIN RESULTS
+
+The metrics for our model and the baselines are shown in Table 1. We find that the abstractive model outperforms all the baselines in rating accuracy. It also obtains a slightly lower, but comparable Word Overlap compared to the extractive method.
+
+The human evaluation results are shown in Table 2 and validate our use of the automatic metrics in guiding our model development. The human scores on sentiment and information agreement are comparable for the extractive and abstractive models and rank order the methods similarly to our proxy metrics, rating accuracy and word overlap, respectively. We find that the abstractive summaries are comparable to extractive summaries and randomly selected input reviews on fluency, suggesting the model outputs have high fluency. We also find that the early cosine loss model has much lower ratings on the fluency questions, which agrees with the much higher NLL compared to our best-performing abstractive model.
+
+An example set of reviews and corresponding summaries are shown in Figure 2. We find that extractive summaries, while highly specific and fluent, appear to summarize only a subset of the reviews. The abstractive summaries tend to be more general (e.g. using the term "mani/pedi" which does not occur in the input), but as the higher rating accuracy suggests, also more reflective of the average sentiment of the reviews. Because the model has no attention, there is very little copying and the summaries are highly abstractive. For summaries over the test set, $7 8 . 4 3 \%$ of 2-grams, $9 6 . 5 7 \%$ of 3-grams, and $9 9 . 3 3 \%$ of 4-grams in the summaries are unique (i.e. not found in the reviews being summarized). Figure 3 shows summaries of negative, neutral, and positive reviews from the same
+
+Table 2: Mechanical Turk results comparing different methods.   
+
+<table><tr><td rowspan="5"></td><td>Model</td><td>Sentiment</td><td>Information</td><td></td><td></td></tr><tr><td>Abstractive (ours) Extractive</td><td>3.91 3.87</td><td>3.83 3.85</td><td></td><td></td></tr><tr><td></td><td>Non-</td><td>Referential</td><td></td><td>Structure and</td></tr><tr><td>Grammar</td><td>redundancy</td><td>clarity</td><td>Focus</td><td>Coherence</td></tr><tr><td>Abstractive (ours)</td><td>3.97</td><td>3.74</td><td>4.13</td><td>4.10</td></tr><tr><td>Extractive</td><td>3.86</td><td>3.93</td><td>4.05</td><td>4.01</td><td>4.02 3.99</td></tr><tr><td>Early cosine loss</td><td>2.02</td><td>1.84</td><td>2.02</td><td>1.96</td><td>1.95</td></tr><tr><td>Random review</td><td>3.94</td><td>4.06</td><td>4.09</td><td>4.23</td><td>4.01</td></tr></table>
+
+# Original Reviews: Mean Rating $\mathbf { \lambda } = 4$
+
+No question the best pedicure in Las Vegas. I go around the world to places like Thailand and Vietnam to get beauty services and this place is the real thing. Ben, Nancy and Jackie took the time to do it right and you don’t feel rushed. My cracked heels have never been softer thanks to Nancy and they didn’t hurt the next day. ${ < } I \mathrm { D O C } { > }$ Came to Vegas to visit sister both wanted full sets got to the salon like around 4 . Friendly guy greet us and ask what we wanted for today but girl doing nails was very rude and immediately refuse service saying she didn’t have any time to do 2 full sets when it clearly said open until $7 \mathrm { p m } !$ ${ \angle } / \mathrm { D O C } >$ This is the most clean nail studio I have been so far. The service is great. They take their time and do the irk with love. That creates a very comfortable atmosphere. I recommend it to everyone!! ${ \angle } / \mathrm { D O C } >$ Took a taxi here from hotel bc of reviews -Walked in and walked out - not sure how they got these reviews. Strong smell and broken floor - below standards for a beauty care facility. ${ \sqrt { \mathrm { D O C } } } >$ The best place for pedi in Vegas for sure. My husband and me moved here a few months ago and we have tried a few places, but this is the only place that makes us $100 \%$ happy with the result. I highly recommend it! </DOC> This was the best nail experience that I had in awhile. The service was perfect from start to finish! I came to Vegas and needed my nails, feet, eyebrows and lashes done before going out. In order to get me out quickly, my feet and hands where done at the same time. Everything about this place was excellent! I will certainly keep them in mind on my next trip. ${ < } / \mathrm { D O C } > \mathrm { ~ I ~ }$ came here for a munch needed pedicure for me and my husband. We got great customer service and an amazing pedicure and manicure. I will be back every time I come to Vegas. My nails are beautiful, my skin is very soft and smooth, and most important I felt great after leaving!!! ${ \angle } / \mathrm { D O C } >$ My friend brought me here to get my very first manicure for my birthday. Ben and Nancy were so friendly and super attentive. Even though were were there past closing time, I never felt like we were being rushed or that they were trying to get us out the door. I got the $\# 4 2 8$ Rosewood gel manicure and I love it. I’ll definitely be back and next time I’ll try a pedicure.
+
+# Extractive Summary: Predicted Rating $\mathbf { \mu } = \mathbf { 1 }$
+
+Came to Vegas to visit sister both wanted full sets got to the salon like around 4 . Friendly guy greet us and ask what we wanted for today but girl doing nails was very rude and immediately refuse service saying she didn’t have any time to do 2 full sets when it clearly said open until $7 \mathrm { p m }$ !
+
+# Unsupervised Abstractive Summary: Predicted Rating $= 5$
+
+Probably the best mani/pedi I have ever had. I went on a Saturday afternoon and it was busy and they have a great selection of colors. We went to the salon for a few hours of work, but this place was very relaxing. Very friendly staff and a great place to relax after a long day of work.
+
+Figure 2: An example of input Yelp Reviews (separated by $" { \mathrm { < } } / { \mathrm { D O C > " } } ,$ ) with the extractive baseline and our model summaries. Certain words are colored in the original reviews that correspond to similar words in the abstractive summary.
+
+business, allowing us to see how the summary changes with the input sentiment. More examples can be found in Appendix D.
+
+# Summary of Negative Reviews: Predicted Rating $\mathbf { \mu } = \mathbf { 1 }$
+
+Never going back. Went there for a late lunch and the place was packed with people. I had to ask for a refund, a manager was rude to me and said they didn’t have any. It’s not the cheapest place in town but it’s not worth it for me. And they do not accept debit cards no matter how busy it is. But whatever, they deserve the money .
+
+# Summary of Neutral Reviews: Predicted Rating $^ { = 3 }$
+
+Food is good and the staff was friendly. I had the pulled pork tacos, which was a nice surprise. The food is not bad but certainly not great. Service was good and friendly. I would have given it a 3 star but $\Gamma \mathrm { m }$ not a fan of their food. Service was friendly and attentive. Only complaint is that the staff has no idea what he’s talking about, but it’s a little more expensive than other taco shops.
+
+# Summary of Positive Reviews: Predicted $\mathbf { R a t i n g } = 5$
+
+Always great food. The best part is that it’s on the light rail station, and it’s a little more expensive than most places. I had a brisket taco with a side of fries and a side of corn. Great place to take a date or to go with some friends
+
+Figure 3: Summaries generated from our model for one business, but varying the input reviews. Each summary is for a set of reviews with the same rating. The original reviews are found in the appendix (Figure 12).
+
+# 5.2 MODEL VARIANT ABLATION STUDIES
+
+The results of the ablation studies are shown in Table 1.
+
+The language model experiments indicate that while initializing the weights with a pre-trained language model helps, as has been shown in sequence-to-sequence models (Ramachandran et al., 2016), it is not critical. Without the pre-trained language model, the rating accuracy and average WO score are only a few points lower (48.97 vs. 52.09 accuracy, 23.68 vs. 26.48 WO). We also find that using a pre-trained language model alone, without training the summarization model, is not enough to generate good summaries. While the generated texts are fluent, they fail to actually summarize the reviews, as shown by the low rating accuracy (24.44) and WO score (19.68).
+
+Two of the models failed completely, with the model degenerating from producing natural language (even though initialized with the pre-trained language model) to garbage text. The first variant, without the auto-encoder, converges to a trivial solution – the cosine similarity loss can be minimized if the encoders learn to produce the same representation $z _ { j }$ regardless of the input. As suspected with the second variant, in which the decoders are not tied, the summary decoder has no constraint to remain in language space, V.
+
+The reconstruction cycle loss works, but worse than the original model (43.66 vs. 52.09 accuracy, 22.26 vs. 26.48 WO). We hypothesize its lower performance is due to difficulties in optimization. Although the Gumbel softmax trick allows the model to be fully differentiable, the gradients will have either high bias or or variance depending on the temperature (which can be annealed during training). With the single loss function being after the Gumbel softmax step, the model may be difficult to optimize. We also believe that reconstructing the original texts from $\phi _ { E } ( s )$ is difficult, as $s$ is a lossy compression of the original documents.
+
+Next, we see that the “Early cosine loss” model has poor rating accuracy and average Word Overlap. We believe this is largely due to exposure bias, resulting in a relatively large NLL. The summaries are generated at test time through greedy decoding, but this decoding process (and thus the summary decoder) is not part of the training procedure. Critically, the full model does not suffer from this problem. Manual inspection of the samples confirm the summaries are disfluent.
+
+Finally, the model performed approximately as well without tying the encoders (50.89 vs. 52.09 accuracy, 26.29 vs. 26.48 WO). Given that this is the case, it makes sense to simply tie the encoders and reduce the number of model parameters.
+
+We also examined the fluency of each model by plotting the negative log-likelihood of the generated summaries during training, as shown in Figure 4. The two models that fail are immediately evident, as indicated by their large NLL’s.
+
+![](images/c211e2965da56a1c1eb793192ed0fbb7a7df3bc635b9a0787e323e3ab63cbbfc.jpg)  
+Figure 4: Negative Log-Likelihood of Models During Training
+
+# 5.3 VARYING $k$
+
+We also ran experiments to examine the effect of different $k$ ’s and whether our model was robust to this hyperparameter. The results for training and testing with different $k$ ’s are shown in Figure 5 and Figure 9. The “Varying $k ^ { \prime \prime }$ model was trained with $k \in \{ 4 , 8 , 1 6 \}$ reviews (randomly selected every minibatch). We did not perform any extra hyperparameter search for the models trained with $k = 4$ , $k = 1 6$ , and varying $k$ , and instead used the same hyperparmeters used to train the $k = 8$ model.
+
+Overall, we find that the rating accuracies are largely stable for all methods. Similarly, we find that the abstractive model also has relatively stable Word Overlap scores, with a small decline as the number of reviews being summarized at test time increases. However, the extractive baseline method appears to decrease as $k$ increases – as the variance in content increases with greater $k$ , it may be harder to extract sentences that reflect all of the reviews.
+
+![](images/f104ca5a5778676877214ed4d730ae5bf68d3e719cc57cd470b820a98d984914.jpg)  
+Figure 5: Word overlap score with varying $k$ at train and test time
+
+# 5.4 AMAZON DATASET
+
+To check that our model works beyond Yelp reviews, we also tested on a Amazon dataset of product reviews. We selected two different categories – Movies & TV and Electronics. We used the same parameters used to filter the Yelp dataset, resulting in training, validation, and test splits of 6,237, 780, and 780 products, and 583776, 73040, 73040 reviews, respectively. No tuning was performed – we used the exact same model and training hyperparameters as the Yelp models. The results are shown in Table 3. We find similar results – the abstractive method outperforms the baselines in rating accuracy and has slightly lower Word Overlap than the extractive baseline method.
+
+Table 3: Results on Amazon dataset   
+
+<table><tr><td>Model</td><td>Rating Accuracy</td><td>Word Overlap</td><td>NLL</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>Abstractive (ours)</td><td>47.90</td><td>27.02</td><td>1.23</td></tr><tr><td>No Training</td><td>38.04 43.86</td><td>18.10</td><td>1.37</td></tr><tr><td>Extractive (Rossiello et al., 2017)</td><td>45.05</td><td>30.41</td><td>1.38</td></tr><tr><td>Best review</td><td>38.88</td><td>24.59</td><td>1.29</td></tr><tr><td>Worst review</td><td>44.90</td><td>13.79</td><td>1.36</td></tr><tr><td>Multi-Lead-1</td><td></td><td>32.18</td><td>1.33</td></tr></table>
+
+# 5.5 QUALITATIVE ERROR ANALYSIS
+
+Although most summaries look reasonable, there are occasionally failure modes. We discuss the common failure modes as follows, with examples in Appendix D.
+
+Fluency errors: Grammatical mistakes (e.g. incorrect use of ‘and’ or ‘but’) and repetition of phrases could perhaps be reduced with a more powerful language model, as state of the art language models use many more parameters.
+
+Factual inaccuracy: Summaries sometimes make reference to named entities (e.g. the city the restaurant is located in) that are incorrect or not found in the original reviews. Factual accuracy is an ongoing area of research in the summarization field, and a loss function to penalize inaccurate statements may be helpful here.
+
+Rare categories: Summaries appear to be worse for categories with limited data (e.g. parks in the Yelp dataset). This could potentially be addressed by up-sampling these reviews or fine-tuning towards specific categories.
+
+Contradictory statements This sometimes occurs when there are both highly positive and highly negative reviews, leading to a summary with a positive statement immediately followed by a negative statement about the same subject. We could either separate these statements in a post-processing step, or train a model that is conditioned on the rating (and possibly other latent variables).
+
+# 6 CONCLUSION, LIMITATIONS, AND FUTURE WORK
+
+The standard approaches to neural abstractive summarization use supervised learning with many document-summary pairs that are expensive to obtain at scale. To address this limitation and make progress toward more widely useful models, we introduced an unsupervised abstractive model for multi-document summarization that applied to reviews is competitive with existing unsupervised extractive methods. 3
+
+The proposed model is highly abstractive because it lacks attention or pointers – future work could incorporate these mechanisms to provide summaries that contain both the most relevant points and the specific details to support them.
+
+For our problem, summarizing multiple documents in the form of a similarly distributed singledocument was appropriate, but may not be in all multi-document summarization cases. Learning to tailor the summary to a different desired form (with few examples) would be an interesting extension.
+
+Our model does not provide an unsupervised solution for the more difficult (as there are fewer redundancy cues) single-document summarization problem. Here too there are extractive solutions, but extending ideas presented in this paper might yield the similar advantages of neural abstractive summarization.
+
+# REFERENCES
+
+Mikel Artetxe, Gorka Labaka, Eneko Agirre, and Kyunghyun Cho. Unsupervised neural machine translation. arXiv preprint arXiv:1710.11041, 2017.
+
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.
+
+Michele Banko and Lucy Vanderwende. Using n-grams to understand the nature of summaries. In Proceedings of HLT-NAACL 2004: Short Papers, pp. 1–4. Association for Computational Linguistics, 2004.
+
+Chung-Cheng Chiu, Tara N Sainath, Yonghui Wu, Rohit Prabhavalkar, Patrick Nguyen, Zhifeng Chen, Anjuli Kannan, Ron J Weiss, Kanishka Rao, Katya Gonina, et al. State-of-the-art speech recognition with sequence-to-sequence models. arXiv preprint arXiv:1712.01769, 2017.
+
+Hoa Trang Dang. Overview of duc 2005. In Proceedings of the document understanding conference, volume 2005, pp. 1–12, 2005.
+
+Aidan N Gomez, Sicong Huang, Ivan Zhang, Bryan M Li, Muhammad Osama, and Lukasz Kaiser. Unsupervised cipher cracking using discrete gans. arXiv preprint arXiv:1801.04883, 2018.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 9(8): 1735–1780, 1997.
+
+Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax. arXiv preprint arXiv:1611.01144, 2016.
+
+Yoon Kim. Convolutional neural networks for sentence classification. arXiv preprint arXiv:1408.5882, 2014.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Ben Krause, Liang Lu, Iain Murray, and Steve Renals. Multiplicative lstm for sequence modelling. arXiv preprint arXiv:1609.07959, 2016.
+
+Guillaume Lample, Ludovic Denoyer, and Marc’Aurelio Ranzato. Unsupervised machine translation using monolingual corpora only. arXiv preprint arXiv:1711.00043, 2017.
+
+Chin-Yew Lin. Rouge: A package for automatic evaluation of summaries. Text Summarization Branches Out, 2004.
+
+Bing Liu, Minqing Hu, and Junsheng Cheng. Opinion observer: analyzing and comparing opinions on the web. In Proceedings of the 14th international conference on World Wide Web, pp. 342–351. ACM, 2005.
+
+Fei Liu, Jeffrey Flanigan, Sam Thomson, Norman Sadeh, and Noah A. Smith. Toward abstractive summarization using semantic representations. In Proceedings of the 2015 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 1077–1086, Denver, Colorado, May–June 2015. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/N15-1114.
+
+Peter J Liu, Mohammad Saleh, Etienne Pot, Ben Goodrich, Ryan Sepassi, Lukasz Kaiser, and Noam Shazeer. Generating wikipedia by summarizing long sequences. arXiv preprint arXiv:1704.04368, 2018.
+
+Duy Khang Ly, Kazunari Sugiyama, Ziheng Lin, and Min-Yen Kan. Product review summarization from a deeper perspective. In Proceedings of the 11th annual international ACM/IEEE joint conference on Digital libraries, pp. 311–314. ACM, 2011.
+
+Chris J Maddison, Andriy Mnih, and Yee Whye Teh. The concrete distribution: A continuous relaxation of discrete random variables. arXiv preprint arXiv:1611.00712, 2016.
+
+Julian McAuley, Christopher Targett, Qinfeng Shi, and Anton Van Den Hengel. Image-based recommendations on styles and substitutes. In Proceedings of the 38th International ACM SIGIR Conference on Research and Development in Information Retrieval, pp. 43–52. ACM, 2015.
+
+Yishu Miao and Phil Blunsom. Language as a latent variable: Discrete generative models for sentence compression. arXiv preprint arXiv:1609.07317, 2016.
+
+Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. arXiv preprint arXiv:1301.3781, 2013.
+
+Ramesh Nallapati, Bowen Zhou, Cicero dos Santos, Ça glar Gulçehre, and Bing Xiang. Abstractive text summarization using sequence-to-sequence rnns and beyond. CoNLL 2016, pp. 280, 2016.
+
+Ani Nenkova and Lucy Vanderwende. The impact of frequency on summarization. Microsoft Research, Redmond, Washington, Tech. Rep. MSR-TR-2005, 101, 2005.
+
+Dragomir R Radev, Hongyan Jing, Małgorzata Stys, and Daniel Tam. Centroid-based summarization ´ of multiple documents. Information Processing & Management, 40(6):919–938, 2004.
+
+Prajit Ramachandran, Peter J Liu, and Quoc V Le. Unsupervised pretraining for sequence to sequence learning. arXiv preprint arXiv:1611.02683, 2016.
+
+Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level training with recurrent neural networks. arXiv preprint arXiv:1511.06732, 2015.
+
+Gaetano Rossiello, Pierpaolo Basile, and Giovanni Semeraro. Centroid-based text summarization through compositionality of word embeddings. In Proceedings of the MultiLing 2017 Workshop on Summarization and Summary Evaluation Across Source Types and Genres, pp. 12–21, 2017.
+
+Alexander M. Rush, Sumit Chopra, and Jason Weston. A neural attention model for abstractive sentence summarization. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, EMNLP 2015, Lisbon, Portugal, September 17-21, 2015, pp. 379–389, 2015. URL http://aclweb.org/anthology/D/D15/D15-1044.pdf.
+
+Abigail See, Peter J Liu, and Christopher D Manning. Get to the point: Summarization with pointergenerator networks. arXiv preprint arXiv:1704.04368, 2017.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017.
+
+Ronald J Williams and David Zipser. A learning algorithm for continually running fully recurrent neural networks. Neural computation, 1(2):270–280, 1989.
+
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016.
+
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In Computer Vision (ICCV), 2017 IEEE International Conference on, pp. 2242–2251. IEEE, 2017.
+
+Li Zhuang, Feng Jing, and Xiao-Yan Zhu. Movie review mining and summarization. In Proceedings of the 15th ACM international conference on Information and knowledge management, pp. 43–50. ACM, 2006.
+
+# APPENDIX A MODEL VARIATIONS
+
+![](images/7f751c26342c5c4a29928627a6c4205aac3989d6d4e0414aae77bc591df298fe.jpg)  
+Figure 6: Model Variant: No Autoencoder
+
+![](images/412814d1e022a996453fa4a9a01149f7300421c6b86cb82f63df25d96bcc48fa.jpg)  
+Figure 7: Model Variant: Reconstruction Cycle Loss
+
+![](images/4ddd83565dfdd08d5fb2d4fa62c4885321069b337eb87629c1191fb712090a01.jpg)  
+Figure 8: Model Variant: Early Cosine Loss
+
+# APPENDIX B EXPERIMENTAL SETUP
+
+# B.1 HUMAN EVALUATION
+
+The results were collected through two separate experiments on Mechanical Turk. For both experiments, the order of the models were randomized so as to prevent ordering biases (e.g. summaries from the first model receiving higher ratings). To obtain higher-quality responses, workers were selected with the following criteria: (1) Masters Qualification (granted by Mechanical Turk depending on a worker’s performance across tasks over time), (2) at least a $9 5 \%$ HIT approval rate, (3) at least 100 HIT’s approved, and (4) worker’s location is the United States.
+
+In the first experiment, in which workers were asked to evaluate how well the summary reflected the information and sentiment of the original reviews, we presented the eight reviews being summarized and the extractive and abstractive summaries next to them.
+
+In the second experiment, in which workers were asked to evaluate the fluency of the summaries, we presented summaries from four different models. The original reviews were not shown, as the questions were simply assessing the linguistic quality of the summaries themselves.
+
+The definitions of the five dimensions of fluency were taken from Dang (2005) and defined as follows:
+
+1. Grammaticality: The summary should have no datelines, system-internal formatting, capitalization errors or obviously ungrammatical sentences (e.g., fragments, missing components) that make the text difficult to read.   
+2. Non-redundancy: There should be no unnecessary repetition in the summary. Unnecessary repetition might take the form of whole sentences that are repeated, or repeated facts, or the repeated use of a noun or noun phrase (e.g., "Bill Clinton") when a pronoun ("he") would suffice.   
+3. Referential clarity: It should be easy to identify who or what the pronouns and noun phrases in the summary are referring to. If a person or other entity is mentioned, it should be clear what their role in the story is. So, a reference would be unclear if an entity is referenced but its identity or relation to the story remains unclear.   
+4. Focus: the summary should have a focus; sentences should only contain information that is related to the rest of the summary.   
+5. Structure and Coherence: The summary should be well-structured and well-organized. The summary should not just be a heap of related information, but should build from sentence to sentence to a coherent body of information about a topic.
+
+![](images/2ed2feec341327f6263fc1cff8782f4bc35223de4fc23b65e70ca40e7dbe14dc.jpg)  
+Figure 9: Classification accuracy with varying $k$ at train and test time
+
+# APPENDIX D EXAMPLES
+
+D.1 ADDITIONAL EXAMPLES
+
+# Original Reviews: Mean Rating $\mathbf { \lambda } = 4$
+
+Crepe on point! Just the way it is supposed to be. Owner very patient and has great customer service. Will return. ${ \angle } / \mathrm { D O C } >$ Small place but friendly cheap tasty and fast! Sat on the barstool by the window with my gf and we were enjoying our time there. Would recommend to anyone looking for a decent breakfast ${ \angle } / \mathrm { D O C } >$ The crepes were pretty good but my 4 and 7 year old preferred the ones that I make at home. Service was good though and coffee was above average. Breakfast for 4 came out to $\$ 47$ which was a bit much considering I spent only a fiver more for a killer dinner for four last night at Amelio’s. ${ \angle } / \mathrm { D O C } >$ We had a ham and cheese crepe as well as a Nutella, strawberry, and banana one, and they were great. The crepe was tasty and chewy, as well as the fillings. Each crepe also came with a since sized portion of fresh fruit. Worth a try if you are looking for a crepe near downtown. ${ \sqrt { \mathrm { D O C } } } >$ The service is friendly. It’s a small, homely place. Great crepes at a reasonable price. ${ \angle } / \mathrm { D O C } >$ Quaint little shop halfway under ground, colorful inside. Only two workers when we went. Lots of options, both sweet and savory. My husband got the thyme and sesame seed crepe, which was amazing. I got the spinach and egg crepe. It was quite boring, but the original had cheese on it and I had them hold the cheese, so that’s my fault. I’d definitely like to come back for a sweet crepe or perhaps a thyme crepe all for myself :-) ${ \sqrt { \mathrm { D O C } } } >$ favorite one, surprised me every time. Starter and choco-strawberry are great choices. Surprise is great too! ${ < } / \mathrm { D O C } > \mathrm { I }$ ordered the crepes with nutella and strawberries and it was honestly so good. And I love the place as well, it’s small yet cozy. My new go to breakfast place because it’s so close to my house and pretty cheap for such delicious crepes.
+
+# Extractive Summary: Predicted $\mathbf { R a t i n g } = 5$
+
+I’d definitely like to come back for a sweet crepe or perhaps a thyme crepe all for myself :-) favorite one, surprised me every time. My new go to breakfast place because it’s so close to my house and pretty cheap for such delicious crepes.
+
+# Unsupervised Abstractive Summary: Predicted Rating $\mathbf { \lambda } = 4$
+
+The crepes and service are great. My only complaint was that the seating was limited, so it could be a little more intimate. Service was friendly and attentive. I’ll be back to try out other items on their menu.
+
+# Original Reviews: Mean Rating $\mathbf { \lambda } = 4$
+
+This spot is amazing i dont understand negative reviews such a great spot with authentic food loved it. ${ \mathrm { < / D O C > } }$ This place is dirty. There are roaches in the dining and restroom areas. They refused to refund my order. The people who work there are rude and useless. There is no reason to waste your time or money on eating here. ${ < } / \mathrm { D O C } { > } \mathrm { I }$ come to this place a lot. Sam is the man and the quality of lamb kabob is amazing. You can’t beat the price. Plus they got free Wi-Fi and plush couches to lounge on afterwards and have some tea and do some work. I highly recommend it. ${ \angle } / \mathrm { D O C } >$ Talk about friendly customer service! From the moment we walked in, we were greeted nicely and immediately felt welcome. I came here with my baby girl and boyfriend. We tried the beef, chicken and lamb kabobs. All were great but my favorite by far was the ground beef. It was so tender, flavorful and delicious! The freshly made bread and hummus was great too. Even my baby girl loved it. We will definitely be back again for more! ${ \sqrt { \mathrm { D O C } } } >$ First time i stopped by i tried the chicken shawrma also the appetizer sampler ( 3 flafel, humus and baba ghanosh ) and the bread was made fresh worth to give it a shot ${ \angle } / \mathrm { D O C } >$ This place is amazing and their food is out of this world!! The food is so good and fresh! Customer service is great since its under a new management !!! Love the people that work there! Cant wait to go with my friends there for their hookah nights!! ${ \angle } / \mathrm { D O C } >$ I’ve had gyros in many places but I can sincerely tell you that this place makes the best gyros I have ever tasted and The Baklava delicious I will definitely return to this place and recommend it to anyone. ${ < } I \mathrm { D O C } { > }$ Lunch: Beef & lamb shawarma. Comes with pita, hummus, tzatziki, salad and...onion salad? with lemon wedge. Meat was a bit on the tough side & heavily seasoned. A bit spicy–guess I’m a wimp today. Needed the tzatziki. Other than that I enjoyed it.
+
+# Extractive Summary: Predicted Rating $= 5$
+
+First time i stopped by i tried the chicken shawrma also the appetizer sampler ( 3 flafel, humus and baba ghanosh ) and the bread was made fresh worth to give it a shot This place is amazing and their food is out of this world!!
+
+# No Training Summary: Predicted Rating $\mathbf { \lambda } = 4$
+
+I’ve only come here for lunch. The soup is always fresh and seasoned deliciously, always packed full of flavor. Service is spotty and sometimes they rush you out of the line at the bar. Open kitchen is clean and neat, and the servers are always nice.
+
+# Early Cosine Loss Summary: Predicted Rating ${ \bf \mu } = { \bf 1 } { \bf \Lambda }$
+
+This place is so good and the food. And my only the places, Chicago, i go the meat the Chicago places always always deli deli always always deli deli always the grocery, the grocery is always clean and the Best always always clean and the lamb with the lamb (i always with lamb meat with the lamb meat i the lamb (with the lamb lamb (i the the the ( (the always the (the the the grocery (the the the Best (the always the Best (i always the the most the the grocery, the the the Best grocery i the the Best the the the the the today today today today today today today today today today today today today today today today today today today today today today
+
+# Unsupervised Abstractive Summary: Predicted Rating $= 5$
+
+Some of the best Mediterranean food I’ve had in a long time. My favorite is the chicken shawarma and it was so tasty!! Also their homemade pita bread is a must try! If you are looking for a place to take your business, make sure you check out this place as it is a lot of food.
+
+Figure 11: Example summaries from different baselines and model variations
+
+I usually don’t write reviews unless It is terrible. One word horrible , longest wait ever and considering how Hungry u would Think the food tasted better. when we received our chicken pork and brisket tacos it was sooo dry. I don’t understand How they call this place a bbq Because it tastes nothing like it. I will never ever come Here again. ${ \sqrt { \mathrm { D O C } } } >$ Impossible to find. Snooty hipster waitstaff. Cash only and a $\$ 4$ fee arm. I don’t care how good your food is. ${ \sqrt { \mathrm { D O C } } } >$ Prices have gone from $\$ 4.75$ & up for one taco to \$6 & up. Not worth it. Go to Las Palmas or Doce instead. ${ \sqrt { \mathrm { D O C } } } >$ Made a reservation, was seated 30 minutes late. Waited 15 minutes for a server. Got the rib plate, dry on the inside and greasy on the outside. Also was scolded for looking at the gluten free menu for some reason. But that’s ok not going back. Thanks I see why you are one of the lower reviewed establishments in the city. I’ll do my part as well in contributing to that. ${ \sqrt { \mathrm { D O C } } } >$ hipster hell!!!! horrible obscure music, skinny jeans everywhere, crappy food, and no heat!!!! servers had disgusting nose piercings. only go to this place if you love participation trophies and bernie sanders ${ \sqrt { \mathrm { D O C } } } >$ Why would you have at the top of your website “NO RESERVATIONS” and then when we show up ask if we called ahead and then tell us it will literally be a three hour wait to get in? Oh I didn’t call to get on the list? Why the hell would I think there was a list your site straight up said no reservations so why would I bother to call? Lawrenceville sucks now anyhow. ${ \sqrt { \mathrm { D O C } } } >$ Ordered a captain and Coke. Was informed they don’t have captian and.They don’t have Coke. Told them to make as best they cold. Got the worst watered down rum and Coke I’ve ever had and got charged $\$ 30$ for the 3 pathetic drinks we ordered. Absolute worst and I’ve lived in several areas even NYC. ${ \sqrt { \mathrm { D O C } } } >$ My first experience was good. The food was above average, but the wait time was pretty long. Went for a 2nd visit for lunch today and ordered two tacos but had to leave before eating, because the order still hadn’t come after 35 minutes! The waitress wasn’t very nice when asked about the delay in serving my order. The place was only half full. Maybe others have had the same experience I had and made the same decision not to go back
+
+Great for take out but atmosphere is a low point. We hadn’t been to Smoke since it was in Homestead so I was ready for a yummy taco. The food did not disappoint. Both my favorites, brisket and chicken apple were delicious. Service was fine. But the music was obnoxiously loud combined with ambient noise to the point that conversation was impossible and digestion questionable. As I walked past the kitchen I noticed it was quieter there. We took our order to go. The new place looks hip but I couldn’t enjoy it. Sorry we couldn’t stay because we really like you guys. Missing the quiet little place in Homestead that was all about good food. ${ \ < } / \mathrm { D O C } > \mathrm { I }$ think I could’ve read a Russian novel in the time between when I placed my order and received my food. Seriously, that was a crazy long wait to get the food. We’re talking about a few tacos, it really shouldn’t take that long. And, our seating area was drafty. Plus the music was too loud. And for what you get, it’s a bit pricey. However, the tacos are quite tasty. Three of the four of them were very good (the chorizo was so-so). The pork was indeed smoky; the chicken was appealing too. If they could improve their operation in the other areas, they’d be a four star place. ${ \sqrt { \mathrm { D O C } } } >$ This was our first visit to Smoke during a weekend trip. Cool, unique neighborhood. The inside of the place is a simple and rustic but welcoming. Service was friendly. It is cash only which I find to be a nuisance... Also BYOB, at least for now. We started with the bowl of cheese. It was delicious but we agreed that half the portion at half the price would be more suitable for two people. The tacos were good. We had chicken, pork, and brisket. I enjoyed the bbq flavors but found the tacos to be each a little one-noted for 6-7 bucks a pop. ${ \ < } / \mathrm { D O C } > \mathrm { I }$ went on burger night therefore the menu was limited but it was nice and they had a few non-burger options. Also there was no wait for a table around $8 \mathrm { p m }$ . I had the appetizer fries with brisket and it was more than enough food to fill me up. I also had the Big Fiz tobdrink (St. Germaine and grapefruit cocktail) and found it to be so light and refreshing. It’s a great summer cocktail and perfect to lighten up a big heavy meaty meal. ${ \sqrt { \mathrm { D O C } } } >$ A couple of years ago this place would have been awarded a five star, but I’m afraid it’s gone down hill. They reduced their taco options and expanded into burgers and plated meals. We decided to sit at the bar and bypass a $^ { 3 0 + }$ minute wait. I ordered the brisket taco and pork taco. The meat in the tacos was dry and overwhelming with sauce, it poured out on the tray while eating them. The mac and cheese side was bland and lacked salt. Maybe we just hit this place on a bad night. I will go back again to make sure, but this trip was disappointing. ${ \angle } / \mathrm { D O C } >$ Decent food. Great service. Menu is hit or miss depending on the day you go. Great idea but inconsistent food. ${ \sqrt { \mathrm { D O C } } } >$ Overhyped for the price. Solid food and half decent service. I tried it out on a whim and it wasn’t all that it was hyped to be. The best part of the place is the smell of the food cooking. If you enjoy the hipster beard crowd this is the place for you. Not bad but nothing that makes me want to go out of my way to revisit. ${ \angle } / \mathrm { D O C } >$ Great tacos and queso, atmosphere is cute, but the wait is intolerable and the staff is unfriendly, which took away from the experience.
+
+(b) Neutral Reviews: Rating $= 3$
+
+My second visit and just as impressed! The service has been awesome and they have been more than willing to accomodate me and my food allergies/restrictions even on a busy Friday night. So excited to be living right around the corner! ${ \sqrt { \mathrm { D O C } } } >$ Best Tacos in Pittsburgh seems like wan praise. Like...prettiest girl in the trailer park. And I don’t have a TON of experience with taco places (or trailer park girls), but I have some...and this is the best one. I try to avoid referencing other places relative to a place I’m rating, but suffice it to say that Smoke has competition, but as far as a more or less conventional ingredient taco goes...Smoke is it! (like Coke is it...see what I did there?) Nice beer selection. Very cool decor. Great location. Friendly servers. Great food. Win. ${ \sqrt { \mathrm { D O C } } } >$ This food is so delicious. The best thing on the menu is definitely the queso. You absolutely cannot skip it. Prices are pretty reasonable. Only negative is that you always have to wait a super long time to get a table. ${ \angle } / \mathrm { D O C } >$ Great lunch today at Smoke. Good craft beer list on tap to start things out. The special today was a smoked mushroom taco which was exceptional. The brisket was tasty but the mac and cheese was to die for. ${ \ < } / \mathrm { D O C } > \mathrm { I }$ dream about their chips and queso! Great tacos and plenty of options for vegetarians. I only wish there was a location closer to my house so I could go more often. ${ \angle } / \mathrm { D O C } >$ We have always enjoyed the food and vibe at this taco spot. We used to go to their location in Homestead often but are happy they are now located in Lawrenceville. BYOB is a plus, but don’t forget it’s cash only. I would recommend any of the tacos, they are all great. Also, we ordered the queso and chips. Absolutely amazing. Soft fried pita chips are so good. Eat it! ${ \angle } / \mathrm { D O C } >$ Awesome food, run don’t walk. Generous portions, only downside was that dessert was crazy expensive. Maybe they could let you known in advance that the “Pie” is small and perfect for 2 people to share, but they will be charging you $\$ 12$ . ${ < } I \mathrm { D O C } { > }$ Love this place. Great offerings with a barbecue twist. Best Mac n cheese I have ever tasted. Great service. Nothing bad to say.
+
+# D.4 QUALITATIVE ERROR ANALYSIS
+
+# Original Reviews: Mean Rating $\mathbf { \lambda } = 4$
+
+First visit to this great little diner today......the crab Benedict was laden with huge chunks of tasty crabmeat and accompanied by great hashed potatoes. Every item ordered at the table was perfect! The server was prompt and helpful and the place has that roadside diner ambiance although it’s in the heart of the city. I’ll be back in a few days, for sure. ${ \sqrt { \mathrm { D O C } } } >$ This place was great. Great food, great service, and great atmosphere. Sat at the bar and got to watch the staff in action. True team effort. Everyone was happy to be there and happy to help...and it showed in the food. Will definitely be back and definitely recommend. </DOC> No knock against the food, it was very straight forward. The shredded hash browns were very bland, will need some sort of seasoning to eat them. Serves was very friendly as soon as we walked in. Was not able to accommodate my egg allergy when I asked if I could supplement something for the eggs that came with my country fried steak. Not getting anything higher unless they can go above and beyond. Fine but nothing remarkable. Also way too expensive, with ripe 35 for 2 peoples... Cmon it’s a dinner... Stop it. ${ \sqrt { \mathrm { D O C } } } >$ Kelly’s actually catered a wedding I was at tonight and the food was fantastic! There was carrot ginger soup, mushroom risotto balls and create your own pasta. I had linguini, sausage, spinach, mushrooms and red onion with alfredo sauce. To Die For!!! Seriously one of the best things I have ever eaten. Really want to go to the diner to check out the full menu. I give the catering an $\mathrm { A \ + + + + } < \mathrm { \angle D O C } >$ This breakfast spot will make you want to come back day after day. Your heart and gut may not agree - but who cares! The breakfast bagel with hot sausge patty is my go to. I love the price, the atmosphere and the food even more. It’s not fancy, but it really doesn’t have to be. ${ \sqrt { \mathrm { D O C } } } >$ Been here $2 \mathbf { x }$ for breakfast and $2 \mathbf { x }$ for lunch in last 2-3 months. Breakfast...had variety of different things. I would stick with anything eggs and meat. Had pancakes once and were a little greasy ¨ ¨for me. Portions are BIG. If you leave full, shame on you. Lunch... fish sandwich - good tuna melt - real good (friend had it - tasted it - yummy) burger club - good (tried zucchini fries with it which were real good and portion was HUGE) For what it is...diner, it is well worth the stop!!! ${ \sqrt { \mathrm { D O C } } } >$ Every time, I mean every time, Kelly O’s hits the spot. I must say I am an early bird and hit the breakfast joints before 8 on the weekend. I wasn’t really, really hungry, but they have a lil one breakfast that is one egg, one meat, some potatoes and Mancini toast. Just enough. I added a pancake for a taste of sweet. For the heartier eater, there are daily specials and a variety of large bfast plates. The key to Kelly O’s is that the service is always prompt and icing on the cake is mancini toast. ${ \sqrt { \mathrm { D O C } } } >$ Kelly-Os is a great Pittsburgh diner. The food is fairly priced, delicious, and fast. Their fresh-squeezed orange juice is the best orange juice ever. The French toast isn’t anything special (and not recommended), but the pancakes are nice and fluffy. This is one of my boyfriend’s favorite places to get Eggs Benedict in Pittsburgh. Some of the waiters/waitresses are nicer than others, so one thing they can work on is better overall friendliness. However, I always have a nice time with good company and great food.
+
+# Unsupervised Abstractive Summary: Predicted Rating $\mathbf { \lambda } = 4$
+
+Last time I was here, the server was really nice and helpful. For breakfast it’s a great place to eat, eat, breakfast or lunch. The place is a bit small but it’s not too far from home. Dinner for two of us was amazing. I had a side of mashed potatoes and gravy with a side of potatoes and gravy. Both were delicious and the onion rings were also very good. A great spot to eat in downtown Phoenix.
+
+# Original Reviews: Mean Rating $\mathbf { \lambda } = 4$
+
+Affordable, efficient and always do a great job. Even my boyfriend got his brows done here once. Highly recommended! ${ \angle } / \mathrm { D O C } >$ Needed legs and lady parts taken care of in a jiffy. this place was near home and priced reasonably. I was looking for somehwere new to replace the closer establishments on bloor where front of house welcome is underwhelming and treatments rushed and often not that great. Naheed was awesome. She was attentive and thorough and was a real sweetie. when I mentioned I’d never had an eyebrow threading before, she began to explain the process and before I knew it, she gave me my first threading at no extra charge! So happy. Personable experience that had me walking away feeling good. Thank you Naheed! ${ \angle } / \mathrm { D O C } >$ My eyebrows got butchered from a threading shop on Gerrard (in little India) so I worked extremely hard to grow them out. After reading some of the other reviews, I decided to check this place out and I was NOT disappointed. Hamilda was the one that reshaped and cleaning up my brows. She did a great job and really knew what she was doing. This will be my new spot for eyebrows! ${ \angle } / \mathrm { D O C } >$ After reading various positive reviews here on Yelp, I scheduled a morning appointment. Naheed, the owner, welcomed me as her first customer of the day. It was my first time getting eyebrow threading done. She was quick, professional and approachable, and made me feel welcome and comfortable. We actually also did a wax as well. Which was thorough. It’s best to get an appointment, as there were walk-ins waiting after I was finished. Thanks again Naheed, I plan to come back again when I’m due for one of your services again, you deserve 5 stars. ${ \sqrt { \mathrm { D O C } } } >$ Love this place! Both Naheed and Nadia are amazing at what they do! The place is clean and walk-ins are always welcome. The prices are super reasonable and there’s always deals on for even more saving! So far I’ve only been for waxing and haven’t left with any complaints. Gonna try out eyebrow threading next. ${ \angle } / \mathrm { D O C } >$ They did such a great job threading my eyebrows!! She charged about $\$ 11$ for eyebrow threading. I forget the name of the lady that did my eyebrows $\cdot /$ but she did such an excellent job! ${ \sqrt { \mathrm { D O C } } } >$ The most amazing threading place ever! Ive been trying to find a threading place in canada for so long and finally found my regular to go place! They do an amazing job shaping the eyebrow, they are really the experts!!! Defiantly torontos best threading place! ${ < } / \mathrm { D O C } > \mathrm { I }$ don’t recommend this place for eyebrows threading! She literally butchered my eyebrows and wasn’t receptive at all. She works way too fast and is not meticulous at all. Too bad!
+
+Unsupervised Abstractive Summary: Predicted Rating $= 5$   
+My brows were beautiful and well done. It’s the closest place to my house for me, but I’m not sure if it is a sign or a very small place. But when it was time to sign up for the appointment, it’s great people! and they are great for brows and feet!
+
+# Original Reviews: Mean Rating ${ \bf \Phi } = 2 { \bf \Phi }$
+
+Horrible service and please check your cat when you pick up from service, they have changed the wheels once and other time that have stolen the tools that a new car comes with. I will never buy a car from them anymore especially because the service department. ${ \angle } / \mathrm { D O C } >$ Was passing thru Las Vegas when my 2007 X5 4.8i had a belt tensioner failure. Limped to this dealer the next morning from my hotel and was kindly greeted by Larry. Years later...Horror strikes from the slipshod work this dealer did to my E70. ${ < } I \mathrm { D O C } { > }$ As many people here have mentioned this is not a place where you want to buy a car. DO NOT let the BMW name fool you, this is a sleezy used car dealership in disguise. The salesman are quick to sale you a car but will NOT get back to you when they deliver a car that was not promised. My car was missing a floor mat, the oil was not changed and has other issues. DON’T be fooled by the rep responding to bad reviews, thats just to save face. I have reached out several times and have yet to get a response. Save yourself the time and energy and buy a car from a professional dealership. DO NOT BUY from BMW of Las Vegas. ${ \sqrt { \mathrm { D O C } } } >$ Bought a preowned BMW and their detail work is terrible. They left dirt in between buttons, and promised me that they would neutralize the perfume smell coming from the arm rest. I had to go several times to get this done, and it still wasn’t done properly. On top of that there was a scratch they promised to repair and it never happened, they kept giving me odd times to go in during the week without a rental. They were not very understanding that I had to work and can’t take days off for something that could of easily be fixed on their end. Never buy from them again, for them it’s all about the $\$ 53$ . ${ < } I \mathrm { D O C } { > }$ Took my car in for routine servicing and when I picked it up later that day I noticed that my front splash guards were missing after the service team took my car through the car wash. I informed the service manager and he assured me that my car came in without splash guards until, I pointed out that that they had thrown them in the front seat and they were still dripping wet from the car wash. He reluctantly admitted his team had torn them off in the car wash and put them in the front seat. Overall just a extremely shady operation. ${ \sqrt { \mathrm { D O C } } } >$ awesome awesome awesome these guys are great i have never had such a great experience thanks Trent!!!! ${ \angle } / \mathrm { D O C } >$ Great car buying experience. Got a really good deal on my new BMW and was treated like royalty by all the professionals at Las Vegas BMW. I highly recommend them. ${ \angle } / \mathrm { D O C } >$ Thanks for hooking us up with a wonderful certified pre-owned Beamer ¨ . Great dealership, BMW should be proud you all are representing them in Las Vegas.
+
+# Unsupervised Abstractive Summary: Predicted Rating $= 5$
+
+Took my car in for a Brazilian wax and transmission fluid. They were very accommodating, the customer service was good and he was able to get me in the same day I called. He was very friendly and helpful in explaining what he was doing and what was going on in the morning. I will be going back to this dealership for sure.
+
+# Original Reviews: Mean Rating $= 5$
+
+My first time at a Dragon Pearl buffet. They had a huge selection of food from over the world and all tasted very good! My favourite was the deep fried oysters (make sure you choose ones with just a little batter). Unfortunately I didn’t get to try their signature dragon pearl dessert...Friends told me that the Markham location had cold crab and frog legs, so I was looking forward to it at this location... they didn’t have it! ${ \sqrt { \mathrm { D O C } } } >$ Just one sentence : I love this restaurant over any restaurant not only in Toronto but over the country . Highly recommended because of many reasons, the food is such fresh that you can’t find in even expensive restaurants . The atmosphere is very sexy and warm that you like to stay there for a long time chatting with you family and friends.on Tuesdays, there is a special promotion that is $1 1 . 9 9 \mathbb { S }$ for lunch and $1 . 5 \ S$ for green tea per each person. I recommend the lobster in weekends which is given to you by a voucher . In sum, this restaurant put the Mandarin in real shame. Highly highly recommended. ${ \angle } / \mathrm { D O C } >$ This place is one of the best buffets that I have tried. They have a good variety of food and the service is amazing. On our second visit they were constantly clearing away places and replenishing napkins without asking. The roast beef was great and so was the fresh noodles, I highly recommend the beef szhewan ${ \sqrt { \mathrm { D O C } } } >$ Great Chinese buffet in North Toronto. Prices are steep but a good pick for a lunch buffet ${ \sqrt { \mathrm { D O C } } } >$ went there with friends for lunch. Food is average ,not impressive. renovation is really stylish though. ${ \sqrt { \mathrm { D O C } } } >$ my parents really like this buffet. its actually pretty decent. the decor and unique and equisite and adds to the atmosphere. theres a strangeness to it it makes you feel like your on vacation or something. hard to explain. the food and variety is good. and lobster, well how can you complain. all.in all hapoy experience everytime ive been there. my only complaint would be theres this stupid rule about ordering tea and not being able to get more than one glass to share with the table. like what the fcuk is that? to me thats just cheap and how much tea can one family drink anyway, isnt the idea to fill up on food, why would they worry about people taking advantage of tea. lol. ${ < } I \mathrm { D O C } { > }$ Wow is the first word that comes to mind about this place. Talk about everthing you can get in a Chinese restaurant but with a twist, there is also a Sushi bar which loved sushi is one of my fav go to fast food. By far one of the BEST buffets i have been to in a while . I am going to sit here and enjoy this moment. While i dig my fork in a bowl of sticky rice and savor this moment. ${ \angle } / \mathrm { D O C } >$ The ambiance is great here, food is replenished more frequently than other buffet places, so you don’t find food sitting out for two long and end up being dry and disgusting. Though I believe the sister restaurant offers a bit more variety.
+
+Unsupervised Abstractive Summary: Predicted Rating $\mathbf { \lambda } = 4$   
+Sushi is good and not too pricey. I’m not a big fan of the food, but the food is great . They have a nice selection of dishes and different presentations. I would recommend this place to anyone who likes spicy food but not in a hurry to get a good meal. Very good value for the money.

parse/train/BJxgz2R9t7/BJxgz2R9t7.md

@@ -0,0 +1,296 @@
+# LEARNING TO SOLVE CIRCUIT-SAT:AN UNSUPERVISED DIFFERENTIABLE APPROACH
+
+Saeed Amizadeh, Sergiy Matusevych, Markus Weimer   
+Microsoft   
+Redmond, WA 98052   
+{saamizad,sergiym,Markus.Weimer}@microsoft.com
+
+# ABSTRACT
+
+Recent efforts to combine Representation Learning with Formal Methods, commonly known as Neuro-Symbolic Methods, have given rise to a new trend of applying rich neural architectures to solve classical combinatorial optimization problems. In this paper, we propose a neural framework that can learn to solve the Circuit Satisfiability problem. Our framework is built upon two fundamental contributions: a rich embedding architecture that encodes the problem structure, and an end-to-end differentiable training procedure that mimics Reinforcement Learning and trains the model directly toward solving the SAT problem. The experimental results show the superior out-of-sample generalization performance of our framework compared to the recently developed NeuroSAT method.
+
+# 1 INTRODUCTION
+
+Recent advances in neural network models for discrete structures have given rise to a new field in Representation Learning known as the Neuro-Symbolic methods. Generally speaking, these methods aim at marrying the classical symbolic techniques in Formal Methods and Computer Science to Deep Learning in order to benefit both disciplines. One of the most exciting outcomes of this marriage is the emergence of neural models for learning how to solve the classical combinatorial optimization problems in Computer Science. The key observation behind many of these models is that in practice, for a given class of combinatorial problems in a specific domain, the problem instances are typically drawn from a certain (unknown) distribution. Therefore if a sufficient number of problem instances are available, then in principle, Statistical Learning should be able to extract the common structures among these instances and produce meta-algorithms (or models) that would, in theory, outperform the carefully hand-crafted algorithms.
+
+There have been two main approaches to realize this idea in practice. In the first group of methods, the general template of the solver algorithm (which is typically the greedy strategy) is directly imported from the classical heuristic search algorithm, and the Deep Learning component is only tasked to learn the optimal heuristics within this template. In combination with Reinforcement Learning, such strategy has been shown to be quite effective for various NP-complete problems – e.g. Khalil et al. (2017). Nevertheless, the resulted model is bounded by the greedy strategy, which is sub-optimal in general. The alternative is to go one step further and let Deep Learning figure out the entire solution structure from scratch. This approach is quite attractive as it allows the model not only learn the optimal (implicit) decision heuristics but also the optimal search strategies beyond the greedy strategy. However, this comes at a price: training such models can be quite challenging! To do so, a typical candidate is Reinforcement Learning (Policy Gradient, in specific), but such techniques are usually sample inefficient – e.g. Bello et al. (2016). As an alternative method for training, more recently Selsam et al. (2018) have proposed using the latent representations learned for the binary classification of the Satisfiability (SAT) problem to actually produce a neural SAT solver model. Even though using such proxy for learning a SAT solver is an interesting observation and provides us with an end-to-end differentiable architecture, the model is not directly trained toward solving a SAT problem (unlike Reinforcement Learning). As we will see later in this paper, that can indeed result in poor generalization and sub-optimal models.
+
+In this paper, we propose a neural Circuit-SAT solver framework that effectively belongs to the second class above; that is, it learns the entire solution structure from scratch. More importantly, to train such model, we propose a training strategy that, unlike the typical Policy Gradient, is differentiable end-toend, yet it trains the model directly toward the end goal (similar to Policy Gradient). Furthermore, our proposed training strategy enjoys an Explore-Exploit mechanism for better optimization even though it is not exactly a Reinforcement Learning approach.
+
+The other aspect of building neural models for solving combinatorial optimization problems is how the problem instance should be represented by the model. Using classical architectures like RNNs or LSTMs completely ignores the inherent structure present in the problem instances. For this very reason, there has been recently a strong push to employ structure-aware architectures such as different variations of neural graph embedding. Most neural graph embedding methodologies are based on the idea of synchronously propagating local information on an underlying (undirected) graph that represents the problem structure. The intuition behind using local information propagation for embedding comes from the fact that many original combinatorial optimization algorithms can actually be seen propagating information. In our case, since we are dealing with Boolean circuits and circuit are Directed Acyclic Graphs (DAG), we would need an embedding architecture that take into account the special architecture of DAGs (i.e. the topological order of the nodes). In particular, we note that in many DAG-structured problems (such as circuits, computational graphs, query DAGs, etc.), the information is propagated sequentially rather than synchronously, hence a justification to have sequential propagation for the embedding as well. To this end, we propose a rich embedding architecture that implements such propagation mechanism for DAGs. As we see in this paper, our proposed architecture is capable of harnessing the structural information in the input circuits. To summarize, our contributions in this work are three-fold:
+
+(a) We propose a general, rich graph embedding architecture that implements sequential propagation for DAG-structured data.   
+(b) We adapt our proposed architecture to design a neural Circuit-SAT solver which is capable of harnessing structural signals in the input circuits to learn a SAT solver.   
+(c) We propose a training strategy for our architecture that is end-to-end differentiable, yet similar to Reinforcement Learning techniques, it directly trains our model toward solving the SAT problem with an Explore-Exploit mechanism.
+
+The experimental results show the superior performance of our framework especially in terms of generalizing to new problem domains compared to the baseline.
+
+# 2 RELATED WORK
+
+Deep learning on graph-structured data has recently become a hot topic in the Machine Learning community under the general umbrella of Geometric Deep Learning Bronstein et al. (2017). Based on the assumptions they make, these models typically divide into two main categories. In the first category, the graph-structured datapoints are assumed to share the same underlying graph structure (aka the domain) and only differ based on the feature values assigned to each node or edge. The methods in this category operate in both the spatial and the frequency domains; for example, Spectral CNN Bruna et al. (2013), Graph CNN Defferrard et al. (2016), Graph Neural Network Scarselli et al. (2009) and Covariant Compositional Networks Kondor et al. (2018). In the second category on the other hand, each example in the training data has its own domain (graph structure). Since the domain is varying across datapoints, these other methods mostly operate in the spatial domain and typically can be seen as the generalization of the classical CNNs (e.g.MoNet Monti et al. (2017)) or the classical RNNs (e.g.TreeLSTM Tai et al. (2015), DAG-RNN Baldi & Pollastri (2003); Shuai et al. (2016)) or both (e.g.GGS-NN Li et al. (2015)) to the graph domain. In this paper, we extend the single layer DAG-RNN model for DAG-structured data Baldi & Pollastri (2003); Shuai et al. (2016) to the more general deep version with Gated Recurrent Units, where each layer processes the input DAG either in the forward or the backward direction.
+
+On the other hand, the application of Machine Learning (deep learning in specific) to logic and symbolic computation has recently emerged as a bridge between Machine Learning and the classical Computer Science. While works such as Evans et al. (2018); Arabshahi et al. (2018) have shown the effectiveness of (recursive) neural networks in modeling symbolic expressions, others have taken one step further and tried to learn approximate algorithms to solve symbolic NP-complete problems Khalil et al. (2017); Bello et al. (2016); Vinyals et al. (2015). In particular, as opposed to black box methods (e.g. Bello et al. (2016); Vinyals et al. (2015)), Khalil et al. Khalil et al. (2017) have shown that by incorporating the underlying graph structure of a NP-hard problem, efficient search heuristics can be learned for the greedy search algorithm. Although working in the context of greedy search introduces an inductive bias that benefits the sample efficiency of the framework, the resulted algorithm is still bounded by the sub-optimality of the greedy search. More recently, Selsal et al. Selsam et al. (2018) have introduced the NeuroSAT framework - a deep learning model aiming at learning to solve the Boolean Satisfiability problem (SAT) from scratch without biasing it toward the greedy search. In particular, they have primarily approached the SAT problem as a binary classification problem and proposed a clustering-based post-processing analysis to find a SAT solution from the latent representations extracted from the learned classifier. Although, they have shown the empirical merits of their proposed framework, it is not clear why the proposed post-processing clusetring should find the SAT solution without being explicitly trained toward that goal. In this paper, we propose a deep learning framework for the Circuit-SAT problem (a more general form of the SAT problem), but in contrast to NeuroSAT, our model is directly trained toward finding SAT solutions without requiring to see them in the training sample.
+
+# 3 DAG EMBEDDING
+
+In this section, we formally formulate the problem of learning on DAG-structured data and propose a deep learning framework to approach the problem. It should be noted that even though this framework has been developed for DAGs, the underlying dataset can be a general graph as long as an explicit ordering for the nodes of each graph is available. This ordering is naturally induced by the topological sort algorithm in DAGs or can be imposed on general undirected graphs to yield DAGs.
+
+# 3.1 NOTATIONS AND DEFINITIONS
+
+Let $G = \langle V _ { G } , E _ { G } \rangle$ denote a Directed Acyclic Graph (DAG). We assume the the set of nodes of $G$ are ordered according to the topological sort of the DAG. For any node $v \in V _ { G }$ , $\pi _ { G } ( v )$ represents the set of direct predecessors of $v$ in $G$ . Also for a given DAG $G$ , we define the reversed DAG, $G ^ { r }$ with the same set of nodes but reversed edges. When topologically sorted, the nodes of $G ^ { r }$ appear in the reversed order of those of $G$ . Furthermore, for a given $G$ , let $\dot { \mu } _ { G } : V _ { G } \mapsto \mathbb { R } ^ { d }$ be a $d$ -dimensional vector function defined on the nodes of $G$ . We refer to $\mu _ { G }$ as a $D A G$ function – i.e. a function that is defined on a DAG. Note that the notation $\mu _ { G }$ implicitly induces the DAG structure $G$ along with the vector function defined on the DAG. Figure 1(a) shows an example DAG function with $d = 3$ . Finally, let $\mathcal { G } ^ { d }$ denote the space of all possible $d$ -dimensional functions $\mu _ { G }$ (along with their underlying graphs $G$ ). We define the parametric functional $\mathcal { F } _ { \pmb { \theta } } : \mathcal { G } ^ { d } \mapsto \mathcal { O }$ that maps any function $\mu _ { G }$ (defined on some DAG $G$ ) in $\mathcal { G } ^ { d }$ to some output space $\mathcal { O }$ .
+
+# 3.2 THE GENERAL MODEL
+
+The next step is to define the mathematical form of the functional $\mathcal { F } _ { \theta }$ . In this work, we propose:
+
+$$
+\mathcal { F } _ { \pmb { \theta } } ( \mu _ { G } ) = \mathcal { C } _ { \pmb { \alpha } } \bigg ( \mathcal { P } \big ( \mathcal { E } _ { \beta } ( \mu _ { G } ) \big ) \bigg )
+$$
+
+Intuitively, $\mathcal { E } _ { \beta } : \mathcal { G } ^ { d } \mapsto \mathcal { G } ^ { q }$ is the embedding function that maps the input $d$ -dimensional DAG functions into a $q$ -dimensional DAG function space. Note that the embedding function in general may transform both the underlying DAG size/structure as well as the the DAG function defined on it. In this paper, however, we assume it only transforms the DAG function and keeps the input DAG structure intact. Once the DAG is embedded into the new space, we apply the fixed pooling function $\mathcal { P } : \mathcal { G } ^ { q } \mapsto \mathcal { G } ^ { q }$ on the embedded DAG function to produce a (possibly) aggregated version of it. For example, if we are interested in DAG-level predictions, $\mathcal { P }$ can be average pooling across all nodes of the input DAG to produce a singleton DAG; whereas, in the case of node-level predictions, $\mathcal { P }$ is simply the Identity function. In this paper, we set $\mathcal { P }$ to retrieve only the sink nodes in the input DAG. Finally, the classification function $\mathcal { C } _ { \alpha } : \mathcal { G } ^ { q } \mapsto \mathcal { O }$ is applied on the aggregated DAG function to produce the final prediction output in $\mathcal { O }$ . In this work, we set $\mathcal { C } _ { \alpha }$ to be a multi-layer neural network. The tuple $\pmb \theta = \langle \pmb \alpha , \beta \rangle$ identifies all the free parameters of the model.
+
+# 3.3 THE DAG EMBEDDING LAYER
+
+The (supervised) embedding of graph-based data into the traditional vector spaces has been a hot topic recently in the Machine Learning community Li et al. (2015); Shuai et al. (2016); Tai et al. (2015). Many of these frameworks are based on the key idea of representing each node in the input graph by a latent vector called the node state and update these latent states via an iterative (synchronous) propagation mechanism that takes the graph structure into account. Two of these methodologies that are closely related to the proposed framework in this paper are the Gated Graph Sequence Neural Networks (GGS-NN) Li et al. (2015) and DAG Recurrent Neural Networks (DAG-RNN) Shuai et al. (2016). While GGS-NNs apply multi-level Gated Recurrent Unit (GRU) like updates in an iterative propagation scheme on general (undirected) graphs, DAG-RNNs apply simple RNN logic in a one-pass, sequential propagation mechanism from the input DAG’s source nodes to its sink nodes.
+
+Our proposed framework is built upon the DAG-RNN framework Shuai et al. (2016) but it enriches this framework further by incorporating key ideas from GGS-NNs Li et al. (2015), Deep RNNs Pascanu et al. (2013) and sequence-to-sequence learning Sutskever et al. (2014). Before we explain our framework, it is worth noting that assiging input feature/state vectors to each node is equivalent to defining a DAG function in our framework. For the sake of notational simplicity, for the input DAG function $\mu _ { G }$ , we define the $d$ -dimensional node feature vector $\mathbf { \boldsymbol { x } } _ { v } = \mu _ { G } ( \bar { \boldsymbol { v } } )$ and the $q$ -dimensional node state vector $\boldsymbol { h _ { v } } = \delta _ { G } ( \boldsymbol { v } )$ for some unknown DAG function $\delta _ { G } : V _ { G } \mapsto \mathbb { R } ^ { q }$ . Given the node feature vectors $\scriptstyle { \mathbf { { \mathit { x } } } } _ { \mathit { v } }$ for an input DAG, the update rule for the state vector at each node is defined as:
+
+$$
+\pmb { h _ { v } } = G R U ( \pmb { x _ { v } } , \pmb { h _ { v } ^ { \prime } } ) , \mathrm { w h e r e } \pmb { h _ { v } ^ { \prime } } = \pmb { \mathcal { A } } \big ( \{ \pmb { h _ { u } } \ | \ u \in \pi ( v ) \} \big )
+$$
+
+where $G R U ( . )$ is the standard GRU Chung et al. (2014) function applied on the input vector at node $v$ and the aggregated state of its direct predecessors which in turn is computed by the aggregator function $\mathcal { A } : 2 ^ { V _ { G } ^ { \smile } } \mapsto \mathbb { R } ^ { q }$ . The aggregator function is defined as a tunable deep set function Zaheer et al. (2017) with free parameters that is invariant to the permutation of its inputs. The main difference between these proposed updates rules and the ones in DAG-RNN is in DAG-RNN, we have the simple RNN logic instead of GRU, and the aggregation logic is simply (fixed) summation.
+
+By applying the update logic in equation 2 sequentially on the nodes of the input DAG processed in the topological sort order, we compute the state vector $h _ { v }$ for all nodes of $G$ in one pass. This would complete the one layer (forward) embedding of the input DAG function, or $\mathcal { E } _ { \beta } ( \mu _ { G } ) = \delta _ { G }$ . Note that the same way that DAG-RNNs are the generalization of RNNs on sequences to DAGs, our proposed one-layer embedding can be seen as the generalization of GRU-NNs on sequences to DAGs.
+
+Furthermore, we introduce the reversed layers (denoted by ${ \mathcal { E } } ^ { r }$ ) that are similar to the regular forward layers except that the input DAG is processed in the reversed order. Alternatively, reversed layers can be seen as regular layers that process the reversed version of the input DAG $G ^ { r }$ ; that is, $\mathcal { E } ^ { r } ( \mu _ { G } ) \equiv$ $\mathcal { E } ( \mu _ { G ^ { r } } )$ . The main reason we have introduced reversed layers in our framework is because in the regular forward layers, the state vector for each node is only affected by the information flowing from its ancestor nodes; whereas, the information from the descendant nodes can also be highly useful for the learning task in hand. The reversed layers provide such information for the learning task. Furthermore, the introduction of reversed layers is partly motivated by the successful application of processing sequences backwards in sequence-to-sequence learning Sutskever et al. (2014). Sequences can be seen as special-case linear DAGs; as a result, reversed layers can be interpreted as the generalized version of reversing sequences.
+
+# 3.4 DEEP-GATED DAG RECURSIVE NEURAL NETWORKS
+
+The natural extension of the one-layer embedding is the stacked $L$ -layer version where the $i$ th layer has its own parameters $\beta _ { i }$ and output DAG function dimensionality $q _ { i }$ . Furthermore, the stacked $L$ layers can be sequentially applied $T$ times in the recurrent fashion to generate the final embedding:
+
+$$
+\begin{array} { r l } & { \mathcal { E } _ { \beta } ( \mu _ { G } ) \equiv \mathcal { E } _ { \beta } ^ { T } ( \mu _ { G } ) , \mathrm { w h e r e } \ \mathcal { E } _ { \beta } ^ { t } ( \mu _ { G } ) = \mathcal { E } _ { s t a c k } \big ( P r o j _ { H } ( \mathcal { E } _ { \beta } ^ { t - 1 } ( \mu _ { G } ) ) \big ) , \forall t \in 2 . . T } \\ & { \qquad \mathcal { E } _ { \beta } ^ { 1 } ( \mu _ { G } ) = \mathcal { E } _ { s t a c k } ( \mu _ { G } ) } \\ & { \qquad \mathrm { s . t . } \ \mathcal { E } _ { s t a c k } = \mathcal { E } _ { \beta _ { L } } \circ \mathcal { E } _ { \beta _ { L - 1 } } \circ \dots \circ \mathcal { E } _ { \beta _ { 1 } } } \end{array}
+$$
+
+where $\beta = \langle \beta _ { 1 } , . . . , \beta _ { L } , H \rangle$ is the list of the parameters and $P r o j _ { H } : \mathcal { G } ^ { q _ { L } } \mapsto \mathcal { G } ^ { d }$ is a linear projection with the projection matrix ${ \cal H } _ { d \times q _ { L } }$ that simply adjusts the output dimensionality of $\mathcal { E } _ { s t a c k }$ so it can be fed back to $\mathcal { E } _ { s t a c k }$ as the input. In our experiments, we have found that by letting $T > 1$ , we can significantly improve the accuracy of our models without introducing more trainable parameters. In practice, we fix the value of $T$ during training and increase it during testing to achieve better accuracy. Also note that the $L$ stacked layers in $\mathcal { E } _ { s t a c k }$ can be any permutation of regular and reversed layers. We refer to this proposed framework as Deep-Gated DAG Recursive Neural Networks or DG-DAGRNN for short. Figure 1(b) shows an example 2-layer DG-DAGRNN model with one forward layer followed by a reversed layer.
+
+![](images/c607b84872e5782753ff11c7410e74e8e99764a46d1e4a793a564acd51d6e3e3.jpg)  
+Figure 1: (a) A toy example input DAG function $\mu _ { G }$ , (b) a DG-DAGRNN model that processes the input in (a) using two sequential DAG embedding layers: a forward layer followed by a reverse layer. The solid red and green arrows show the flow of information within each layer while the black arrows show the feed-forward flow of information in between the layers. Also, the dotted blue arrows show the recurrent flow of information from the last embedding layer back to the first one.
+
+# 4 APPLICATION TO THE CIRCUIT-SAT PROBLEM
+
+The Circuit Satisfiability problem (aka Circuit-SAT) is a fundamental NP-complete problem in Computer Science. The problem is defined as follows: given a Boolean expression consists of Boolean variables, parentheses, and logical gates (specifically And $\wedge$ , Or $\vee$ and Not $\sqsupset$ ), find an assignment to the variables such that it would satisfy the original expression, aka a solution. If the expression is not satisfiable, it will be labeled as UNSAT. Moreover, when represented in the circuit format, Boolean expressions can aggregate the repetitions of the same Boolean sub-expression in the expression into one node in the circuit. This is also crucial from the learning perspective as we do not want to learn two different representations for the same Boolean sub-expression.
+
+In this section, we apply the framework from the previous section to learn a Circuit-SAT solver merely from data. More formally, a Boolean circuit can be modeled as a DAG function $\mu _ { G }$ with each node representing either a Boolean variable or a logical gate. In particular, we have $\mu _ { G } \colon V _ { G } \mapsto \mathbb { R } ^ { 4 }$ defined as $\mu _ { G } ( v ) = \mathrm { O n e - H o t } ( t y p e ( v ) )$ , where $t y p e ( v ) \in \{ \mathbf { A n d } , \mathbf { O r } , \mathbf { N o t } , \mathbf { V a r i a b l e } \}$ . All the source nodes in a circuit $\mu _ { G }$ have type Variable. Moreover, each circuit DAG has only one sink node (the root node of the Boolean expression).
+
+Similar to Selsam et al. (2018), we could also approach the Circuit-SAT problem from two different angles: (1) predicting the circuit satisfiability problem as a binary classification problem, and (2) solving the Circuit-SAT problem directly by generating a solution if the input circuit is indeed SAT. In Selsam et al. (2018), solving the former is the prerequisite for solving the latter. However, that is not the case in our proposed model and since we are interested to actually solve the SAT problems, we do not focus on the binary classification problem. Nevertheless, our model can be easily adapted for SAT classification, as illustrated in Appendix A.
+
+# 4.1 NEURAL CIRCUIT-SAT SOLVER
+
+Learning to solve SAT problems (i.e.finding a satisfying assignment) is indeed a much harder problem than SAT/UNSAT classification. In the NeuroSAT framework, Selsam et al. (2018), the authors have proposed a post-processing unsupervised procedure to decode a solution from the latent state representations of the Boolean literals. Although this approach works empirically for many SAT problems, it is not clear that it would also work for the Circuit-SAT problems. But more importantly, it is not clear why this approach should decode the SAT problems in the first place because the objective function used in Selsam et al. (2018) does not explicitly contain any component for solving SAT problems; in fact, the decoding procedure is added as a secondary analysis after training. In other words, the model is not optimized toward actually finding SAT assignments.
+
+In contrast, in this paper, we pursue a completely different strategy for training a neural Circuit-SAT solver. In particular, using the DG-DAGRNN framework, we learn a neural functional $\mathcal { F } _ { \theta }$ on the space of circuits $\mu _ { G }$ such that given an input circuit, it would directly generate a satisfying assignment for the circuit if it is indeed SAT. Moreover, we explicitly train $\mathcal { F } _ { \theta }$ to generate SAT solutions without requiring to see any actual SAT assignment during training. Our proposed strategy for training $\mathcal { F } _ { \theta }$ is reminiscent of Policy Gradient methods in Deep Reinforcement Learning Arulkumaran et al. (2017).
+
+The Solver Network. We start with characterizing the components of $\mathcal { F } _ { \theta }$ . First, the embedding function $\mathcal { E } _ { \beta }$ is set to be a multi-layer recursive embedding as in equation 3 with interleaving regular forward and reversed layers making sure that the last layer is a reversed layer so that we can read off the final outputs of the embedding from the Variable nodes (i.e. the sink nodes of the reversed DAG). The classification function $\mathcal { C } _ { \alpha }$ is set to be a MLP with ReLU activation function for the hidden layers and the Sigmoid activation for the output layer. The output space here encodes the soft assignment (i.e. in range $[ 0 , 1 ] )$ to the corresponding variable node in the input circuit. We also refer to $\mathcal { F } _ { \theta }$ as the solver or the policy network.
+
+The Evaluator Network. Furthermore, for any given circuit $\mu _ { G }$ , we define the soft evaluation function $\mathcal { R } _ { G }$ as a DAG computational graph that shares the same topology $G$ with the circuit $\mu _ { G }$ except that the And nodes are replaced by the smooth min function, the Or nodes by the smooth max function and the Not nodes by $\mathcal { N } ( z ) = 1 - z$ function, where $z$ is the input to the Not node. The smooth min and max functions are defined as:
+
+$$
+S _ { m a x } ( a _ { 1 } , a _ { 2 } , . . . , a _ { n } ) = \frac { \sum _ { i = 1 } ^ { n } a _ { i } e ^ { a _ { i } / \tau } } { \sum _ { i = 1 } ^ { n } e ^ { a _ { i } / \tau } } , S _ { m i n } ( a _ { 1 } , a _ { 2 } , . . . , a _ { n } ) = \frac { \sum _ { i = 1 } ^ { n } a _ { i } e ^ { - a _ { i } / \tau } } { \sum _ { i = 1 } ^ { n } e ^ { - a _ { i } / \tau } } , I _ { m } ( a _ { 1 } , a _ { 2 } , . . . , a _ { n } ) = \frac { \sum _ { i = 1 } ^ { n } a _ { i } e ^ { - a _ { i } / \tau } } { \sum _ { i = 1 } ^ { n } e ^ { - a _ { i } / \tau } } .
+$$
+
+where $\tau \geq 0$ is the temperature. For $\tau = + \infty$ , both $S _ { m a x } ( )$ and $S _ { m i n } ( )$ are the arithmetic mean functions. As $\tau  0$ , we have $S _ { m a x } ( \ v r ) \to \mathrm { m a x } ( \ v r )$ and $S _ { m i n } ( \ l )  \mathrm { m i n } ( \ l )$ . One can also show that $\forall a = ( a _ { 1 } , . . . , a _ { n } ) : \operatorname* { m i n } ( a ) < S _ { m i n } ( \dot { a } ) < S _ { m a x } \big ($ a) < max(a). More importantly, as opposed to the $\operatorname* { m i n } ( )$ and max() functions, their smooth versions are fully differentiable w.r.t. all of their inputs.
+
+As its name suggests, the soft evaluation function evaluates a soft assignment (i.e. in [0, 1]) to the variables of the circuit. In particular, at a low enough temperature, if for a given input assignment, $\mathcal { R } _ { G }$ yields a value strictly greater than 0.5, then that assignment (or its hard counterpart) can be seen as a satisfying solution for the circuit. We also refer to $\mathcal { R } _ { G }$ as the evaluator or the reward network. Note that the evaluator network does not have any trainable parameter.
+
+Encoding logical expressions into neural networks is not new per se as there has been recently a push to enrich deep learning with symbolic computing Hu et al. (2016); Xu et al. (2017). What are new in our framework, however, are two folds: (a) each graph example in our dataset induces a different evaluation network as opposed to having one fixed network for the entire dataset, and (b) by encoding the logical operators as smooth min and max functions, we provide a more efficient framework for back-propagating the gradients and speeding up the learning as the result, as we will see shortly.
+
+The Optimization. Putting the two pieces together, we define the satisfiability function $S _ { \theta } : { \mathcal { G } } \mapsto$ $[ 0 , 1 ]$ as: $S _ { \pmb \theta } ( \mu _ { G } ) = \mathcal { R } _ { G } ( \bar { \mathcal { F } } _ { \pmb \theta } ( \mu _ { G } ) )$ . Intuitively, the satisfiability function uses the solver network to produce an assignment for the input circuit and then feeds the resulted assignment to the evaluator network to see if it satisfies the circuit. We refer to the final output of $\scriptstyle { \mathcal { S } } _ { \theta }$ as the satisfiability value for the input circuit, which is a real number in [0, 1]. Having computed the satisfiability value, we define the loss function as the smooth Step function:
+
+$$
+{ \mathcal { L } } ( s ) = { \frac { ( 1 - s ) ^ { \kappa } } { ( 1 - s ) ^ { \kappa } + s ^ { \kappa } } }
+$$
+
+where $s = { \cal S } _ { \theta } ( \mu _ { G } )$ and $\kappa \geq 1$ is a constant. By minimizing the loss function in equation 7, we push the solver network to produce an assignment that yields a higher satisfiability value $ { \boldsymbol { S } } _ {  { \boldsymbol { \theta } } } (  { \boldsymbol { \mu } } _ { G } )$ For satisfiable circuits this would eventually result in finding a satisfiable assignment for the circuit. However, if the input circuit is UNSAT, the maximum achievable value for $\scriptstyle { \mathcal { S } } _ { \theta }$ is 0.5 as we have shown in Appendix B. In practice though, the inclusion of UNSAT circuits in the training data slows down the training process mainly because the UNSAT circuits keep confusing the solver network as it tries hard to find a SAT solution for them. For this very reason, in this scheme, we only train on SAT examples and exclude the UNSAT circuits from training. Nevertheless, if the model has enough capacity, one can still include the UNSAT examples and pursue the training as a pure unsupervised learning task since the true SAT/UNSAT labels are not used anywhere in equation 7.
+
+Moreover, the loss function in equation 7 has a nice property of having higher gradients for satisfiability values close to 0.5 when $\kappa > 1$ (we set $\kappa = 1 0$ in our experiments). This means that the gradient vector in backpropagation is always dominated by the examples closer to the decision boundary. In practice, that would mean that the training algorithm immediately in the beginning pushes the easier examples in the training set (with satisfiability values close to 0.5) to the SAT region $( > 0 . 5 )$ with a safety margin from 0.5. As the training progresses, harder examples (with satisfiability values close to 0) start moving toward the SAT region.
+
+As mentioned before, the proposed learning scheme in this section can be seen as a variant of Policy Gradient methods, where the solver network represents the policy function and the evaluator network acts as the reward function. The main difference here is that in our problem the mathematical form of the reward function is fully known and is differentiable so the entire pipeline can be trained using backpropagation in an end-to-end fashion to maximize the total reward over the training sample.
+
+Exploration vs. Exploitation. The reason we use the smooth min and max functions in the evaluator network instead of the actual $\operatorname* { m i n } ( )$ and $\operatorname* { m a x } ( )$ is that in a min-max circuit, the gradient vector of the output of the circuit w.r.t. its inputs has at most one non-zero entry 1. That is, the circuit output is sensitive to only one of its inputs in the case of infinitesimal changes. For fixed input values, we refer to this input as the active input and to the path from the active input to the output as the active path. In the case of a min-max evaluator, the gradients flow back only through the active path of the evaluator network forcing the solver network to change such that it can satisfy the input circuit through its active path only. This strategy however is quite myopic and, as we observed empirically, leads to slow training and sub-optimal solutions. To avoid this effect, we use the smooth min and max functions in the evaluator network to allow the gradients to flow through all paths in the input circuit. Furthermore, in the beginning of the training we start with a high temperature value to let the model explore all paths in the input circuits for finding a SAT solution. As the training progresses, we slowly anneal the temperature toward 0 so that the model exploits more active path(s) for finding a solution. One annealing strategy is to let $\tau = t ^ { - \epsilon }$ , where $t$ is timestep and $\epsilon$ is the annealing rate. In our experiments we set $\epsilon = 0 . 4$ . It should be noted that at the test time, the smooth min and max functions are replaced by their non-smooth versions.
+
+Prediction. Given a test circuit $\mu _ { G }$ , we evaluate $s = \mathcal { S } _ { \pmb { \theta } } ( \mu _ { G } ) = \mathcal { R } _ { G } \big ( \mathcal { F } _ { \pmb { \theta } } ( \mu _ { G } ) \big )$ . If $s > 0 . 5$ then the circuit is classified as SAT and the SAT solution is provided by $\mathcal { F } _ { \pmb { \theta } } ( \mu _ { G } )$ . Otherwise, the circuit is classified as UNSAT. This way, unlike SAT classification, we predict SAT for a given circuit only if we have already found a SAT solution for it. In other words, our model never produces false positives. We have formally proved this in Appendix B. Moreover, at the prediction time, we do not need to set the number of recurrences $T$ in equation 3 to the same value we used for training. In fact, we have observed by letting $T$ to be variable on the per example basis, we can improve the model accuracy quite significantly at the test time.
+
+# 5 EXPERIMENTAL EVALUATION
+
+The baseline method we have compared our framework to is the NeuroSAT model by Selsam et al. (2018). Like most classical SAT solvers, NeuroSAT assumes the input problem is given in the Conjunctive Normal Form (CNF). Even though that is a fair assumption in general, in some cases, the input does not naturally come as CNF. For instance, in hardware verification, the input problems are often in the form of circuits. One can indeed convert the circuit format into CNF in polynomial time using Tseitin transformation. However, such transformation will introduce extra variables (i.e. the derived variables) which may further complicate the problem for the SAT solver. More importantly, as a number of works in the SAT community have shown, such transformations typically lose the structural information embedded in the circuit format, which otherwise can be a rich source of information for the SAT solver, Thiffault et al. (2004); Andrews (2002); Biere (2008); Fu & Malik (2007); Velev (2007). As a result, there has been quite an effort in the classical SAT community to develop SAT solvers that directly work with the circuit format Thiffault et al. (2004); Jain & Clarke (2009). In the similar vein, our neural framework for learning a SAT solver enables us to harness such structural signals in learning by directly consuming the circuit format. That contrasts the NeuroSAT approach which cannot in principle benefit from such structural information.
+
+Despite this clear advantage of our framework to NeuroSAT, in this paper, we assume the (raw) input problems come in CNF, just so we can make a fair comparison to NeuroSAT. Instead for our method, we propose to use pre-processing methods to convert the input CNF into circuit that has the potential of injecting structural information into the circuit structure. In particular, if available, one can in principle encode problem-specific heuristics into the structure while building the circuit. For example, if there is a variable ordering heuristic available for a specific class of SAT problems, it can be used to build that target circuit in a certain way, as discussed in Appendix C. Note that we could just consume the original CNF; after all, CNF is a (flat) circuit, too. But as we empirically observed, that would negatively affect the results, which again highlights the fact that our proposed framework has been optimized to utilize circuit structure as much as possible.
+
+Both our method and NeuroSAT require a large training sample size for moderate size problems. The good news is both methods can effectively be trained on an infinite stream of randomly generated problems in real-world applications. However, since we ran our experiments only on one GPU with limited memory, we had to limit the training sample size for the purpose of experimentation. This in turn restricts the maximum problem sizes we could train both models on. Nevertheless, our method can generalize pretty well to out-of-sample SAT problems with much larger sizes, as shown below.
+
+# 5.1 RANDOM $k$ -SAT
+
+We have used the generation process proposed in the NeuroSAT paper Selsam et al. (2018) to generate random $k$ -SAT CNF pairs (with $k$ stochastically set according to the default settings in Selsam et al. (2018)). These pairs are then directly fed to NeuroSAT for training. For our method, on the other hand, we first need to convert these CNFs into circuits2. In Appendix C, we have described the details of this conversion process.
+
+Experimental Setup: We have trained a DG-DAGRNN model (i.e. our framework) and a NeuroSAT model on a dataset of 300K SAT and UNSAT pairs generated according to the scheme proposed in Selsam et al. (2018). The number of Boolean variables in the problems in this dataset ranges from 3 to 10. We have designed both models to have roughly $\sim 1 8 0 \mathrm { K }$ tunable parameters. In particular our model has two DAG embedding layers: a forward layer followed by a reversed layer, each with the embedding dimension $q = 1 0 0$ . The classifier is a 2-layer MLP with hidden dimensionality 30. The aggregator function $\boldsymbol { \mathcal { A } } ( \cdot )$ consists of two 2-layer MLPs, each with hidden dimensionality 50. For training, we have used the Adam optimization algorithm with learning rate of $1 0 ^ { - 5 }$ , weight decay of $1 0 ^ { - \bar { 1 } 0 }$ and gradient clipping norm of 0.65. We have also applied a dropout mechanism for the aggregator function during training with the rate of $2 0 \%$ . For the NeuroSAT model, we have used the default hyper-parameter settings proposed in Selsam et al. (2018). Finally, since our model does not produce false positives, we have only included satisfiable examples in the test data for all experiments.
+
+In-Sample Results: Once we trained the two models, the main performance metric we measure is the percentage of SAT problems in the test set that each model can actually find a SAT solution for.3 Figure 2 (Left) shows this metric on a test set from the same distribution for both our model and NeuroSAT as the number of recurrences (or propagation iterations for NeuroSAT) $T$ increases. Not surprisingly, both methods are able to decode more SAT problems as we increase $T$ . However, our method converges much faster than NeuroSAT (to a slightly smaller value). In other words, compared to NeuroSAT, our method requires smaller of number of iterations at the test time to decode SAT problems. We conjecture this is due to the fact the sequential propagation mechanism in DG-DAGRNN is more effective in decoding the structural information in the circuit format for the SAT problem than the synchronous propagation mechanism in NeuroSAT for the flat CNF.
+
+![](images/c58f4d0f03bb646ce981d50017f231db375fe60223fd8c34faee4630c361dd82.jpg)  
+Figure 2: (Left) In-Sample test results comparing between DG-DAGRNN and NeuroSAT, as the number of recurrence iterations $T$ increases. (Right) Out-of-Sample test results comparing the two methods when tested on much larger problems.
+
+Out-of-Sample Results: Furthermore, we evaluated both trained models on test datasets drawn from different distributions than the training data with much larger number of variables (20, 40, 60 and 80 variables, in particular). We let both models iteratively run on each test dataset until the test metric converges. Figure 2 (Right) shows the test metric for both methods on these datasets after convergence. As the results demonstrate, compared to that of our method, the performance of NeuroSAT declines faster as we increase the number variables during test time, with a significant margin. In other words, our method generalizes better to out-of-sample, larger problems during the test time. We attribute this to the fact that NeuroSAT is trained toward the SAT classification problem as a proxy to learn a solver. This may result in the classifier picking up certain features that are informative for classification of in-sample examples which are, otherwise, harmful (or useless at best) for learning a solver for out-of-sample examples. Our framework, on the other hand, simply does not suffer from such problem because it is directly trained toward solving the SAT problem.
+
+Time Complexity: We trained both our model and NeuroSAT for a day on a single GPU. To give an idea of the test time complexity, it took both our model and NeuroSAT roughly about 3s to run for 40 iterations on a single example of 20 variables. We also measured the time that it takes for a modern SAT Solver (MiniSAT here) to solve a similar example to be roughly about 0.7s in average. Despite this difference, our neural approach is way more prallelizable compared to modern solvers such that many examples can be solved concurrently in a single batch on GPU. For example, while it took MiniSAT 114min to solve a set of 10, 000 examples, it took our method only 8min to solve for the same set in a batch-processing fashion on GPU. This indeed shows another important advantage of our neural approach toward SAT solving in large-scale applications: the extreme parallelization.
+
+# 5.2 RANDOM GRAPH $k$ -COLORING
+
+To further evaluate the generalization performance of the trained models from the previous section, we have tested them on SAT problems coming from an entire different domain than $k$ -SAT problems. In particular, we have chosen the graph $k$ -coloring decision problem which belongs to the class of NP-complete problems. In short, given an undirected graph $G$ with $k$ color values, in graph $k$ -coloring decision problem, we seek to find a mapping from the graph nodes to the color set such that no adjacent nodes in the graph have the same color. This classical problem is reducible to SAT. Moreover, the graph topology in general contains valuable information that can be further injected into the circuit structure when preparing circuit representation for our model. Appendix D illustrates how we incorporate this information to convert instances of the graph $k$ -coloring problem into circuits. For this experiment, we have generated two different test datasets:
+
+Dataset-1: We have generated a diverse set of random graphs with number of nodes ranging between 6 and 10 and the edge percentage of $3 7 \%$ . The random graphs are evenly generated according to six distinct distributions: Erdos-Renyi, Barabasi-Albert, Power Law, Random Regular, Watts-Strogatz and Newman-Watts-Strogatz. Each generated graph is then paired with a random color number in $2 \leq k \leq 4$ to generate a graph $k$ -coloring instance. We only keep the SAT instances in the dataset.
+
+Dataset-2: We first generate random trees with the same number of nodes as Dataset-1. Then each tree is paired with a random color number in $2 \leq k \leq 4$ . Since the chromatic number of trees is 2, every single pair so far is SAT. Lastly, for each pair we keep adding random edges to the graph until it becomes UNSAT, then we remove the last added edge to make the instance SAT again and stop.
+
+Even though Dataset-1 has much higher coverage in terms of different graph distributions, Dataset2 contains harder SAT examples in general, simply because in average, it contains maximally constrained instances that are still SAT. We evaluated both our method and NeuroSAT (which were both trained on $k$ -SAT-3-10) on these test datasets. Our method could solve $4 8 \%$ and $2 7 \%$ of the SAT problems in Dataset-1 and Dataset-2, respectively. However, to our surprise, the same NeuroSAT model that generated the out-of-sample results on $k$ -SAT datasets in Figure 2, could not solve any of the SAT graph $k$ -coloring problems in Dataset-1 and Dataset-2, even after 128 propagation iterations. This does not match the results reported in Selsam et al. (2018) on graph coloring. We suspect different CNF formulations for the graph $k$ -coloring problem might be the cause behind this discrepancy, which would mean that NeuroSAT is quite sensitive to the change of problem distribution. Nevertheless, the final judgment remains open up to further investigations.
+
+In a separate effort, we tried to actually train a fresh NeuroSAT model on a larger versions of Dataset-1 and Dataset-2 which also included UNSAT examples. However, despite a significant decrease on the classification training loss, NeuroSAT failed to decode any of the SAT problems in the test sets. We attribute this behavior to the fact that NeuroSAT is dependent on learning a good SAT classifier that can capture the conceptual essence of SAT vs. UNSAT. As a result, in order to avoid learning superficial classification features, NeuroSAT restricts its training to a strict regime of SAT-UNSAT pairs, where the two examples in a pair only differ in negation of one literal. However, such strict regime can be only enforced in the random $k$ -SAT problems. For graph coloring, the closest strategy we could come up with was the one in Dataset-2, where the SAT-UNSAT examples in a pair only differ in an edge (which still translates to a couple of clauses in the CNF). This again signifies the importance of learning the solver directly rather than relying on a classification proxy.
+
+# 6 DISCUSSION
+
+In this paper, we proposed a neural framework for efficiently learning a Circuit-SAT solver. Our methodology relies on two fundamental contributions: (1) a rich DAG-embedding architecture that implements the sequential propagation mechanism on DAG-structured data and is capable of learning useful representations for the input circuits, and (2) an efficient training procedure that trains the DAGembedding architecture directly toward solving the SAT problem without requiring SAT/UNSAT labels in general. Our proposed training strategy is fully differentiable end-to-end and at the same time enjoys many features of Reinforcement Learning such as an Explore-Exploit mechanism and direct training toward the end goal.
+
+As our experiments showed, the proposed embedding architecture is able to harness structural information in the input DAG distribution and as a result solve the test SAT cases in a fewer number of iterations compared to the baseline. This would also allow us to inject domain-specific heuristics into the circuit structure of the input data to obtain better models for that specific domain. Moreover, our direct training procedure as opposed to the indirect, classification-based method in NeuroSAT enables our model to generalize better to out-of-sample test cases, as demonstrated by the experiments. This superior generalization got even more expressed as we transferred the trained models to a complete new domain (i.e. graph coloring). Furthermore, we argued that not only does direct training give us superior out-of-sample generalization, but it is also essential for the problem domains where we cannot enforce the strict training regime where SAT and UNSAT cases come in pairs with almost identical structures, as proposed by Selsam et al. (2018).
+
+Future efforts in this direction would include closely examining the SAT solver algorithm learned by our framework to see if any high-level knowledge and insight can be extracted to further aide the classical SAT solvers. Needless to say, this type of neural models have a long way to go in order to compete with industrial SAT solvers; nevertheless, these preliminary results are promising enough to motivate the community to pursue this direction.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Leonardo de Moura and Nikolaj Bjorner from Microsoft Research for the valuable feedback and discussions.
+
+# REFERENCES
+
+Peter B Andrews. An introduction to mathematical logic and type theory, volume 27. Springer Science & Business Media, 2002.
+
+Forough Arabshahi, Sameer Singh, and Animashree Anandkumar. Combining symbolic and function evaluation expressions in neural programs. arXiv preprint arXiv:1801.04342, 2018.
+
+Kai Arulkumaran, Marc Peter Deisenroth, Miles Brundage, and Anil Anthony Bharath. A brief survey of deep reinforcement learning. arXiv preprint arXiv:1708.05866, 2017.
+
+Pierre Baldi and Gianluca Pollastri. The principled design of large-scale recursive neural network architectures–dag-rnns and the protein structure prediction problem. Journal of Machine Learning Research, 4(Sep):575–602, 2003.
+
+Irwan Bello, Hieu Pham, Quoc V Le, Mohammad Norouzi, and Samy Bengio. Neural combinatorial optimization with reinforcement learning. arXiv preprint arXiv:1611.09940, 2016.
+
+Armin Biere. Picosat essentials. Journal on Satisfiability, Boolean Modeling and Computation, 4: 75–97, 2008.
+
+Armin Biere, Marijn Heule, Hans van Maaren, and Toby Walsh. Conflict-driven clause learning sat solvers. Handbook of Satisfiability, Frontiers in Artificial Intelligence and Applications, pp. 131–153, 2009.
+
+Michael M Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017.
+
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. arXiv preprint arXiv:1312.6203, 2013.
+
+Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.
+
+Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In Advances in Neural Information Processing Systems, pp. 3844–3852, 2016.
+
+Richard Evans, David Saxton, David Amos, Pushmeet Kohli, and Edward Grefenstette. Can neural networks understand logical entailment? arXiv preprint arXiv:1802.08535, 2018.
+
+Zhaohui Fu and Sharad Malik. Extracting logic circuit structure from conjunctive normal form descriptions. In VLSI Design, 2007. Held jointly with 6th International Conference on Embedded Systems., 20th International Conference on, pp. 37–42. IEEE, 2007.
+
+Marijn JH Heule, Oliver Kullmann, Siert Wieringa, and Armin Biere. Cube and conquer: Guiding cdcl sat solvers by lookaheads. In Haifa Verification Conference, pp. 50–65. Springer, 2011.
+
+Zhiting Hu, Xuezhe Ma, Zhengzhong Liu, Eduard Hovy, and Eric Xing. Harnessing deep neural networks with logic rules. arXiv preprint arXiv:1603.06318, 2016.
+
+Himanshu Jain and Edmund M Clarke. Efficient sat solving for non-clausal formulas using dpll, graphs, and watched cuts. In Proceedings of the 46th Annual Design Automation Conference, pp. 563–568. ACM, 2009.
+
+Elias Khalil, Hanjun Dai, Yuyu Zhang, Bistra Dilkina, and Le Song. Learning combinatorial optimization algorithms over graphs. In Advances in Neural Information Processing Systems, pp. 6351–6361, 2017.
+
+Risi Kondor, Hy Truong Son, Horace Pan, Brandon Anderson, and Shubhendu Trivedi. Covariant compositional networks for learning graphs. arXiv preprint arXiv:1801.02144, 2018.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015.
+
+Joao Marques-Silva. The impact of branching heuristics in propositional satisfiability algorithms. In Portuguese Conference on Artificial Intelligence, pp. 62–74. Springer, 1999.
+
+Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodola, Jan Svoboda, and Michael M Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. In Proc. CVPR, volume 1, pp. 3, 2017.
+
+Matthew W Moskewicz, Conor F Madigan, Ying Zhao, Lintao Zhang, and Sharad Malik. Chaff: Engineering an efficient sat solver. In Proceedings of the 38th annual Design Automation Conference, pp. 530–535. ACM, 2001.
+
+Razvan Pascanu, Caglar Gulcehre, Kyunghyun Cho, and Yoshua Bengio. How to construct deep recurrent neural networks. arXiv preprint arXiv:1312.6026, 2013.
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2009.
+
+Daniel Selsam, Matthew Lamm, Benedikt Bunz, Percy Liang, Leonardo de Moura, and David L Dill. Learning a sat solver from single-bit supervision. arXiv preprint arXiv:1802.03685, 2018.
+
+Bing Shuai, Zhen Zuo, Bing Wang, and Gang Wang. Dag-recurrent neural networks for scene labeling. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3620–3629, 2016.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014.
+
+Kai Sheng Tai, Richard Socher, and Christopher D Manning. Improved semantic representations from tree-structured long short-term memory networks. arXiv preprint arXiv:1503.00075, 2015.
+
+Christian Thiffault, Fahiem Bacchus, and Toby Walsh. Solving non-clausal formulas with dpll search. In International Conference on Principles and Practice of Constraint Programming, pp. 663–678. Springer, 2004.
+
+Miroslav N Velev. Exploiting hierarchy and structure to efficiently solve graph coloring as sat. In Proceedings of the 2007 IEEE/ACM international conference on Computer-aided design, pp. 135–142. IEEE Press, 2007.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015.
+
+Jingyi Xu, Zilu Zhang, Tal Friedman, Yitao Liang, and Guy Van den Broeck. A semantic loss function for deep learning with symbolic knowledge. arXiv preprint arXiv:1711.11157, 2017.
+
+Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Ruslan R Salakhutdinov, and Alexander J Smola. Deep sets. In Advances in Neural Information Processing Systems, pp. 3394–3404, 2017.
+
+# APPENDIX A: ADAPTING DG-DAGRNN FOR CIRCUIT-SAT CLASSIFICATION
+
+In the classification problem, we are interested to merely classify each input circuit as SAT or UNSAT. To do so, we customize DG-DAGRNN framework as follows. The classification function $\mathcal { C } _ { \alpha }$ is set to be a MLP with ReLU activation function for the hidden layers and the Sigmoid activation for the output layer. As the result the output space $\mathcal { O }$ will become [0, 1]. The embedding function $\mathcal { E } _ { \beta }$ is set to be a multi-layer recursive embedding as in equation 3 with interleaving regular forward and reversed layers. For the classification problem, we make sure the last layer of the embedding is a forward layer so that we can read off from only one sink node (i.e. the expression root node) and feed the result to the classification function for the final prediction. Finally given a labeled training set, we minimize the standard cross-entropy loss via the end-to-end backpropagation through the entire network.
+
+# APPENDIX B: PROOF OF NO FALSE POSITIVES
+
+In this section, we prove that for any UNSAT input circuit $\mu _ { G }$ , the satisfiability function $ { \boldsymbol { S } } _ {  { \boldsymbol { \theta } } } (  { \boldsymbol { \mu } } _ { G } )$ at the prediction time will never go beyond 0.5, and as a result, our model would never produce false positives. To prove that, first we show that thresholding the output of the evaluator network $\mathcal { R } _ { G }$ for a soft assignment $^ { a }$ is equivalent to applying the original circuit $\mu _ { G }$ to the hard assignment corresponding to $^ { a }$ :
+
+Lemma 1. Let $\mu _ { G }$ be any $D A G$ function representing a Boolean circuit with underlying topology $G$ . Also let $\mathcal { R } _ { G }$ be the evaluator network corresponding to $\mu _ { G }$ where all the And, Or and Not gates are replaced by the $\operatorname* { m i n } ( \cdot )$ , $\operatorname* { m a x } ( { \mathord { \cdot } } )$ and $\mathcal { N } ( \cdot )$ functions, respectively. Moreover, for any soft assignment $\pmb { a } = ( a _ { 1 } , a _ { 2 } , . . . , a _ { n } ) \in [ 0 , 1 ] ^ { n }$ , let its corresponding hard assignment $\mathcal { H } ( \pmb { a } ) =$ $\left( \mathcal { H } ( a _ { 1 } ) , \mathcal { H } ( a _ { 2 } ) , . . . , \mathcal { H } ( a _ { n } ) \right)$ be obtained by thresholding at 0.5; that is, $\forall i \in 1 . . n : \mathcal { H } ( a _ { i } ) = \mathbb { I } ( a _ { i } >$ 0.5). Then we have $\mathcal { H } \big ( \mathcal { R } _ { G } ( \mathbf { { a } } ) \big ) = \mu _ { G } \big ( \mathcal { H } ( \mathbf { { a } } ) \big )$ for all soft assignments $\pmb { a } \in [ 0 , 1 ] ^ { n }$ .
+
+Proof. Proof by induction on the number of gates $N$ in $\mu _ { G }$ : for the base case (i.e. $N = 1$ ), the circuit $\mu _ { G }$ simply consists of one gate. Depending on the type of this gate, we can have three possibilities:
+
+$$
+\begin{array} { r l } & { \mathbf { A n d } ) \ \mathcal { H } \big ( \operatorname* { m i n } ( a _ { 1 } , . . . , a _ { n } ) \big ) = \operatorname* { m i n } \big ( \mathcal { H } ( a _ { 1 } ) , . . . , \mathcal { H } ( a _ { n } ) \big ) = \mathbf { A n d } \big ( \mathcal { H } ( a _ { 1 } ) , . . . , \mathcal { H } ( a _ { n } ) \big ) } \\ & { \begin{array} { r l } { \mathbf { ( O r ) } \ \mathcal { H } \big ( \operatorname* { m a x } ( a _ { 1 } , . . . , a _ { n } ) \big ) = \operatorname* { m a x } \big ( \mathcal { H } ( a _ { 1 } ) , . . . , \mathcal { H } ( a _ { n } ) \big ) = \mathbf { O r } \big ( \mathcal { H } ( a _ { 1 } ) , . . . , \mathcal { H } ( a _ { n } ) \big ) } \\ { \mathbf { ( N o t ) } \ \mathcal { H } \big ( \mathcal { N } ( a ) \big ) = \mathcal { H } ( 1 - a ) = 1 - \mathcal { H } ( a ) = \mathbf { N o t } \big ( \mathcal { H } ( a ) \big ) } \end{array} } \end{array}
+$$
+
+Now let us assume the lemma holds for any circuit with strictly less than $N$ gates. We want to prove it also holds for any circuit $\mu _ { G }$ with $N$ gates. For the sake of simplicity, let us assume the sink node (i.e. the final gate) of $\mu _ { G }$ is an And gate (the same argument can be made for $\mathbf { o r }$ and Not gates). If the final gate has $k$ inputs and is removed from the circuit, we will end up with $k$ (possibly overlapping) sub-circuits $\mu _ { G _ { 1 } } , . . . , \mu _ { G _ { k } }$ with corresponding evaluator networks $\mathcal { R } _ { G _ { 1 } } , . . . , \mathcal { R } _ { G _ { k } }$ . We can then write:
+
+$$
+\begin{array} { r l } & { \mathcal { H } \big ( \mathcal { R } _ { G } ( a ) \big ) = \mathcal { H } \bigg ( \operatorname* { m i n } \big ( \mathcal { R } _ { G _ { 1 } } ( a ) , . . . , \mathcal { R } _ { G _ { k } } ( a ) \big ) \bigg ) = \mathbf { A } \mathbf { n d } \bigg ( \mathcal { H } \big ( \mathcal { R } _ { G _ { 1 } } ( a ) \big ) , . . . , \mathcal { H } \big ( \mathcal { R } _ { G _ { k } } ( a ) \big ) \bigg ) } \\ & { \quad \quad \quad = \mathbf { A } \mathbf { n d } \bigg ( \mu _ { G _ { 1 } } \big ( \mathcal { H } ( a ) \big ) , . . . , \mu _ { G _ { k } } \big ( \mathcal { H } ( a ) \big ) \bigg ) = \mu _ { G } \big ( \mathcal { H } ( a ) \big ) } \end{array}
+$$
+
+where the second and the third equalities come from the base and the inductive steps of the induction, respectively. □
+
+Theorem 2. $\mu _ { G }$ is UNSAT if and only if $\mathcal { R } _ { G } ( { \pmb a } ) \le 0 . 5$ for all soft assignments $\pmb { a } \in [ 0 , 1 ] ^ { n }$ .
+
+Proof. (If) Proof by contradiction: let us assume $\mu _ { G }$ is indeed SAT. Then there exists at least one hard assignment $\hat { \pmb { a } } \in \{ 0 , 1 \} ^ { n }$ such that $\mu _ { G } ( \hat { \pmb a } ) = 1$ . However, for hard assignment values, the $\operatorname* { m i n } ( \cdot ) , \operatorname* { m a x } ( \cdot )$ and $\mathcal { N } ( \cdot )$ functions behave exactly the same as the And, Or and Not gates, respectively. This means that for hard assignments, we have $\mu _ { G } \equiv \mathcal { R } _ { G }$ , which further yields $\mathcal { R } _ { G } ( { \hat { a } } ) = { \dot { \mu } } _ { G } ( { \hat { a } } ) = 1 > 0 . 5 .$ . This would in turn lead to a contradiction.
+
+(Only-If) Proof by contradiction: let us assume that there exists a soft assignment $\pmb { a } \in [ 0 , 1 ] ^ { n }$ such that $\mathcal { R } _ { G } ( { \pmb a } ) > 0 . 5$ , then using Lemma 1 and the definition of $\mathcal { H } ( \cdot )$ , we will have:
+
+$$
+\mu _ { G } \big ( \mathcal { H } ( \pmb { a } ) \big ) = \mathcal { H } \big ( \mathcal { R } _ { G } ( \pmb { a } ) \big ) = \mathbb { I } \big ( \mathcal { R } _ { G } ( \pmb { a } ) > 0 . 5 \big ) = 1
+$$
+
+In other words, we have found a hard assignment $\mathcal { H } ( a )$ that satisfies the circuit $\mu _ { G }$ ; this is a contradiction. □
+
+# APPENDIX C: CONVERTING CNF TO CIRCUIT
+
+There are many ways one can convert a CNF to a circuit; some are optimized toward extracting structural information – e.g. Fu & Malik (2007). Here, we have taken a more intuitive and general approach based on the Cube and Conquer paradigm (Heule et al. (2011)) for solving CNF-SAT problems. In the Cube and Conquer paradigm, for a given input Boolean formula $F$ , a variable $x$ in $F$ is picked and set to TRUE once to obtain $F _ { x } ^ { + }$ and to FALSE the other time to get $F _ { x } ^ { - }$ . Now if we can find a SAT solution for either of $F _ { x } ^ { + }$ or $F _ { x } ^ { - }$ , then we also have a SAT solution for $F$ . Since neither of $F _ { x } ^ { + }$ or $F _ { x } ^ { - }$ contains $x$ , we effectively reduce the complexity of the original SAT problem by removing one variable. This process can be repeated recursively (up to a fixed level) for $F _ { x } ^ { + }$ and $\dot { F } _ { x } ^ { - }$ by picking a new variable to reduce the complexity even further. Now inspired by this paradigm, one can easily show that the following logical equivalence holds for any variable $x$ in $F$ :
+
+$$
+F \Leftrightarrow ( x \wedge F _ { x } ^ { + } ) \vee ( \neg x \wedge F _ { x } ^ { - } )
+$$
+
+And this is exactly the principle we used to convert a CNF formula $F$ into a circuit. In particular, by applying the equivalence in equation 8 recursively, up to a fixed level4, we perform the CNF to circuit conversion (Note that $\hat { F _ { x } ^ { + } }$ and $F _ { x } ^ { - }$ are also CNFs). The natural question then is in what order we should pick variables to apply equation 8. That is where the heuristic part comes into play: depending on the specific class of SAT problems we are targeting, we can incorporate a garden variety of ordering heuristics (aka the branching heuristics) in the literature – e.g. Biere et al. (2009); Heule et al. (2011); Marques-Silva (1999); Moskewicz et al. (2001). In our experiments for random $k$ -SAT problems, each time we simply pick the variable that appears in the largest number of clauses in the current CNF.
+
+# APPENDIX D: REPRESENTING GRAPH $k$ -COLORING AS CNF AND CIRCUIT
+
+We know from Computer Science theory that the graph $k$ -coloring problem can be reduced to the SAT problem by representing the problem as a Boolean CNF. There are many ways in the literature to do so; we have picked the Muldirect approach from Velev (2007). In particular, for a graph with $N$ nodes and maximum $k$ allowed colors, we define the Boolean variables $\boldsymbol { x } _ { i j }$ for $1 \leq i \leq N$ and $1 \leq j \leq k$ , where $x _ { i j } = 1$ indicates that the ith node is colored by the $j$ th color. Then, the CNF encoding the decision graph $k$ -coloring problem is defined as:
+
+$$
+\biggl [ \bigwedge _ { i = 1 } ^ { N } \biggl ( \bigvee _ { j = 1 } ^ { k } x _ { i j } \biggr ) \biggr ] \wedge \biggl [ \bigwedge _ { ( p , q ) \in E } \biggl ( \bigwedge _ { j = 1 } ^ { k } ( \neg x _ { p j } \vee \neg x _ { q j } ) \biggr ) \biggr ]
+$$
+
+where $E$ is the set of the graph edges. The left set of clauses in equation 9 ensure that each node of the graph takes at least one color. The right set of clauses in equation 9 enforce the constraint that the neighboring nodes cannot take the same color. As a result, any satisfiable solution to the CNF in equation 9 corresponds to at least one coloring solution for the original problem if not more. Note that in this formulation, we do not require each node to take only one color value; therefore, one SAT solution can produce multiple valid graph coloring solutions.
+
+To generate a circuit from the above CNF, we note that the graph structure in graph coloring problem contains valuable structural information that can be potentially encoded as heuristics into the circuit structure. One such good heuristics, in particular, is the node degrees. More specifically, the most constrained variable first heuristic in Constraint Satisfaction Problems (CSPs) recommends assigning values to the most constrained variable first. In graph coloring problem, the higher the node degree, the more constrained the variables associated with that node are. Therefore, sorting the graph nodes based on their degrees would give us a meaningful variable ordering, which can be further used to build the circuit using the equivalence in equation 8, for example.

parse/train/BJxgz2R9t7/BJxgz2R9t7_content_list.json

@@ -0,0 +1,1602 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING TO SOLVE CIRCUIT-SAT:AN UNSUPERVISED DIFFERENTIABLE APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            764,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Saeed Amizadeh, Sergiy Matusevych, Markus Weimer   \nMicrosoft   \nRedmond, WA 98052   \n{saamizad,sergiym,Markus.Weimer}@microsoft.com ",
+        "bbox": [
+            184,
+            169,
+            635,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent efforts to combine Representation Learning with Formal Methods, commonly known as Neuro-Symbolic Methods, have given rise to a new trend of applying rich neural architectures to solve classical combinatorial optimization problems. In this paper, we propose a neural framework that can learn to solve the Circuit Satisfiability problem. Our framework is built upon two fundamental contributions: a rich embedding architecture that encodes the problem structure, and an end-to-end differentiable training procedure that mimics Reinforcement Learning and trains the model directly toward solving the SAT problem. The experimental results show the superior out-of-sample generalization performance of our framework compared to the recently developed NeuroSAT method. ",
+        "bbox": [
+            233,
+            299,
+            766,
+            438
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            478,
+            336,
+            494
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent advances in neural network models for discrete structures have given rise to a new field in Representation Learning known as the Neuro-Symbolic methods. Generally speaking, these methods aim at marrying the classical symbolic techniques in Formal Methods and Computer Science to Deep Learning in order to benefit both disciplines. One of the most exciting outcomes of this marriage is the emergence of neural models for learning how to solve the classical combinatorial optimization problems in Computer Science. The key observation behind many of these models is that in practice, for a given class of combinatorial problems in a specific domain, the problem instances are typically drawn from a certain (unknown) distribution. Therefore if a sufficient number of problem instances are available, then in principle, Statistical Learning should be able to extract the common structures among these instances and produce meta-algorithms (or models) that would, in theory, outperform the carefully hand-crafted algorithms. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            666
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There have been two main approaches to realize this idea in practice. In the first group of methods, the general template of the solver algorithm (which is typically the greedy strategy) is directly imported from the classical heuristic search algorithm, and the Deep Learning component is only tasked to learn the optimal heuristics within this template. In combination with Reinforcement Learning, such strategy has been shown to be quite effective for various NP-complete problems – e.g. Khalil et al. (2017). Nevertheless, the resulted model is bounded by the greedy strategy, which is sub-optimal in general. The alternative is to go one step further and let Deep Learning figure out the entire solution structure from scratch. This approach is quite attractive as it allows the model not only learn the optimal (implicit) decision heuristics but also the optimal search strategies beyond the greedy strategy. However, this comes at a price: training such models can be quite challenging! To do so, a typical candidate is Reinforcement Learning (Policy Gradient, in specific), but such techniques are usually sample inefficient – e.g. Bello et al. (2016). As an alternative method for training, more recently Selsam et al. (2018) have proposed using the latent representations learned for the binary classification of the Satisfiability (SAT) problem to actually produce a neural SAT solver model. Even though using such proxy for learning a SAT solver is an interesting observation and provides us with an end-to-end differentiable architecture, the model is not directly trained toward solving a SAT problem (unlike Reinforcement Learning). As we will see later in this paper, that can indeed result in poor generalization and sub-optimal models. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a neural Circuit-SAT solver framework that effectively belongs to the second class above; that is, it learns the entire solution structure from scratch. More importantly, to train such model, we propose a training strategy that, unlike the typical Policy Gradient, is differentiable end-toend, yet it trains the model directly toward the end goal (similar to Policy Gradient). Furthermore, our proposed training strategy enjoys an Explore-Exploit mechanism for better optimization even though it is not exactly a Reinforcement Learning approach. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The other aspect of building neural models for solving combinatorial optimization problems is how the problem instance should be represented by the model. Using classical architectures like RNNs or LSTMs completely ignores the inherent structure present in the problem instances. For this very reason, there has been recently a strong push to employ structure-aware architectures such as different variations of neural graph embedding. Most neural graph embedding methodologies are based on the idea of synchronously propagating local information on an underlying (undirected) graph that represents the problem structure. The intuition behind using local information propagation for embedding comes from the fact that many original combinatorial optimization algorithms can actually be seen propagating information. In our case, since we are dealing with Boolean circuits and circuit are Directed Acyclic Graphs (DAG), we would need an embedding architecture that take into account the special architecture of DAGs (i.e. the topological order of the nodes). In particular, we note that in many DAG-structured problems (such as circuits, computational graphs, query DAGs, etc.), the information is propagated sequentially rather than synchronously, hence a justification to have sequential propagation for the embedding as well. To this end, we propose a rich embedding architecture that implements such propagation mechanism for DAGs. As we see in this paper, our proposed architecture is capable of harnessing the structural information in the input circuits. To summarize, our contributions in this work are three-fold: ",
+        "bbox": [
+            174,
+            194,
+            825,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(a) We propose a general, rich graph embedding architecture that implements sequential propagation for DAG-structured data.   \n(b) We adapt our proposed architecture to design a neural Circuit-SAT solver which is capable of harnessing structural signals in the input circuits to learn a SAT solver.   \n(c) We propose a training strategy for our architecture that is end-to-end differentiable, yet similar to Reinforcement Learning techniques, it directly trains our model toward solving the SAT problem with an Explore-Exploit mechanism. ",
+        "bbox": [
+            205,
+            441,
+            825,
+            549
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The experimental results show the superior performance of our framework especially in terms of generalizing to new problem domains compared to the baseline. ",
+        "bbox": [
+            174,
+            559,
+            821,
+            588
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            607,
+            344,
+            623
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep learning on graph-structured data has recently become a hot topic in the Machine Learning community under the general umbrella of Geometric Deep Learning Bronstein et al. (2017). Based on the assumptions they make, these models typically divide into two main categories. In the first category, the graph-structured datapoints are assumed to share the same underlying graph structure (aka the domain) and only differ based on the feature values assigned to each node or edge. The methods in this category operate in both the spatial and the frequency domains; for example, Spectral CNN Bruna et al. (2013), Graph CNN Defferrard et al. (2016), Graph Neural Network Scarselli et al. (2009) and Covariant Compositional Networks Kondor et al. (2018). In the second category on the other hand, each example in the training data has its own domain (graph structure). Since the domain is varying across datapoints, these other methods mostly operate in the spatial domain and typically can be seen as the generalization of the classical CNNs (e.g.MoNet Monti et al. (2017)) or the classical RNNs (e.g.TreeLSTM Tai et al. (2015), DAG-RNN Baldi & Pollastri (2003); Shuai et al. (2016)) or both (e.g.GGS-NN Li et al. (2015)) to the graph domain. In this paper, we extend the single layer DAG-RNN model for DAG-structured data Baldi & Pollastri (2003); Shuai et al. (2016) to the more general deep version with Gated Recurrent Units, where each layer processes the input DAG either in the forward or the backward direction. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, the application of Machine Learning (deep learning in specific) to logic and symbolic computation has recently emerged as a bridge between Machine Learning and the classical Computer Science. While works such as Evans et al. (2018); Arabshahi et al. (2018) have shown the effectiveness of (recursive) neural networks in modeling symbolic expressions, others have taken one step further and tried to learn approximate algorithms to solve symbolic NP-complete problems Khalil et al. (2017); Bello et al. (2016); Vinyals et al. (2015). In particular, as opposed to black box methods (e.g. Bello et al. (2016); Vinyals et al. (2015)), Khalil et al. Khalil et al. (2017) have shown that by incorporating the underlying graph structure of a NP-hard problem, efficient search heuristics can be learned for the greedy search algorithm. Although working in the context of greedy search introduces an inductive bias that benefits the sample efficiency of the framework, the resulted algorithm is still bounded by the sub-optimality of the greedy search. More recently, Selsal et al. Selsam et al. (2018) have introduced the NeuroSAT framework - a deep learning model aiming at learning to solve the Boolean Satisfiability problem (SAT) from scratch without biasing it toward the greedy search. In particular, they have primarily approached the SAT problem as a binary classification problem and proposed a clustering-based post-processing analysis to find a SAT solution from the latent representations extracted from the learned classifier. Although, they have shown the empirical merits of their proposed framework, it is not clear why the proposed post-processing clusetring should find the SAT solution without being explicitly trained toward that goal. In this paper, we propose a deep learning framework for the Circuit-SAT problem (a more general form of the SAT problem), but in contrast to NeuroSAT, our model is directly trained toward finding SAT solutions without requiring to see them in the training sample. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            340
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DAG EMBEDDING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            358,
+            359,
+            376
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we formally formulate the problem of learning on DAG-structured data and propose a deep learning framework to approach the problem. It should be noted that even though this framework has been developed for DAGs, the underlying dataset can be a general graph as long as an explicit ordering for the nodes of each graph is available. This ordering is naturally induced by the topological sort algorithm in DAGs or can be imposed on general undirected graphs to yield DAGs. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            460
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 NOTATIONS AND DEFINITIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            477,
+            428,
+            491
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $G = \\langle V _ { G } , E _ { G } \\rangle$ denote a Directed Acyclic Graph (DAG). We assume the the set of nodes of $G$ are ordered according to the topological sort of the DAG. For any node $v \\in V _ { G }$ , $\\pi _ { G } ( v )$ represents the set of direct predecessors of $v$ in $G$ . Also for a given DAG $G$ , we define the reversed DAG, $G ^ { r }$ with the same set of nodes but reversed edges. When topologically sorted, the nodes of $G ^ { r }$ appear in the reversed order of those of $G$ . Furthermore, for a given $G$ , let $\\dot { \\mu } _ { G } : V _ { G } \\mapsto \\mathbb { R } ^ { d }$ be a $d$ -dimensional vector function defined on the nodes of $G$ . We refer to $\\mu _ { G }$ as a $D A G$ function – i.e. a function that is defined on a DAG. Note that the notation $\\mu _ { G }$ implicitly induces the DAG structure $G$ along with the vector function defined on the DAG. Figure 1(a) shows an example DAG function with $d = 3$ . Finally, let $\\mathcal { G } ^ { d }$ denote the space of all possible $d$ -dimensional functions $\\mu _ { G }$ (along with their underlying graphs $G$ ). We define the parametric functional $\\mathcal { F } _ { \\pmb { \\theta } } : \\mathcal { G } ^ { d } \\mapsto \\mathcal { O }$ that maps any function $\\mu _ { G }$ (defined on some DAG $G$ ) in $\\mathcal { G } ^ { d }$ to some output space $\\mathcal { O }$ . ",
+        "bbox": [
+            173,
+            502,
+            825,
+            656
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 THE GENERAL MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            671,
+            374,
+            686
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The next step is to define the mathematical form of the functional $\\mathcal { F } _ { \\theta }$ . In this work, we propose: ",
+        "bbox": [
+            171,
+            696,
+            800,
+            713
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/60aca9b8c5281ab003c9080a7f5326dea8698a1170e0b6b305d970c1c0c92f34.jpg",
+        "text": "$$\n\\mathcal { F } _ { \\pmb { \\theta } } ( \\mu _ { G } ) = \\mathcal { C } _ { \\pmb { \\alpha } } \\bigg ( \\mathcal { P } \\big ( \\mathcal { E } _ { \\beta } ( \\mu _ { G } ) \\big ) \\bigg )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            717,
+            599,
+            752
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, $\\mathcal { E } _ { \\beta } : \\mathcal { G } ^ { d } \\mapsto \\mathcal { G } ^ { q }$ is the embedding function that maps the input $d$ -dimensional DAG functions into a $q$ -dimensional DAG function space. Note that the embedding function in general may transform both the underlying DAG size/structure as well as the the DAG function defined on it. In this paper, however, we assume it only transforms the DAG function and keeps the input DAG structure intact. Once the DAG is embedded into the new space, we apply the fixed pooling function $\\mathcal { P } : \\mathcal { G } ^ { q } \\mapsto \\mathcal { G } ^ { q }$ on the embedded DAG function to produce a (possibly) aggregated version of it. For example, if we are interested in DAG-level predictions, $\\mathcal { P }$ can be average pooling across all nodes of the input DAG to produce a singleton DAG; whereas, in the case of node-level predictions, $\\mathcal { P }$ is simply the Identity function. In this paper, we set $\\mathcal { P }$ to retrieve only the sink nodes in the input DAG. Finally, the classification function $\\mathcal { C } _ { \\alpha } : \\mathcal { G } ^ { q } \\mapsto \\mathcal { O }$ is applied on the aggregated DAG function to produce the final prediction output in $\\mathcal { O }$ . In this work, we set $\\mathcal { C } _ { \\alpha }$ to be a multi-layer neural network. The tuple $\\pmb \\theta = \\langle \\pmb \\alpha , \\beta \\rangle$ identifies all the free parameters of the model. ",
+        "bbox": [
+            173,
+            756,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 THE DAG EMBEDDING LAYER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            428,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The (supervised) embedding of graph-based data into the traditional vector spaces has been a hot topic recently in the Machine Learning community Li et al. (2015); Shuai et al. (2016); Tai et al. (2015). Many of these frameworks are based on the key idea of representing each node in the input graph by a latent vector called the node state and update these latent states via an iterative (synchronous) propagation mechanism that takes the graph structure into account. Two of these methodologies that are closely related to the proposed framework in this paper are the Gated Graph Sequence Neural Networks (GGS-NN) Li et al. (2015) and DAG Recurrent Neural Networks (DAG-RNN) Shuai et al. (2016). While GGS-NNs apply multi-level Gated Recurrent Unit (GRU) like updates in an iterative propagation scheme on general (undirected) graphs, DAG-RNNs apply simple RNN logic in a one-pass, sequential propagation mechanism from the input DAG’s source nodes to its sink nodes. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            268
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our proposed framework is built upon the DAG-RNN framework Shuai et al. (2016) but it enriches this framework further by incorporating key ideas from GGS-NNs Li et al. (2015), Deep RNNs Pascanu et al. (2013) and sequence-to-sequence learning Sutskever et al. (2014). Before we explain our framework, it is worth noting that assiging input feature/state vectors to each node is equivalent to defining a DAG function in our framework. For the sake of notational simplicity, for the input DAG function $\\mu _ { G }$ , we define the $d$ -dimensional node feature vector $\\mathbf { \\boldsymbol { x } } _ { v } = \\mu _ { G } ( \\bar { \\boldsymbol { v } } )$ and the $q$ -dimensional node state vector $\\boldsymbol { h _ { v } } = \\delta _ { G } ( \\boldsymbol { v } )$ for some unknown DAG function $\\delta _ { G } : V _ { G } \\mapsto \\mathbb { R } ^ { q }$ . Given the node feature vectors $\\scriptstyle { \\mathbf { { \\mathit { x } } } } _ { \\mathit { v } }$ for an input DAG, the update rule for the state vector at each node is defined as: ",
+        "bbox": [
+            173,
+            273,
+            825,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3fcfab6fc57826c455fcd4032bbb9e8898c3c3e4c1ef85df7638ec4c1f202118.jpg",
+        "text": "$$\n\\pmb { h _ { v } } = G R U ( \\pmb { x _ { v } } , \\pmb { h _ { v } ^ { \\prime } } ) , \\mathrm { w h e r e } \\pmb { h _ { v } ^ { \\prime } } = \\pmb { \\mathcal { A } } \\big ( \\{ \\pmb { h _ { u } } \\ | \\ u \\in \\pi ( v ) \\} \\big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            392,
+            681,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $G R U ( . )$ is the standard GRU Chung et al. (2014) function applied on the input vector at node $v$ and the aggregated state of its direct predecessors which in turn is computed by the aggregator function $\\mathcal { A } : 2 ^ { V _ { G } ^ { \\smile } } \\mapsto \\mathbb { R } ^ { q }$ . The aggregator function is defined as a tunable deep set function Zaheer et al. (2017) with free parameters that is invariant to the permutation of its inputs. The main difference between these proposed updates rules and the ones in DAG-RNN is in DAG-RNN, we have the simple RNN logic instead of GRU, and the aggregation logic is simply (fixed) summation. ",
+        "bbox": [
+            173,
+            415,
+            825,
+            501
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By applying the update logic in equation 2 sequentially on the nodes of the input DAG processed in the topological sort order, we compute the state vector $h _ { v }$ for all nodes of $G$ in one pass. This would complete the one layer (forward) embedding of the input DAG function, or $\\mathcal { E } _ { \\beta } ( \\mu _ { G } ) = \\delta _ { G }$ . Note that the same way that DAG-RNNs are the generalization of RNNs on sequences to DAGs, our proposed one-layer embedding can be seen as the generalization of GRU-NNs on sequences to DAGs. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            577
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, we introduce the reversed layers (denoted by ${ \\mathcal { E } } ^ { r }$ ) that are similar to the regular forward layers except that the input DAG is processed in the reversed order. Alternatively, reversed layers can be seen as regular layers that process the reversed version of the input DAG $G ^ { r }$ ; that is, $\\mathcal { E } ^ { r } ( \\mu _ { G } ) \\equiv$ $\\mathcal { E } ( \\mu _ { G ^ { r } } )$ . The main reason we have introduced reversed layers in our framework is because in the regular forward layers, the state vector for each node is only affected by the information flowing from its ancestor nodes; whereas, the information from the descendant nodes can also be highly useful for the learning task in hand. The reversed layers provide such information for the learning task. Furthermore, the introduction of reversed layers is partly motivated by the successful application of processing sequences backwards in sequence-to-sequence learning Sutskever et al. (2014). Sequences can be seen as special-case linear DAGs; as a result, reversed layers can be interpreted as the generalized version of reversing sequences. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            737
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 DEEP-GATED DAG RECURSIVE NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            752,
+            583,
+            768
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The natural extension of the one-layer embedding is the stacked $L$ -layer version where the $i$ th layer has its own parameters $\\beta _ { i }$ and output DAG function dimensionality $q _ { i }$ . Furthermore, the stacked $L$ layers can be sequentially applied $T$ times in the recurrent fashion to generate the final embedding: ",
+        "bbox": [
+            174,
+            779,
+            823,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b3168cc2eb74946ab35c57035018b4399dd7a04320c0be50d29e3375f781f04d.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { E } _ { \\beta } ( \\mu _ { G } ) \\equiv \\mathcal { E } _ { \\beta } ^ { T } ( \\mu _ { G } ) , \\mathrm { w h e r e } \\ \\mathcal { E } _ { \\beta } ^ { t } ( \\mu _ { G } ) = \\mathcal { E } _ { s t a c k } \\big ( P r o j _ { H } ( \\mathcal { E } _ { \\beta } ^ { t - 1 } ( \\mu _ { G } ) ) \\big ) , \\forall t \\in 2 . . T } \\\\ & { \\qquad \\mathcal { E } _ { \\beta } ^ { 1 } ( \\mu _ { G } ) = \\mathcal { E } _ { s t a c k } ( \\mu _ { G } ) } \\\\ & { \\qquad \\mathrm { s . t . } \\ \\mathcal { E } _ { s t a c k } = \\mathcal { E } _ { \\beta _ { L } } \\circ \\mathcal { E } _ { \\beta _ { L - 1 } } \\circ \\dots \\circ \\mathcal { E } _ { \\beta _ { 1 } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            245,
+            827,
+            756,
+            890
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\beta = \\langle \\beta _ { 1 } , . . . , \\beta _ { L } , H \\rangle$ is the list of the parameters and $P r o j _ { H } : \\mathcal { G } ^ { q _ { L } } \\mapsto \\mathcal { G } ^ { d }$ is a linear projection with the projection matrix ${ \\cal H } _ { d \\times q _ { L } }$ that simply adjusts the output dimensionality of $\\mathcal { E } _ { s t a c k }$ so it can be fed back to $\\mathcal { E } _ { s t a c k }$ as the input. In our experiments, we have found that by letting $T > 1$ , we can significantly improve the accuracy of our models without introducing more trainable parameters. In practice, we fix the value of $T$ during training and increase it during testing to achieve better accuracy. Also note that the $L$ stacked layers in $\\mathcal { E } _ { s t a c k }$ can be any permutation of regular and reversed layers. We refer to this proposed framework as Deep-Gated DAG Recursive Neural Networks or DG-DAGRNN for short. Figure 1(b) shows an example 2-layer DG-DAGRNN model with one forward layer followed by a reversed layer. ",
+        "bbox": [
+            176,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/c607b84872e5782753ff11c7410e74e8e99764a46d1e4a793a564acd51d6e3e3.jpg",
+        "image_caption": [
+            "Figure 1: (a) A toy example input DAG function $\\mu _ { G }$ , (b) a DG-DAGRNN model that processes the input in (a) using two sequential DAG embedding layers: a forward layer followed by a reverse layer. The solid red and green arrows show the flow of information within each layer while the black arrows show the feed-forward flow of information in between the layers. Also, the dotted blue arrows show the recurrent flow of information from the last embedding layer back to the first one. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            98,
+            725,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            361,
+            825,
+            459
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 APPLICATION TO THE CIRCUIT-SAT PROBLEM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            481,
+            596,
+            498
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The Circuit Satisfiability problem (aka Circuit-SAT) is a fundamental NP-complete problem in Computer Science. The problem is defined as follows: given a Boolean expression consists of Boolean variables, parentheses, and logical gates (specifically And $\\wedge$ , Or $\\vee$ and Not $\\sqsupset$ ), find an assignment to the variables such that it would satisfy the original expression, aka a solution. If the expression is not satisfiable, it will be labeled as UNSAT. Moreover, when represented in the circuit format, Boolean expressions can aggregate the repetitions of the same Boolean sub-expression in the expression into one node in the circuit. This is also crucial from the learning perspective as we do not want to learn two different representations for the same Boolean sub-expression. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            626
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we apply the framework from the previous section to learn a Circuit-SAT solver merely from data. More formally, a Boolean circuit can be modeled as a DAG function $\\mu _ { G }$ with each node representing either a Boolean variable or a logical gate. In particular, we have $\\mu _ { G } \\colon V _ { G } \\mapsto \\mathbb { R } ^ { 4 }$ defined as $\\mu _ { G } ( v ) = \\mathrm { O n e - H o t } ( t y p e ( v ) )$ , where $t y p e ( v ) \\in \\{ \\mathbf { A n d } , \\mathbf { O r } , \\mathbf { N o t } , \\mathbf { V a r i a b l e } \\}$ . All the source nodes in a circuit $\\mu _ { G }$ have type Variable. Moreover, each circuit DAG has only one sink node (the root node of the Boolean expression). ",
+        "bbox": [
+            174,
+            633,
+            825,
+            717
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Similar to Selsam et al. (2018), we could also approach the Circuit-SAT problem from two different angles: (1) predicting the circuit satisfiability problem as a binary classification problem, and (2) solving the Circuit-SAT problem directly by generating a solution if the input circuit is indeed SAT. In Selsam et al. (2018), solving the former is the prerequisite for solving the latter. However, that is not the case in our proposed model and since we are interested to actually solve the SAT problems, we do not focus on the binary classification problem. Nevertheless, our model can be easily adapted for SAT classification, as illustrated in Appendix A. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            821
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 NEURAL CIRCUIT-SAT SOLVER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            434,
+            854
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Learning to solve SAT problems (i.e.finding a satisfying assignment) is indeed a much harder problem than SAT/UNSAT classification. In the NeuroSAT framework, Selsam et al. (2018), the authors have proposed a post-processing unsupervised procedure to decode a solution from the latent state representations of the Boolean literals. Although this approach works empirically for many SAT problems, it is not clear that it would also work for the Circuit-SAT problems. But more importantly, it is not clear why this approach should decode the SAT problems in the first place because the objective function used in Selsam et al. (2018) does not explicitly contain any component for solving SAT problems; in fact, the decoding procedure is added as a secondary analysis after training. In other words, the model is not optimized toward actually finding SAT assignments. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In contrast, in this paper, we pursue a completely different strategy for training a neural Circuit-SAT solver. In particular, using the DG-DAGRNN framework, we learn a neural functional $\\mathcal { F } _ { \\theta }$ on the space of circuits $\\mu _ { G }$ such that given an input circuit, it would directly generate a satisfying assignment for the circuit if it is indeed SAT. Moreover, we explicitly train $\\mathcal { F } _ { \\theta }$ to generate SAT solutions without requiring to see any actual SAT assignment during training. Our proposed strategy for training $\\mathcal { F } _ { \\theta }$ is reminiscent of Policy Gradient methods in Deep Reinforcement Learning Arulkumaran et al. (2017). ",
+        "bbox": [
+            174,
+            180,
+            825,
+            265
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The Solver Network. We start with characterizing the components of $\\mathcal { F } _ { \\theta }$ . First, the embedding function $\\mathcal { E } _ { \\beta }$ is set to be a multi-layer recursive embedding as in equation 3 with interleaving regular forward and reversed layers making sure that the last layer is a reversed layer so that we can read off the final outputs of the embedding from the Variable nodes (i.e. the sink nodes of the reversed DAG). The classification function $\\mathcal { C } _ { \\alpha }$ is set to be a MLP with ReLU activation function for the hidden layers and the Sigmoid activation for the output layer. The output space here encodes the soft assignment (i.e. in range $[ 0 , 1 ] )$ to the corresponding variable node in the input circuit. We also refer to $\\mathcal { F } _ { \\theta }$ as the solver or the policy network. ",
+        "bbox": [
+            173,
+            270,
+            825,
+            382
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The Evaluator Network. Furthermore, for any given circuit $\\mu _ { G }$ , we define the soft evaluation function $\\mathcal { R } _ { G }$ as a DAG computational graph that shares the same topology $G$ with the circuit $\\mu _ { G }$ except that the And nodes are replaced by the smooth min function, the Or nodes by the smooth max function and the Not nodes by $\\mathcal { N } ( z ) = 1 - z$ function, where $z$ is the input to the Not node. The smooth min and max functions are defined as: ",
+        "bbox": [
+            174,
+            388,
+            825,
+            459
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dbdbb07666b7cba216c63532dc62325bf77488cf9482b954341f20019a8d3dec.jpg",
+        "text": "$$\nS _ { m a x } ( a _ { 1 } , a _ { 2 } , . . . , a _ { n } ) = \\frac { \\sum _ { i = 1 } ^ { n } a _ { i } e ^ { a _ { i } / \\tau } } { \\sum _ { i = 1 } ^ { n } e ^ { a _ { i } / \\tau } } , S _ { m i n } ( a _ { 1 } , a _ { 2 } , . . . , a _ { n } ) = \\frac { \\sum _ { i = 1 } ^ { n } a _ { i } e ^ { - a _ { i } / \\tau } } { \\sum _ { i = 1 } ^ { n } e ^ { - a _ { i } / \\tau } } , I _ { m } ( a _ { 1 } , a _ { 2 } , . . . , a _ { n } ) = \\frac { \\sum _ { i = 1 } ^ { n } a _ { i } e ^ { - a _ { i } / \\tau } } { \\sum _ { i = 1 } ^ { n } e ^ { - a _ { i } / \\tau } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            463,
+            761,
+            501
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\tau \\geq 0$ is the temperature. For $\\tau = + \\infty$ , both $S _ { m a x } ( )$ and $S _ { m i n } ( )$ are the arithmetic mean functions. As $\\tau  0$ , we have $S _ { m a x } ( \\ v r ) \\to \\mathrm { m a x } ( \\ v r )$ and $S _ { m i n } ( \\ l )  \\mathrm { m i n } ( \\ l )$ . One can also show that $\\forall a = ( a _ { 1 } , . . . , a _ { n } ) : \\operatorname* { m i n } ( a ) < S _ { m i n } ( \\dot { a } ) < S _ { m a x } \\big ($ a) < max(a). More importantly, as opposed to the $\\operatorname* { m i n } ( )$ and max() functions, their smooth versions are fully differentiable w.r.t. all of their inputs. ",
+        "bbox": [
+            174,
+            506,
+            823,
+            563
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As its name suggests, the soft evaluation function evaluates a soft assignment (i.e. in [0, 1]) to the variables of the circuit. In particular, at a low enough temperature, if for a given input assignment, $\\mathcal { R } _ { G }$ yields a value strictly greater than 0.5, then that assignment (or its hard counterpart) can be seen as a satisfying solution for the circuit. We also refer to $\\mathcal { R } _ { G }$ as the evaluator or the reward network. Note that the evaluator network does not have any trainable parameter. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            640
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Encoding logical expressions into neural networks is not new per se as there has been recently a push to enrich deep learning with symbolic computing Hu et al. (2016); Xu et al. (2017). What are new in our framework, however, are two folds: (a) each graph example in our dataset induces a different evaluation network as opposed to having one fixed network for the entire dataset, and (b) by encoding the logical operators as smooth min and max functions, we provide a more efficient framework for back-propagating the gradients and speeding up the learning as the result, as we will see shortly. ",
+        "bbox": [
+            173,
+            646,
+            825,
+            731
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The Optimization. Putting the two pieces together, we define the satisfiability function $S _ { \\theta } : { \\mathcal { G } } \\mapsto$ $[ 0 , 1 ]$ as: $S _ { \\pmb \\theta } ( \\mu _ { G } ) = \\mathcal { R } _ { G } ( \\bar { \\mathcal { F } } _ { \\pmb \\theta } ( \\mu _ { G } ) )$ . Intuitively, the satisfiability function uses the solver network to produce an assignment for the input circuit and then feeds the resulted assignment to the evaluator network to see if it satisfies the circuit. We refer to the final output of $\\scriptstyle { \\mathcal { S } } _ { \\theta }$ as the satisfiability value for the input circuit, which is a real number in [0, 1]. Having computed the satisfiability value, we define the loss function as the smooth Step function: ",
+        "bbox": [
+            174,
+            736,
+            825,
+            820
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/608f733191e0d298b753ccb127ef22440d4930b26fd3c49808113a14cf40be06.jpg",
+        "text": "$$\n{ \\mathcal { L } } ( s ) = { \\frac { ( 1 - s ) ^ { \\kappa } } { ( 1 - s ) ^ { \\kappa } + s ^ { \\kappa } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            827,
+            575,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $s = { \\cal S } _ { \\theta } ( \\mu _ { G } )$ and $\\kappa \\geq 1$ is a constant. By minimizing the loss function in equation 7, we push the solver network to produce an assignment that yields a higher satisfiability value $ { \\boldsymbol { S } } _ {  { \\boldsymbol { \\theta } } } (  { \\boldsymbol { \\mu } } _ { G } )$ For satisfiable circuits this would eventually result in finding a satisfiable assignment for the circuit. However, if the input circuit is UNSAT, the maximum achievable value for $\\scriptstyle { \\mathcal { S } } _ { \\theta }$ is 0.5 as we have shown in Appendix B. In practice though, the inclusion of UNSAT circuits in the training data slows down the training process mainly because the UNSAT circuits keep confusing the solver network as it tries hard to find a SAT solution for them. For this very reason, in this scheme, we only train on SAT examples and exclude the UNSAT circuits from training. Nevertheless, if the model has enough capacity, one can still include the UNSAT examples and pursue the training as a pure unsupervised learning task since the true SAT/UNSAT labels are not used anywhere in equation 7. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Moreover, the loss function in equation 7 has a nice property of having higher gradients for satisfiability values close to 0.5 when $\\kappa > 1$ (we set $\\kappa = 1 0$ in our experiments). This means that the gradient vector in backpropagation is always dominated by the examples closer to the decision boundary. In practice, that would mean that the training algorithm immediately in the beginning pushes the easier examples in the training set (with satisfiability values close to 0.5) to the SAT region $( > 0 . 5 )$ with a safety margin from 0.5. As the training progresses, harder examples (with satisfiability values close to 0) start moving toward the SAT region. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            291
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As mentioned before, the proposed learning scheme in this section can be seen as a variant of Policy Gradient methods, where the solver network represents the policy function and the evaluator network acts as the reward function. The main difference here is that in our problem the mathematical form of the reward function is fully known and is differentiable so the entire pipeline can be trained using backpropagation in an end-to-end fashion to maximize the total reward over the training sample. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            368
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Exploration vs. Exploitation. The reason we use the smooth min and max functions in the evaluator network instead of the actual $\\operatorname* { m i n } ( )$ and $\\operatorname* { m a x } ( )$ is that in a min-max circuit, the gradient vector of the output of the circuit w.r.t. its inputs has at most one non-zero entry 1. That is, the circuit output is sensitive to only one of its inputs in the case of infinitesimal changes. For fixed input values, we refer to this input as the active input and to the path from the active input to the output as the active path. In the case of a min-max evaluator, the gradients flow back only through the active path of the evaluator network forcing the solver network to change such that it can satisfy the input circuit through its active path only. This strategy however is quite myopic and, as we observed empirically, leads to slow training and sub-optimal solutions. To avoid this effect, we use the smooth min and max functions in the evaluator network to allow the gradients to flow through all paths in the input circuit. Furthermore, in the beginning of the training we start with a high temperature value to let the model explore all paths in the input circuits for finding a SAT solution. As the training progresses, we slowly anneal the temperature toward 0 so that the model exploits more active path(s) for finding a solution. One annealing strategy is to let $\\tau = t ^ { - \\epsilon }$ , where $t$ is timestep and $\\epsilon$ is the annealing rate. In our experiments we set $\\epsilon = 0 . 4$ . It should be noted that at the test time, the smooth min and max functions are replaced by their non-smooth versions. ",
+        "bbox": [
+            173,
+            376,
+            825,
+            597
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Prediction. Given a test circuit $\\mu _ { G }$ , we evaluate $s = \\mathcal { S } _ { \\pmb { \\theta } } ( \\mu _ { G } ) = \\mathcal { R } _ { G } \\big ( \\mathcal { F } _ { \\pmb { \\theta } } ( \\mu _ { G } ) \\big )$ . If $s > 0 . 5$ then the circuit is classified as SAT and the SAT solution is provided by $\\mathcal { F } _ { \\pmb { \\theta } } ( \\mu _ { G } )$ . Otherwise, the circuit is classified as UNSAT. This way, unlike SAT classification, we predict SAT for a given circuit only if we have already found a SAT solution for it. In other words, our model never produces false positives. We have formally proved this in Appendix B. Moreover, at the prediction time, we do not need to set the number of recurrences $T$ in equation 3 to the same value we used for training. In fact, we have observed by letting $T$ to be variable on the per example basis, we can improve the model accuracy quite significantly at the test time. ",
+        "bbox": [
+            173,
+            603,
+            825,
+            717
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTAL EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            739,
+            450,
+            755
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The baseline method we have compared our framework to is the NeuroSAT model by Selsam et al. (2018). Like most classical SAT solvers, NeuroSAT assumes the input problem is given in the Conjunctive Normal Form (CNF). Even though that is a fair assumption in general, in some cases, the input does not naturally come as CNF. For instance, in hardware verification, the input problems are often in the form of circuits. One can indeed convert the circuit format into CNF in polynomial time using Tseitin transformation. However, such transformation will introduce extra variables (i.e. the derived variables) which may further complicate the problem for the SAT solver. More importantly, as a number of works in the SAT community have shown, such transformations typically lose the structural information embedded in the circuit format, which otherwise can be a rich source of information for the SAT solver, Thiffault et al. (2004); Andrews (2002); Biere (2008); Fu & Malik (2007); Velev (2007). As a result, there has been quite an effort in the classical SAT community to develop SAT solvers that directly work with the circuit format Thiffault et al. (2004); Jain & Clarke (2009). In the similar vein, our neural framework for learning a SAT solver enables us to harness such structural signals in learning by directly consuming the circuit format. That contrasts the NeuroSAT approach which cannot in principle benefit from such structural information. ",
+        "bbox": [
+            173,
+            771,
+            825,
+            897
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Despite this clear advantage of our framework to NeuroSAT, in this paper, we assume the (raw) input problems come in CNF, just so we can make a fair comparison to NeuroSAT. Instead for our method, we propose to use pre-processing methods to convert the input CNF into circuit that has the potential of injecting structural information into the circuit structure. In particular, if available, one can in principle encode problem-specific heuristics into the structure while building the circuit. For example, if there is a variable ordering heuristic available for a specific class of SAT problems, it can be used to build that target circuit in a certain way, as discussed in Appendix C. Note that we could just consume the original CNF; after all, CNF is a (flat) circuit, too. But as we empirically observed, that would negatively affect the results, which again highlights the fact that our proposed framework has been optimized to utilize circuit structure as much as possible. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            333
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Both our method and NeuroSAT require a large training sample size for moderate size problems. The good news is both methods can effectively be trained on an infinite stream of randomly generated problems in real-world applications. However, since we ran our experiments only on one GPU with limited memory, we had to limit the training sample size for the purpose of experimentation. This in turn restricts the maximum problem sizes we could train both models on. Nevertheless, our method can generalize pretty well to out-of-sample SAT problems with much larger sizes, as shown below. ",
+        "bbox": [
+            174,
+            340,
+            825,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 RANDOM $k$ -SAT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            441,
+            330,
+            455
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have used the generation process proposed in the NeuroSAT paper Selsam et al. (2018) to generate random $k$ -SAT CNF pairs (with $k$ stochastically set according to the default settings in Selsam et al. (2018)). These pairs are then directly fed to NeuroSAT for training. For our method, on the other hand, we first need to convert these CNFs into circuits2. In Appendix C, we have described the details of this conversion process. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            537
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Experimental Setup: We have trained a DG-DAGRNN model (i.e. our framework) and a NeuroSAT model on a dataset of 300K SAT and UNSAT pairs generated according to the scheme proposed in Selsam et al. (2018). The number of Boolean variables in the problems in this dataset ranges from 3 to 10. We have designed both models to have roughly $\\sim 1 8 0 \\mathrm { K }$ tunable parameters. In particular our model has two DAG embedding layers: a forward layer followed by a reversed layer, each with the embedding dimension $q = 1 0 0$ . The classifier is a 2-layer MLP with hidden dimensionality 30. The aggregator function $\\boldsymbol { \\mathcal { A } } ( \\cdot )$ consists of two 2-layer MLPs, each with hidden dimensionality 50. For training, we have used the Adam optimization algorithm with learning rate of $1 0 ^ { - 5 }$ , weight decay of $1 0 ^ { - \\bar { 1 } 0 }$ and gradient clipping norm of 0.65. We have also applied a dropout mechanism for the aggregator function during training with the rate of $2 0 \\%$ . For the NeuroSAT model, we have used the default hyper-parameter settings proposed in Selsam et al. (2018). Finally, since our model does not produce false positives, we have only included satisfiable examples in the test data for all experiments. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            712
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In-Sample Results: Once we trained the two models, the main performance metric we measure is the percentage of SAT problems in the test set that each model can actually find a SAT solution for.3 Figure 2 (Left) shows this metric on a test set from the same distribution for both our model and NeuroSAT as the number of recurrences (or propagation iterations for NeuroSAT) $T$ increases. Not surprisingly, both methods are able to decode more SAT problems as we increase $T$ . However, our method converges much faster than NeuroSAT (to a slightly smaller value). In other words, compared to NeuroSAT, our method requires smaller of number of iterations at the test time to decode SAT problems. We conjecture this is due to the fact the sequential propagation mechanism in DG-DAGRNN is more effective in decoding the structural information in the circuit format for the SAT problem than the synchronous propagation mechanism in NeuroSAT for the flat CNF. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            872
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c58f4d0f03bb646ce981d50017f231db375fe60223fd8c34faee4630c361dd82.jpg",
+        "image_caption": [
+            "Figure 2: (Left) In-Sample test results comparing between DG-DAGRNN and NeuroSAT, as the number of recurrence iterations $T$ increases. (Right) Out-of-Sample test results comparing the two methods when tested on much larger problems. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            98,
+            759,
+            243
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Out-of-Sample Results: Furthermore, we evaluated both trained models on test datasets drawn from different distributions than the training data with much larger number of variables (20, 40, 60 and 80 variables, in particular). We let both models iteratively run on each test dataset until the test metric converges. Figure 2 (Right) shows the test metric for both methods on these datasets after convergence. As the results demonstrate, compared to that of our method, the performance of NeuroSAT declines faster as we increase the number variables during test time, with a significant margin. In other words, our method generalizes better to out-of-sample, larger problems during the test time. We attribute this to the fact that NeuroSAT is trained toward the SAT classification problem as a proxy to learn a solver. This may result in the classifier picking up certain features that are informative for classification of in-sample examples which are, otherwise, harmful (or useless at best) for learning a solver for out-of-sample examples. Our framework, on the other hand, simply does not suffer from such problem because it is directly trained toward solving the SAT problem. ",
+        "bbox": [
+            173,
+            327,
+            825,
+            493
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Time Complexity: We trained both our model and NeuroSAT for a day on a single GPU. To give an idea of the test time complexity, it took both our model and NeuroSAT roughly about 3s to run for 40 iterations on a single example of 20 variables. We also measured the time that it takes for a modern SAT Solver (MiniSAT here) to solve a similar example to be roughly about 0.7s in average. Despite this difference, our neural approach is way more prallelizable compared to modern solvers such that many examples can be solved concurrently in a single batch on GPU. For example, while it took MiniSAT 114min to solve a set of 10, 000 examples, it took our method only 8min to solve for the same set in a batch-processing fashion on GPU. This indeed shows another important advantage of our neural approach toward SAT solving in large-scale applications: the extreme parallelization. ",
+        "bbox": [
+            174,
+            501,
+            825,
+            626
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 RANDOM GRAPH $k$ -COLORING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            645,
+            429,
+            660
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To further evaluate the generalization performance of the trained models from the previous section, we have tested them on SAT problems coming from an entire different domain than $k$ -SAT problems. In particular, we have chosen the graph $k$ -coloring decision problem which belongs to the class of NP-complete problems. In short, given an undirected graph $G$ with $k$ color values, in graph $k$ -coloring decision problem, we seek to find a mapping from the graph nodes to the color set such that no adjacent nodes in the graph have the same color. This classical problem is reducible to SAT. Moreover, the graph topology in general contains valuable information that can be further injected into the circuit structure when preparing circuit representation for our model. Appendix D illustrates how we incorporate this information to convert instances of the graph $k$ -coloring problem into circuits. For this experiment, we have generated two different test datasets: ",
+        "bbox": [
+            174,
+            672,
+            826,
+            811
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dataset-1: We have generated a diverse set of random graphs with number of nodes ranging between 6 and 10 and the edge percentage of $3 7 \\%$ . The random graphs are evenly generated according to six distinct distributions: Erdos-Renyi, Barabasi-Albert, Power Law, Random Regular, Watts-Strogatz and Newman-Watts-Strogatz. Each generated graph is then paired with a random color number in $2 \\leq k \\leq 4$ to generate a graph $k$ -coloring instance. We only keep the SAT instances in the dataset. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dataset-2: We first generate random trees with the same number of nodes as Dataset-1. Then each tree is paired with a random color number in $2 \\leq k \\leq 4$ . Since the chromatic number of trees is 2, every single pair so far is SAT. Lastly, for each pair we keep adding random edges to the graph until it becomes UNSAT, then we remove the last added edge to make the instance SAT again and stop. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Even though Dataset-1 has much higher coverage in terms of different graph distributions, Dataset2 contains harder SAT examples in general, simply because in average, it contains maximally constrained instances that are still SAT. We evaluated both our method and NeuroSAT (which were both trained on $k$ -SAT-3-10) on these test datasets. Our method could solve $4 8 \\%$ and $2 7 \\%$ of the SAT problems in Dataset-1 and Dataset-2, respectively. However, to our surprise, the same NeuroSAT model that generated the out-of-sample results on $k$ -SAT datasets in Figure 2, could not solve any of the SAT graph $k$ -coloring problems in Dataset-1 and Dataset-2, even after 128 propagation iterations. This does not match the results reported in Selsam et al. (2018) on graph coloring. We suspect different CNF formulations for the graph $k$ -coloring problem might be the cause behind this discrepancy, which would mean that NeuroSAT is quite sensitive to the change of problem distribution. Nevertheless, the final judgment remains open up to further investigations. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            291
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In a separate effort, we tried to actually train a fresh NeuroSAT model on a larger versions of Dataset-1 and Dataset-2 which also included UNSAT examples. However, despite a significant decrease on the classification training loss, NeuroSAT failed to decode any of the SAT problems in the test sets. We attribute this behavior to the fact that NeuroSAT is dependent on learning a good SAT classifier that can capture the conceptual essence of SAT vs. UNSAT. As a result, in order to avoid learning superficial classification features, NeuroSAT restricts its training to a strict regime of SAT-UNSAT pairs, where the two examples in a pair only differ in negation of one literal. However, such strict regime can be only enforced in the random $k$ -SAT problems. For graph coloring, the closest strategy we could come up with was the one in Dataset-2, where the SAT-UNSAT examples in a pair only differ in an edge (which still translates to a couple of clauses in the CNF). This again signifies the importance of learning the solver directly rather than relying on a classification proxy. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            472,
+            310,
+            488
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we proposed a neural framework for efficiently learning a Circuit-SAT solver. Our methodology relies on two fundamental contributions: (1) a rich DAG-embedding architecture that implements the sequential propagation mechanism on DAG-structured data and is capable of learning useful representations for the input circuits, and (2) an efficient training procedure that trains the DAGembedding architecture directly toward solving the SAT problem without requiring SAT/UNSAT labels in general. Our proposed training strategy is fully differentiable end-to-end and at the same time enjoys many features of Reinforcement Learning such as an Explore-Exploit mechanism and direct training toward the end goal. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            614
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As our experiments showed, the proposed embedding architecture is able to harness structural information in the input DAG distribution and as a result solve the test SAT cases in a fewer number of iterations compared to the baseline. This would also allow us to inject domain-specific heuristics into the circuit structure of the input data to obtain better models for that specific domain. Moreover, our direct training procedure as opposed to the indirect, classification-based method in NeuroSAT enables our model to generalize better to out-of-sample test cases, as demonstrated by the experiments. This superior generalization got even more expressed as we transferred the trained models to a complete new domain (i.e. graph coloring). Furthermore, we argued that not only does direct training give us superior out-of-sample generalization, but it is also essential for the problem domains where we cannot enforce the strict training regime where SAT and UNSAT cases come in pairs with almost identical structures, as proposed by Selsam et al. (2018). ",
+        "bbox": [
+            174,
+            622,
+            825,
+            775
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Future efforts in this direction would include closely examining the SAT solver algorithm learned by our framework to see if any high-level knowledge and insight can be extracted to further aide the classical SAT solvers. Needless to say, this type of neural models have a long way to go in order to compete with industrial SAT solvers; nevertheless, these preliminary results are promising enough to motivate the community to pursue this direction. ",
+        "bbox": [
+            174,
+            781,
+            823,
+            852
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            867,
+            326,
+            881
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Leonardo de Moura and Nikolaj Bjorner from Microsoft Research for the valuable feedback and discussions. ",
+        "bbox": [
+            173,
+            891,
+            823,
+            919
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peter B Andrews. An introduction to mathematical logic and type theory, volume 27. Springer Science & Business Media, 2002. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            155
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Forough Arabshahi, Sameer Singh, and Animashree Anandkumar. Combining symbolic and function evaluation expressions in neural programs. arXiv preprint arXiv:1801.04342, 2018. ",
+        "bbox": [
+            173,
+            162,
+            823,
+            191
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kai Arulkumaran, Marc Peter Deisenroth, Miles Brundage, and Anil Anthony Bharath. A brief survey of deep reinforcement learning. arXiv preprint arXiv:1708.05866, 2017. ",
+        "bbox": [
+            174,
+            199,
+            821,
+            229
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pierre Baldi and Gianluca Pollastri. The principled design of large-scale recursive neural network architectures–dag-rnns and the protein structure prediction problem. Journal of Machine Learning Research, 4(Sep):575–602, 2003. ",
+        "bbox": [
+            174,
+            238,
+            823,
+            280
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Irwan Bello, Hieu Pham, Quoc V Le, Mohammad Norouzi, and Samy Bengio. Neural combinatorial optimization with reinforcement learning. arXiv preprint arXiv:1611.09940, 2016. ",
+        "bbox": [
+            171,
+            287,
+            823,
+            319
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Armin Biere. Picosat essentials. Journal on Satisfiability, Boolean Modeling and Computation, 4: 75–97, 2008. ",
+        "bbox": [
+            173,
+            325,
+            825,
+            354
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Armin Biere, Marijn Heule, Hans van Maaren, and Toby Walsh. Conflict-driven clause learning sat solvers. Handbook of Satisfiability, Frontiers in Artificial Intelligence and Applications, pp. 131–153, 2009. ",
+        "bbox": [
+            173,
+            363,
+            825,
+            406
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael M Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017. ",
+        "bbox": [
+            174,
+            414,
+            825,
+            457
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. arXiv preprint arXiv:1312.6203, 2013. ",
+        "bbox": [
+            169,
+            465,
+            825,
+            496
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014. ",
+        "bbox": [
+            171,
+            502,
+            823,
+            534
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In Advances in Neural Information Processing Systems, pp. 3844–3852, 2016. ",
+        "bbox": [
+            173,
+            540,
+            825,
+            583
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard Evans, David Saxton, David Amos, Pushmeet Kohli, and Edward Grefenstette. Can neural networks understand logical entailment? arXiv preprint arXiv:1802.08535, 2018. ",
+        "bbox": [
+            171,
+            592,
+            823,
+            622
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhaohui Fu and Sharad Malik. Extracting logic circuit structure from conjunctive normal form descriptions. In VLSI Design, 2007. Held jointly with 6th International Conference on Embedded Systems., 20th International Conference on, pp. 37–42. IEEE, 2007. ",
+        "bbox": [
+            176,
+            628,
+            823,
+            672
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marijn JH Heule, Oliver Kullmann, Siert Wieringa, and Armin Biere. Cube and conquer: Guiding cdcl sat solvers by lookaheads. In Haifa Verification Conference, pp. 50–65. Springer, 2011. ",
+        "bbox": [
+            171,
+            680,
+            825,
+            710
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhiting Hu, Xuezhe Ma, Zhengzhong Liu, Eduard Hovy, and Eric Xing. Harnessing deep neural networks with logic rules. arXiv preprint arXiv:1603.06318, 2016. ",
+        "bbox": [
+            171,
+            717,
+            823,
+            747
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Himanshu Jain and Edmund M Clarke. Efficient sat solving for non-clausal formulas using dpll, graphs, and watched cuts. In Proceedings of the 46th Annual Design Automation Conference, pp. 563–568. ACM, 2009. ",
+        "bbox": [
+            174,
+            755,
+            825,
+            797
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Elias Khalil, Hanjun Dai, Yuyu Zhang, Bistra Dilkina, and Le Song. Learning combinatorial optimization algorithms over graphs. In Advances in Neural Information Processing Systems, pp. 6351–6361, 2017. ",
+        "bbox": [
+            173,
+            806,
+            826,
+            849
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Risi Kondor, Hy Truong Son, Horace Pan, Brandon Anderson, and Shubhendu Trivedi. Covariant compositional networks for learning graphs. arXiv preprint arXiv:1801.02144, 2018. ",
+        "bbox": [
+            173,
+            858,
+            823,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joao Marques-Silva. The impact of branching heuristics in propositional satisfiability algorithms. In Portuguese Conference on Artificial Intelligence, pp. 62–74. Springer, 1999. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodola, Jan Svoboda, and Michael M Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. In Proc. CVPR, volume 1, pp. 3, 2017. ",
+        "bbox": [
+            176,
+            141,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew W Moskewicz, Conor F Madigan, Ying Zhao, Lintao Zhang, and Sharad Malik. Chaff: Engineering an efficient sat solver. In Proceedings of the 38th annual Design Automation Conference, pp. 530–535. ACM, 2001. ",
+        "bbox": [
+            174,
+            193,
+            825,
+            234
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Razvan Pascanu, Caglar Gulcehre, Kyunghyun Cho, and Yoshua Bengio. How to construct deep recurrent neural networks. arXiv preprint arXiv:1312.6026, 2013. ",
+        "bbox": [
+            173,
+            243,
+            823,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2009. ",
+        "bbox": [
+            174,
+            281,
+            821,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel Selsam, Matthew Lamm, Benedikt Bunz, Percy Liang, Leonardo de Moura, and David L Dill. Learning a sat solver from single-bit supervision. arXiv preprint arXiv:1802.03685, 2018. ",
+        "bbox": [
+            176,
+            319,
+            823,
+            349
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bing Shuai, Zhen Zuo, Bing Wang, and Gang Wang. Dag-recurrent neural networks for scene labeling. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3620–3629, 2016. ",
+        "bbox": [
+            173,
+            357,
+            825,
+            400
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014. ",
+        "bbox": [
+            173,
+            409,
+            823,
+            439
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kai Sheng Tai, Richard Socher, and Christopher D Manning. Improved semantic representations from tree-structured long short-term memory networks. arXiv preprint arXiv:1503.00075, 2015. ",
+        "bbox": [
+            173,
+            445,
+            821,
+            476
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Thiffault, Fahiem Bacchus, and Toby Walsh. Solving non-clausal formulas with dpll search. In International Conference on Principles and Practice of Constraint Programming, pp. 663–678. Springer, 2004. ",
+        "bbox": [
+            174,
+            484,
+            826,
+            526
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Miroslav N Velev. Exploiting hierarchy and structure to efficiently solve graph coloring as sat. In Proceedings of the 2007 IEEE/ACM international conference on Computer-aided design, pp. 135–142. IEEE Press, 2007. ",
+        "bbox": [
+            173,
+            536,
+            825,
+            579
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pp. 2692–2700, 2015. ",
+        "bbox": [
+            173,
+            587,
+            823,
+            617
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jingyi Xu, Zilu Zhang, Tal Friedman, Yitao Liang, and Guy Van den Broeck. A semantic loss function for deep learning with symbolic knowledge. arXiv preprint arXiv:1711.11157, 2017. ",
+        "bbox": [
+            173,
+            625,
+            825,
+            655
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Ruslan R Salakhutdinov, and Alexander J Smola. Deep sets. In Advances in Neural Information Processing Systems, pp. 3394–3404, 2017. ",
+        "bbox": [
+            173,
+            662,
+            825,
+            705
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX A: ADAPTING DG-DAGRNN FOR CIRCUIT-SAT CLASSIFICATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            820,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In the classification problem, we are interested to merely classify each input circuit as SAT or UNSAT. To do so, we customize DG-DAGRNN framework as follows. The classification function $\\mathcal { C } _ { \\alpha }$ is set to be a MLP with ReLU activation function for the hidden layers and the Sigmoid activation for the output layer. As the result the output space $\\mathcal { O }$ will become [0, 1]. The embedding function $\\mathcal { E } _ { \\beta }$ is set to be a multi-layer recursive embedding as in equation 3 with interleaving regular forward and reversed layers. For the classification problem, we make sure the last layer of the embedding is a forward layer so that we can read off from only one sink node (i.e. the expression root node) and feed the result to the classification function for the final prediction. Finally given a labeled training set, we minimize the standard cross-entropy loss via the end-to-end backpropagation through the entire network. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            260
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B: PROOF OF NO FALSE POSITIVES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            280,
+            562,
+            297
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section, we prove that for any UNSAT input circuit $\\mu _ { G }$ , the satisfiability function $ { \\boldsymbol { S } } _ {  { \\boldsymbol { \\theta } } } (  { \\boldsymbol { \\mu } } _ { G } )$ at the prediction time will never go beyond 0.5, and as a result, our model would never produce false positives. To prove that, first we show that thresholding the output of the evaluator network $\\mathcal { R } _ { G }$ for a soft assignment $^ { a }$ is equivalent to applying the original circuit $\\mu _ { G }$ to the hard assignment corresponding to $^ { a }$ : ",
+        "bbox": [
+            173,
+            313,
+            825,
+            383
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1. Let $\\mu _ { G }$ be any $D A G$ function representing a Boolean circuit with underlying topology $G$ . Also let $\\mathcal { R } _ { G }$ be the evaluator network corresponding to $\\mu _ { G }$ where all the And, Or and Not gates are replaced by the $\\operatorname* { m i n } ( \\cdot )$ , $\\operatorname* { m a x } ( { \\mathord { \\cdot } } )$ and $\\mathcal { N } ( \\cdot )$ functions, respectively. Moreover, for any soft assignment $\\pmb { a } = ( a _ { 1 } , a _ { 2 } , . . . , a _ { n } ) \\in [ 0 , 1 ] ^ { n }$ , let its corresponding hard assignment $\\mathcal { H } ( \\pmb { a } ) =$ $\\left( \\mathcal { H } ( a _ { 1 } ) , \\mathcal { H } ( a _ { 2 } ) , . . . , \\mathcal { H } ( a _ { n } ) \\right)$ be obtained by thresholding at 0.5; that is, $\\forall i \\in 1 . . n : \\mathcal { H } ( a _ { i } ) = \\mathbb { I } ( a _ { i } >$ 0.5). Then we have $\\mathcal { H } \\big ( \\mathcal { R } _ { G } ( \\mathbf { { a } } ) \\big ) = \\mu _ { G } \\big ( \\mathcal { H } ( \\mathbf { { a } } ) \\big )$ for all soft assignments $\\pmb { a } \\in [ 0 , 1 ] ^ { n }$ . ",
+        "bbox": [
+            173,
+            387,
+            825,
+            477
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof. Proof by induction on the number of gates $N$ in $\\mu _ { G }$ : for the base case (i.e. $N = 1$ ), the circuit $\\mu _ { G }$ simply consists of one gate. Depending on the type of this gate, we can have three possibilities: ",
+        "bbox": [
+            174,
+            493,
+            823,
+            523
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/add67401c0389dca6aac175c7e680c8ee55b963676a14854df5d31fbafe09a87.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { A n d } ) \\ \\mathcal { H } \\big ( \\operatorname* { m i n } ( a _ { 1 } , . . . , a _ { n } ) \\big ) = \\operatorname* { m i n } \\big ( \\mathcal { H } ( a _ { 1 } ) , . . . , \\mathcal { H } ( a _ { n } ) \\big ) = \\mathbf { A n d } \\big ( \\mathcal { H } ( a _ { 1 } ) , . . . , \\mathcal { H } ( a _ { n } ) \\big ) } \\\\ & { \\begin{array} { r l } { \\mathbf { ( O r ) } \\ \\mathcal { H } \\big ( \\operatorname* { m a x } ( a _ { 1 } , . . . , a _ { n } ) \\big ) = \\operatorname* { m a x } \\big ( \\mathcal { H } ( a _ { 1 } ) , . . . , \\mathcal { H } ( a _ { n } ) \\big ) = \\mathbf { O r } \\big ( \\mathcal { H } ( a _ { 1 } ) , . . . , \\mathcal { H } ( a _ { n } ) \\big ) } \\\\ { \\mathbf { ( N o t ) } \\ \\mathcal { H } \\big ( \\mathcal { N } ( a ) \\big ) = \\mathcal { H } ( 1 - a ) = 1 - \\mathcal { H } ( a ) = \\mathbf { N o t } \\big ( \\mathcal { H } ( a ) \\big ) } \\end{array} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            189,
+            535,
+            732,
+            613
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Now let us assume the lemma holds for any circuit with strictly less than $N$ gates. We want to prove it also holds for any circuit $\\mu _ { G }$ with $N$ gates. For the sake of simplicity, let us assume the sink node (i.e. the final gate) of $\\mu _ { G }$ is an And gate (the same argument can be made for $\\mathbf { o r }$ and Not gates). If the final gate has $k$ inputs and is removed from the circuit, we will end up with $k$ (possibly overlapping) sub-circuits $\\mu _ { G _ { 1 } } , . . . , \\mu _ { G _ { k } }$ with corresponding evaluator networks $\\mathcal { R } _ { G _ { 1 } } , . . . , \\mathcal { R } _ { G _ { k } }$ . We can then write: ",
+        "bbox": [
+            174,
+            626,
+            828,
+            696
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/63d7f1a62cec8097e6bba351ecca2e8e56afb9b5e0954b1317ea383754b75880.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { H } \\big ( \\mathcal { R } _ { G } ( a ) \\big ) = \\mathcal { H } \\bigg ( \\operatorname* { m i n } \\big ( \\mathcal { R } _ { G _ { 1 } } ( a ) , . . . , \\mathcal { R } _ { G _ { k } } ( a ) \\big ) \\bigg ) = \\mathbf { A } \\mathbf { n d } \\bigg ( \\mathcal { H } \\big ( \\mathcal { R } _ { G _ { 1 } } ( a ) \\big ) , . . . , \\mathcal { H } \\big ( \\mathcal { R } _ { G _ { k } } ( a ) \\big ) \\bigg ) } \\\\ & { \\quad \\quad \\quad = \\mathbf { A } \\mathbf { n d } \\bigg ( \\mu _ { G _ { 1 } } \\big ( \\mathcal { H } ( a ) \\big ) , . . . , \\mu _ { G _ { k } } \\big ( \\mathcal { H } ( a ) \\big ) \\bigg ) = \\mu _ { G } \\big ( \\mathcal { H } ( a ) \\big ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            199,
+            704,
+            797,
+            775
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where the second and the third equalities come from the base and the inductive steps of the induction, respectively. □ ",
+        "bbox": [
+            171,
+            780,
+            826,
+            809
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. $\\mu _ { G }$ is UNSAT if and only if $\\mathcal { R } _ { G } ( { \\pmb a } ) \\le 0 . 5$ for all soft assignments $\\pmb { a } \\in [ 0 , 1 ] ^ { n }$ . ",
+        "bbox": [
+            169,
+            819,
+            767,
+            837
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof. (If) Proof by contradiction: let us assume $\\mu _ { G }$ is indeed SAT. Then there exists at least one hard assignment $\\hat { \\pmb { a } } \\in \\{ 0 , 1 \\} ^ { n }$ such that $\\mu _ { G } ( \\hat { \\pmb a } ) = 1$ . However, for hard assignment values, the $\\operatorname* { m i n } ( \\cdot ) , \\operatorname* { m a x } ( \\cdot )$ and $\\mathcal { N } ( \\cdot )$ functions behave exactly the same as the And, Or and Not gates, respectively. This means that for hard assignments, we have $\\mu _ { G } \\equiv \\mathcal { R } _ { G }$ , which further yields $\\mathcal { R } _ { G } ( { \\hat { a } } ) = { \\dot { \\mu } } _ { G } ( { \\hat { a } } ) = 1 > 0 . 5 .$ . This would in turn lead to a contradiction. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(Only-If) Proof by contradiction: let us assume that there exists a soft assignment $\\pmb { a } \\in [ 0 , 1 ] ^ { n }$ such that $\\mathcal { R } _ { G } ( { \\pmb a } ) > 0 . 5$ , then using Lemma 1 and the definition of $\\mathcal { H } ( \\cdot )$ , we will have: ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/21382bd21b285fa276a685bd7db96d17d42629d5a94e35512499de6a4c58e0fc.jpg",
+        "text": "$$\n\\mu _ { G } \\big ( \\mathcal { H } ( \\pmb { a } ) \\big ) = \\mathcal { H } \\big ( \\mathcal { R } _ { G } ( \\pmb { a } ) \\big ) = \\mathbb { I } \\big ( \\mathcal { R } _ { G } ( \\pmb { a } ) > 0 . 5 \\big ) = 1\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            135,
+            669,
+            154
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In other words, we have found a hard assignment $\\mathcal { H } ( a )$ that satisfies the circuit $\\mu _ { G }$ ; this is a contradiction. □ ",
+        "bbox": [
+            166,
+            155,
+            821,
+            184
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX C: CONVERTING CNF TO CIRCUIT ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            202,
+            558,
+            219
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "There are many ways one can convert a CNF to a circuit; some are optimized toward extracting structural information – e.g. Fu & Malik (2007). Here, we have taken a more intuitive and general approach based on the Cube and Conquer paradigm (Heule et al. (2011)) for solving CNF-SAT problems. In the Cube and Conquer paradigm, for a given input Boolean formula $F$ , a variable $x$ in $F$ is picked and set to TRUE once to obtain $F _ { x } ^ { + }$ and to FALSE the other time to get $F _ { x } ^ { - }$ . Now if we can find a SAT solution for either of $F _ { x } ^ { + }$ or $F _ { x } ^ { - }$ , then we also have a SAT solution for $F$ . Since neither of $F _ { x } ^ { + }$ or $F _ { x } ^ { - }$ contains $x$ , we effectively reduce the complexity of the original SAT problem by removing one variable. This process can be repeated recursively (up to a fixed level) for $F _ { x } ^ { + }$ and $\\dot { F } _ { x } ^ { - }$ by picking a new variable to reduce the complexity even further. Now inspired by this paradigm, one can easily show that the following logical equivalence holds for any variable $x$ in $F$ : ",
+        "bbox": [
+            173,
+            233,
+            825,
+            373
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3f5bf81f90276ae2b581d24d32f7f47986bbf989dff2d525435a3e95621b0182.jpg",
+        "text": "$$\nF \\Leftrightarrow ( x \\wedge F _ { x } ^ { + } ) \\vee ( \\neg x \\wedge F _ { x } ^ { - } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            375,
+            598,
+            392
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "And this is exactly the principle we used to convert a CNF formula $F$ into a circuit. In particular, by applying the equivalence in equation 8 recursively, up to a fixed level4, we perform the CNF to circuit conversion (Note that $\\hat { F _ { x } ^ { + } }$ and $F _ { x } ^ { - }$ are also CNFs). The natural question then is in what order we should pick variables to apply equation 8. That is where the heuristic part comes into play: depending on the specific class of SAT problems we are targeting, we can incorporate a garden variety of ordering heuristics (aka the branching heuristics) in the literature – e.g. Biere et al. (2009); Heule et al. (2011); Marques-Silva (1999); Moskewicz et al. (2001). In our experiments for random $k$ -SAT problems, each time we simply pick the variable that appears in the largest number of clauses in the current CNF. ",
+        "bbox": [
+            173,
+            393,
+            826,
+            518
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX D: REPRESENTING GRAPH $k$ -COLORING AS CNF AND CIRCUIT ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            537,
+            797,
+            555
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We know from Computer Science theory that the graph $k$ -coloring problem can be reduced to the SAT problem by representing the problem as a Boolean CNF. There are many ways in the literature to do so; we have picked the Muldirect approach from Velev (2007). In particular, for a graph with $N$ nodes and maximum $k$ allowed colors, we define the Boolean variables $\\boldsymbol { x } _ { i j }$ for $1 \\leq i \\leq N$ and $1 \\leq j \\leq k$ , where $x _ { i j } = 1$ indicates that the ith node is colored by the $j$ th color. Then, the CNF encoding the decision graph $k$ -coloring problem is defined as: ",
+        "bbox": [
+            173,
+            569,
+            825,
+            654
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/35958a76db109f6e44c11d9ca7dde49ecbf984813ccaa86d4236dddb66b0891d.jpg",
+        "text": "$$\n\\biggl [ \\bigwedge _ { i = 1 } ^ { N } \\biggl ( \\bigvee _ { j = 1 } ^ { k } x _ { i j } \\biggr ) \\biggr ] \\wedge \\biggl [ \\bigwedge _ { ( p , q ) \\in E } \\biggl ( \\bigwedge _ { j = 1 } ^ { k } ( \\neg x _ { p j } \\vee \\neg x _ { q j } ) \\biggr ) \\biggr ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            656,
+            676,
+            700
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where $E$ is the set of the graph edges. The left set of clauses in equation 9 ensure that each node of the graph takes at least one color. The right set of clauses in equation 9 enforce the constraint that the neighboring nodes cannot take the same color. As a result, any satisfiable solution to the CNF in equation 9 corresponds to at least one coloring solution for the original problem if not more. Note that in this formulation, we do not require each node to take only one color value; therefore, one SAT solution can produce multiple valid graph coloring solutions. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            786
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To generate a circuit from the above CNF, we note that the graph structure in graph coloring problem contains valuable structural information that can be potentially encoded as heuristics into the circuit structure. One such good heuristics, in particular, is the node degrees. More specifically, the most constrained variable first heuristic in Constraint Satisfaction Problems (CSPs) recommends assigning values to the most constrained variable first. In graph coloring problem, the higher the node degree, the more constrained the variables associated with that node are. Therefore, sorting the graph nodes based on their degrees would give us a meaningful variable ordering, which can be further used to build the circuit using the equivalence in equation 8, for example. ",
+        "bbox": [
+            173,
+            792,
+            826,
+            905
+        ],
+        "page_idx": 13
+    }
+]

parse/train/KOk7mUGspN9/KOk7mUGspN9_content_list.json

@@ -0,0 +1,1493 @@
+[
+    {
+        "type": "text",
+        "text": "On the Fundamental Trade-offs in Learning Invariant Representations ",
+        "text_level": 1,
+        "bbox": [
+            232,
+            122,
+            767,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Many applications of representation learning, such as privacy-preservation, al  \n2 gorithmic fairness and domain adaptation, desire explicit control over semantic   \n3 information being discarded. This goal is often formulated as satisfying two po  \n4 tentially competing objectives: maximizing utility for predicting a target attribute   \n5 while simultaneously being independent or invariant with respect to a known seman  \n6 tic attribute. In this paper, we identify and determine two fundamental trade-offs   \n7 between utility and semantic dependence induced by the statistical dependencies   \n8 between the data and its corresponding target and semantic attributes. We derive   \n9 closed-form solutions for the global optima of the underlying optimization prob  \n10 lems under mild assumptions, which in turn yields closed formulae for the exact   \n11 trade-offs. We also derive empirical estimates of the trade-offs and show their   \n12 convergence to the corresponding population counterparts. Finally, we numeri  \n13 cally quantify the trade-offs on representative problems and compare the solutions   \n14 achieved by baseline representation learning algorithms. ",
+        "bbox": [
+            148,
+            348,
+            767,
+            542
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "15 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            566,
+            310,
+            584
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "16 Real-world applications of representation learning algorithms often have to contend with objectives   \n17 beyond predictive performance. These include cost functions pertaining to, invariance (e.g., to   \n18 photometric or geometric variations), semantic independence (e.g., w.r.t to age or race for face   \n19 recognition systems), privacy (e.g., mitigating leakage of sensitive information [1]), algorithmic   \n20 fairness (e.g., demographic parity [2]), and generalization across multiple domains [3], to name a few.   \n21 At its core, the underlying goal of the aforementioned formulations of representation learning is to   \n22 satisfy two competing objectives, extracting as much information necessary to predict a target label   \n23 $\\textbf {  { y } }$ (e.g., face identity) while intentionally and permanently suppressing information pertaining to a   \n24 desired semantic attribute $\\pmb { s }$ (e.g., age, gender or race). When $\\textbf {  { y } }$ is independent of $\\pmb { s }$ , one can learn a   \n25 representation that is independent of $\\pmb { s }$ with no loss of performance, i.e., no trade-off exists between   \n26 the two objectives. However, when the two attributes $\\textbf {  { y } }$ and $\\pmb { s }$ are correlated, attaining semantic   \n27 independence will necessarily reduce the performance of the target predictor, i.e., there is a trade-off   \n28 between the two objectives. The trade-off is unknown yet is important for understanding the limits of   \n29 existing and future representation learning algorithms that involve semantic independence constraints.   \n30 Let $z = f ( { \\pmb x } )$ be a representation of input data $_ { \\textbf { \\em x } }$ , and $f ( \\cdot )$ be the encoder (see Fig 1(a)). Invariant   \n31 learning requires that prediction of the target label, ${ \\widehat { \\pmb { y } } } = g _ { Y } ( z )$ be independent of a semantic attribute   \n32 $\\pmb { s }$ i.e., $\\boldsymbol { \\widehat { y } } \\perp \\perp \\boldsymbol { s }$ for all possible downstream target predictors $\\overset { \\cdot } { g _ { Y } ( \\cdot ) }$ . This independence condition is   \n33 satisfied if and only if (iff), the representation $_ z$ is independent of $\\pmb { s }$ i.e., $z \\perp \\perp s$ . Therefore, Invariant   \n34 representation learning (IRL) seeks to optimize two objectives: i) the degree of dependence between   \n35 data representation $_ z$ and semantic attribute $\\pmb { s }$ , and ii) target task utility. These two objectives can be   \n36 combined into one, with a parameter $\\tau$ controlling the trade-off.   \n37 In this paper, we identify and analytically determine two fundamental trade-offs in the invariant   \n38 representation learning setting introduced above, namely Data Space Trade-Off and Label Space   \n39 Trade-Off. These trade-offs are illustrated in Figure 1 (b) and formally defined next.   \n40 Definition 1. Data Space Trade-Off arises from the statistical dependence between the target attribute   \n41 $\\textbf {  { y } }$ and the semantic attribute $\\pmb { s }$ conditioned on the given input data $_ { \\textbf { \\em x } }$ . When the learner’s hypothesis   \n42 class contains all Borel-measurable functions1 we have: ",
+        "bbox": [
+            147,
+            598,
+            825,
+            667
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            672,
+            825,
+            799
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            804,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/4b41f619b913d0b024a06e9ffd146496a768341a1e6fc6bf1f8d3e1e0ad4349a.jpg",
+        "image_caption": [
+            "Figure 1: (a): Generic frame work of invariant representation learning (IRL) where attributes $\\pmb { s }$ and $\\textbf {  { y } }$ are caused by a latent factor $\\textbf { \\em a }$ and are not marginally independent. Under this setting, IRL seeks a representation $z = f ( { \\pmb x } )$ that contains enough information for downstream target predictor $g _ { Y } ( \\cdot )$ while being independent of the semantic attribute $\\pmb { s }$ . Consequently, the prediction ${ \\widehat { \\pmb { y } } } = g _ { Y } ( z )$ will also be independent of $\\pmb { s }$ for any downstream predictor $g _ { Y } ( \\bar { \\cdot } )$ . (b): We identify and determine two different fundamental trade-offs between utility (i.e., the performance of target task predictor) and dependence measure $\\deg ( z , s )$ by an optimal learner in the hypothesis class of Borel-measurable functions. Trade-off $\\mathbf { L }$ is induced by the joint distribution of the labels $p _ { y s }$ . Trade-off $\\mathbf { D }$ is induced by the joint distribution of the data $p _ { { \\pmb x } { \\pmb y } { \\pmb s } }$ . Trade-off $\\mathbf { F }$ is a relaxed version of trade-off $\\mathbf { D }$ obtained by either using a surrogate measure of dependence, e.g., adversarial learning [3] or from a constrained hypothesis class [4], or from using sub-optimal optimization algorithms. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            89,
+            810,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            492,
+            825,
+            535
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            537,
+            828,
+            579
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cd866cf20062d35a070a4db8d02708c7aa68a5d3b81e044962bf3f7319225de3.jpg",
+        "text": "$$\n\\operatorname* { i n f } _ { f ( \\cdot ) \\mathrm { ~ m e a s u r a b l e } } \\Big \\{ ( 1 - \\tau ) \\operatorname* { i n f } _ { g _ { Y } ( \\cdot ) \\mathrm { ~ m e a s u r a b l e } } \\mathbb { E } _ { x , y } \\Big [ \\mathcal { L } _ { Y } \\Big ( g _ { Y } \\big ( f ( x ) ) , y \\Big ) \\Big ] + \\tau \\mathrm { d e p } ( f ( x ) , s ) \\Big \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            580,
+            751,
+            611
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "43 where $f ( \\cdot )$ is the encoder that extracts representation $_ z$ from $_ { \\textbf { \\em x } }$ , $g _ { Y } ( \\cdot )$ predicts $\\widehat { \\pmb { y } }$ from the repre  \n44 sentation $_ z$ , $\\mathcal { L } _ { Y } ( \\cdot , \\cdot )$ is the loss for the desired task of predicting the task label $\\textbf {  { y } }$ . The function   \n45 $\\mathrm { d e p } ( \\cdot , \\cdot ) \\geq 0$ is a parametric or non-parametric measure of statistical dependence i.e., $\\mathrm { d e p } ( q , r ) = 0$   \n46 means $\\pmb q$ and $\\mathbfit { \\Delta } \\mathbf { r }$ are independent, and $\\mathrm { d e p } ( q , r ) > 0$ means $\\pmb q$ and $\\pmb { r }$ are dependent with larger values   \n47 indicating greater degrees of dependence. The scalar $\\tau \\in [ 0 , 1 )$ is a hyper-parameter that controls   \n48 the trade-off between the two objectives, with $\\tau = 0$ being the standard approach that enforces no   \n49 independence to the attribute $\\pmb { s }$ , while $\\tau  1$ enforces representation $_ z$ to be independent of $\\pmb { s }$ .   \n50 Including all measurable functions in the hypothesis class of the encoder $f ( \\cdot )$ and target predic  \n51 tor $g _ { Y } ( \\cdot )$ ensures that the best possible trade-off is included within the feasible solution space.   \n52 For example, when $\\tau = 0$ and $\\bar { \\mathcal { L } } _ { Y } ( \\cdot , \\cdot )$ is the mean-squared error, the optimal Bayes estimator,   \n53 $g _ { Y } ( f ( \\pmb { x } ) ) = \\mathbb { E } _ { \\pmb { y } } [ \\pmb { y } | \\pmb { x } ]$ is reachable. This definition corresponds to the trade-off $\\mathbf { D }$ in Figure 1 (b).   \n54 Definition 2. Label Space Trade- $O f f$ arises by ignoring the data $_ { \\textbf { \\em x } }$ and is purely determined by the   \n55 statistical dependence between the target feature $\\textbf {  { y } }$ and the semantic attribute $\\pmb { s }$ . Such a trade-off can   \n56 be defined as: ",
+        "bbox": [
+            147,
+            616,
+            825,
+            713
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            722,
+            826,
+            780
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            781,
+            825,
+            823
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1105840a7cda0a0a7cc0ef367e69df7054bdd17c4e8cc4a2b44a4a79758b374b.jpg",
+        "text": "$$\n\\operatorname* { i n f } _ { z \\in L ^ { 2 } } \\Big \\{ ( 1 - \\tau ) \\operatorname* { i n f } _ { g _ { Y } ( \\cdot ) \\mathrm { ~ m e a s u r a b l e } } \\mathbb { E } _ { x , y } \\Big [ \\mathcal { L } _ { Y } \\big ( g _ { Y } ( z ) , y \\big ) \\Big ] + \\tau \\deg ( z , s \\big ) \\Big \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            824,
+            700,
+            854
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where 57 $L ^ { 2 }$ is the space of all random vectors with finite second-order moment (i.e., $\\mathbb { E } _ { z } [ \\| z \\| ^ { 2 } ] < \\infty$ ) 58 on the same probability space in which the joint variable $( s , y )$ comes from. ",
+        "bbox": [
+            145,
+            859,
+            828,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "59 This definition corresponds to the optimal trade-off obtained by an ideal representation $_ { z }$ that is not   \n60 constrained by the learnability of the encoder $f ( \\cdot )$ . For example, if $\\tau = 0$ , the ideal representation   \n61 $_ z$ is perfectly aligned with the target label $\\textbf {  { y } }$ i.e., $z = y$ and $g _ { Y } ( \\cdot )$ is the identity function, perfect   \n62 prediction of target attribute is feasible. Therefore, this trade-off corresponds to the best trade-off that   \n63 any combination of data $_ { \\textbf { \\em x } }$ and learnable encoder $f ( \\cdot )$ can aspire to. This definition corresponds to   \n64 the trade-off $\\mathbf { L }$ in Figure 1 (b), and it necessarily dominates the Data Space Trade-Off D.   \n65 Contributions: i) Identify two fundamental trade-offs in invariant representation learning. ii) Obtain   \n66 closed-form solution for the corresponding optimization problems, and consequently determine the   \n67 trade-offs exactly. iii) Provide consistent empirical closed-form solution for the representations that   \n68 achieve optimal trade-offs. iv) Numerically quantify the trade-offs defined here and compare them to   \n69 those obtained by existing solutions.   \n70 Implications: i) Our closed-form empirical estimators for the optimal representations lend themselves   \n71 to practical invariant representation learning algorithms. ii) Theoretically elucidating and empirically   \n72 quantifying the intrinsic limits of invariant representations will enable researchers and practitioners   \n73 alike to identify the feasible and infeasible solution space for the trade-offs and lead to informed   \n74 development and deployment of optimal IRL methods. iii) Our theoretical analysis sheds light on the   \n75 utility-semantic independence trade-off, the role of statistical dependency between target label $\\textbf {  { y } }$ , the   \n76 semantic attribute $\\pmb { s }$ , and the input data $_ { \\textbf { \\em x } }$ , and the hypothesis class adopted for the learners. ",
+        "bbox": [
+            147,
+            92,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            181,
+            825,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            256,
+            825,
+            353
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "77 2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            375,
+            321,
+            392
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "78 Trade-Offs in Representation Learning: While there are abundant empirical approaches for the   \n79 representation learning applications considered in this paper, to the best of our knowledge, there   \n80 is no prior work that exactly characterizes and empirically quantifies the trade-offs inherent to   \n81 representation learning with semantic independence constraints.   \n82 Prior work primarily sought to either obtain lower or upper bounds or characterize the extreme   \n83 points of the trade-off in specific contexts such as fair representation learning. For instance, [5]   \n84 uses information theoretic tools and characterizes the utility-fairness trade-off in terms of a lower   \n85 bounds when both $\\textbf {  { y } }$ and $\\pmb { s }$ are binary labels. Later [6] provided both upper and lower bound for the   \n86 binary labels. By leveraging Chernoff bound [7] proposed a construction method to generate an ideal   \n87 representation beyond input data to achieve perfect fairness while maintaining the best performance   \n88 on target task for equalized odds. In the case of categorical features, a lower bound on utility-fairness   \n89 trade-off has been provided by [8]. The notion of Pareto optimality was used by [9] to minimize   \n90 the maximum possible error among sensitive attributes where both target and sensitive features are   \n91 categorical. In contrast to this body of work, our trade-off analysis is applicable to multi-dimensional   \n92 discrete and/or continuous attributes where we find the exact optimal trade-offs.   \n93 The only prior work that investigates fundamental trade-offs in a general setting where both $\\textbf {  { y } }$ and $\\pmb { s }$   \n94 can be continuous or discrete features, are [4] and [10]. [4] considers only linear dependence between   \n95 the representation and semantic attribute and proposed a closed-form solution for the utility-fairness   \n96 trade-off. Even though [10] considers non-linear dependencies, optimal losses have been derived only   \n97 for the extremes of the trade-off (i.e., $\\tau  0$ and $\\tau  1$ ). In a more general setting where $0 < \\tau < 1$   \n98 [10] only provides a lower bound on utility-invariance trade-off through information plane analysis.   \n99 In contrast to the foregoing, we take a functional analysis approach and utilize covariance operator   \n100 based measures of dependence that account for all non-linear dependence relations. We exactly   \n101 characterize and quantify the utility-invariance trade-offs, while also providing a means to empirically   \n102 estimate the encoder that achieves said optimal trade-off. Lastly, in addition to the Data Space   \n103 Trade-Off, we also introduce and determine the Label Space Trade-Off which is the ideal trade-off   \n104 that any unrestricted learning algorithm can aspire to.   \n105 Invariant, Fair, Privacy-Preserving Representation Learning: The basic idea of representation   \n106 learning that discards unwanted semantic information has been explored under different contexts like   \n107 invariant, fair, or privacy-preserving learning. In domain adaptation [11, 12, 13], the goal is to learn   \n108 features that are independent of the data domain. In fair learning [14, 15, 16, 17, 18, 19, 20, 21, 22, 23,   \n109 2, 24, 25, 26, 27, 4], the goal is to discard the demographic information that leads to unfair outcomes.   \n110 Similarly, there is a growing interest in mitigating unintended leakage of private information from   \n111 data representations [28, 29, 1, 30, 31]. A vast majority of this body of work is empirical in nature.   \n112 These methods implicitly look for a single or more points in the trade-off between utility and fairness   \n113 and do not explicitly seek to characterize the whole trade-off front. Overall, these approaches are   \n114 not concerned (or aware) about the feasibility and limitations on the utility-invariance trade-off. In   \n115 contrast, this paper determines the fundamental theoretical limits of controlling independence to   \n116 semantic attributes, and proposes practical learning algorithms that achieve this limit.   \n117 Adversarial Representation Learning: Most practical approaches for learning fair, invariant, do  \n118 main adaptive or privacy-preserving representations discussed above are based on adversarial repre  \n119 sentation learning (ARL). This learning problem is typically formulated as, ",
+        "bbox": [
+            148,
+            407,
+            825,
+            463
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            469,
+            825,
+            622
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            628,
+            825,
+            794
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            825,
+            148
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            137,
+            152,
+            830,
+            196
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/013b262f08910b8b5f11c7eb3567a1dcf7265674b9f9d387abb4b9cc80dff340.jpg",
+        "text": "$$\n\\operatorname* { i n f } _ { f \\in \\mathcal { H } _ { x } } \\Big \\{ ( 1 - \\tau ) \\operatorname* { i n f } _ { g \\mathrm { y } \\in \\mathcal { H } _ { y } } \\mathbb { E } _ { \\mathbf { x } , y } \\Big [ \\mathcal { L } _ { Y } \\Big ( g _ { Y } \\big ( f ( x ) \\big ) , y \\Big ) \\Big ] - \\tau \\operatorname* { i n f } _ { g _ { S } \\in \\mathcal { H } _ { s } } \\mathbb { E } _ { \\mathbf { x } , s } \\Big [ \\mathcal { L } _ { S } \\Big ( g _ { S } \\big ( f ( x ) \\big ) , s \\Big ) \\Big ] \\Big \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            200,
+            772,
+            231
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "120 where $\\mathcal { L } _ { S } ( \\cdot , \\cdot )$ is the loss function of a hypothetical adversary $g _ { S } ( \\cdot )$ who intends to extract the semantic   \n121 attribute $\\pmb { s }$ through the best predictor within the hypothesis class $\\mathcal { H } _ { s }$ . ARL is a special case of the Data   \n122 Space Trade-Off in (1) where the negative loss of the adversary, $- \\operatorname* { i n f } _ { g _ { S } \\in \\mathcal { H } _ { s } } \\mathbb { E } _ { { \\pmb x } , s } \\Big [ { \\mathscr L } _ { S } \\Big ( g _ { S } \\big ( f ( { \\pmb x } ) \\big ) , s \\Big ) \\Big ]$   \n123 plays the role of $\\mathrm { d e p } ( f ( \\pmb { x } ) , \\pmb { s } )$ . However, this form of adversarial learning suffers from a fundamental   \n124 drawback as also noted in [32, 33]. The measure of dependence induced by ARL does not account   \n125 for all modes of non-linear dependence between $\\pmb { s }$ and the representation $_ z$ . The next theorem states   \n126 this observation precisely,   \n127 Theorem 1. 2 Let $\\mathcal { H } _ { s }$ contain all Borel-measurable functions and $\\mathcal { L } _ { S } ( \\cdot , \\cdot )$ be mean squared error   \n128 (MSE) loss. Then, ",
+        "bbox": [
+            140,
+            238,
+            826,
+            349
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            352,
+            825,
+            381
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/35062611b558f36ddba8f8b8d334c6b6ae4325e451050c08d614ec237167c45d.jpg",
+        "text": "$$\nz \\in \\arg \\operatorname* { s u p } \\left\\{ \\operatorname* { i n f } _ { \\substack { g _ { S } \\in \\mathcal { H } _ { s } } } \\mathbb { E } _ { \\pmb { x } , s } \\Big [ \\mathcal { L } _ { S } \\Big ( g _ { S } ( z ) , \\pmb { s } \\Big ) \\Big ] \\right\\} \\Leftrightarrow \\mathbb { E } [ \\pmb { s } | z ] = \\mathbb { E } [ \\pmb { s } ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            386,
+            696,
+            429
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "129 This theorem implies that an optimal adversary does not necessarily lead to a representation $_ { z }$ that   \n130 is statistically independent of $\\pmb { s }$ (i.e., $p ( s | z ) \\stackrel { } { = } p ( s ) \\rangle$ ), but rather leads to $\\pmb { s }$ being mean independent   \n131 of representation $_ z$ i.e., independence with respect to first order moment only. In other words,   \n132 adversarially learned measure of dependence is not a complete measure of dependence and hence   \n133 does not account for all modes of non-linear dependence between two random variables. As such, ARL   \n134 is inherently incapable of attaining the trade-offs achievable by complete measures of dependence. ",
+        "bbox": [
+            140,
+            440,
+            826,
+            525
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "35 3 Theoretical Results ",
+        "text_level": 1,
+        "bbox": [
+            156,
+            542,
+            367,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Problem Setting ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            574,
+            326,
+            589
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "137 Consider the probability space $( \\Omega , \\mathcal { F } , \\mathbb { P } )$ , where $\\Omega$ is the sample space, $\\mathcal { F }$ is a $\\sigma -$ algebra on $\\Omega$ , and   \n138 $\\mathbb { P }$ is a probability measure on $\\mathcal { F }$ . We assume that the joint random vector $( { \\pmb x } , { \\pmb y } , { \\pmb s } )$ , containing the   \n139 input data $\\pmb { x } \\in \\mathbb { R } ^ { d _ { x } }$ , the target label $\\boldsymbol { y } \\in \\mathbb { R } ^ { d _ { \\boldsymbol { y } } }$ and the sensitive attribute $\\boldsymbol { s } \\in \\mathbb { R } ^ { d _ { s } }$ , is a random vector   \n140 on $( \\Omega , { \\mathcal { F } } )$ with joint distribution $\\mathbf { \\nabla } _ { p _ { x y s } }$ .   \n141 Assumption 1. We assume that the encoder consists of $r$ functions in an $L _ { 2 }$ -universal RKHS   \n142 $( \\mathcal { H } _ { \\pmb { x } } , k _ { \\pmb { x } } ( \\cdot , \\cdot ) )$ (e.g., Gaussian kernel), where $L _ { 2 }$ −universality guarantees that $\\mathcal { H } _ { x }$ can approximate   \n143 any Borel-measurable function with arbitrary precision [34]. ",
+        "bbox": [
+            142,
+            598,
+            825,
+            657
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            660,
+            825,
+            704
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "144 Now, the representation vector $_ z$ can be expressed as ",
+        "bbox": [
+            142,
+            713,
+            522,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fa8165d306fc4c63ea991d7c5b5b25ff298ae67f4da32a6411e134dca846233b.jpg",
+        "text": "$$\n\\begin{array} { r } { z = f ( \\pmb { x } ) : = \\left[ f _ { 1 } ( \\pmb { x } ) , \\cdots , f _ { r } ( \\pmb { x } ) \\right] ^ { T } \\in \\mathbb { R } ^ { r } , \\quad f _ { j } ( \\cdot ) \\in \\mathcal { H } _ { \\pmb { x } } \\forall j = 1 , \\ldots , r . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            734,
+            718,
+            765
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "145 where $r$ is the dimensionality of the representation $_ z$ . As discussed in Corollary 5.1, unlike common   \n146 practice where it is chosen arbitrarily, $r$ itself is an object of interest for optimization. We consider a   \n147 general scenario where both $\\textbf {  { y } }$ and $\\pmb { s }$ can be continuous or discrete, or one of $\\textbf {  { y } }$ or $\\pmb { s }$ is continuous   \n148 while the other is discrete. To do this, we substitute3 the target loss, inf $\\mathbb { E } _ { { \\pmb x } , { \\pmb y } } [ { \\mathcal { L } } _ { Y } ( g _ { Y } ( { \\pmb z } ) , { \\pmb y } ) ]$ in (1)   \ngY   \n149 with the negative of a non-parametric measure of dependence i.e., $- \\mathrm { d e p } ( z , y )$ . Furthermore, in ",
+        "bbox": [
+            140,
+            770,
+            826,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/035e387cacfb5793359d46fd8dc14b93ff0973c4ba3de84177d5dc7a55c3413e.jpg",
+        "text": "$$\n\\pmb { x }  \\overbrace { ( \\underbrace { f ( \\cdot ) } ) } ^ { \\iint ( \\underbrace { \\longrightarrow ( \\mathbb { C } \\mathrm { o v } ( f ( \\pmb { x } ) , \\beta _ { y } ( \\pmb { y } ) ) ) } _ { \\beta } + \\underbrace { ( \\beta _ { y } ( \\cdot ) ) } _ { \\beta } + \\textbf { { y } } ) } ^ { \\iint ( \\mathbb { C } \\mathrm { o v } ( f ( \\pmb { x } ) , \\beta _ { y } ( \\pmb { y } ) ) ) + ( \\beta _ { y } ( \\cdot ) ) + \\textbf { \\delta } ^ { y } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            87,
+            686,
+            183
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "150 unsupervised settings, when there is no target attribute $\\textbf {  { y } }$ , the target dependence $\\mathrm { d e p } ( z , y )$ can be   \n151 replaced with $\\mathrm { d e p } ( z , \\boldsymbol { x } )$ , which implicitly forces the representation $_ { z }$ to retain as much information   \n152 as is necessary for reconstructing the input data $_ { \\textbf { \\em x } }$ . This scenario is of practical interest when a data   \n153 producer aims to provide a representation of data that is independent of a desired semantic attribute   \n154 for any arbitrary downstream task.   \n155 We start by designing $\\deg ( z , s )$ , and $\\mathrm { d e p } ( z , y )$ follows similarly. A key desiderata of dependence   \n156 measures is that they should be able to account for all possible non-linear dependence relations   \n157 between the random variables (or vectors). Examples of such measures include information theoretic   \n158 measures such as mutual information (e.g., MINE [36]) or covariance operator based measures such   \n159 as Hilbert-Schmidt Independence Criterion [37], Constrained Covariance [38] and Kernel Canonical   \n160 Correlation [39]. The underlying principle behind the latter class of dependence measures is that   \n161 finite dimensional spaces with non-linear dependencies behave as linearly dependent spaces when   \n162 mapped appropriately to higher dimensional spaces. In this paper we adopt the covariance operator   \n163 based measures as our choice of dependence measure for analytical tractability.   \n164 Principally, $_ { z }$ and $\\pmb { s }$ are independent iff $\\mathbb { C } \\mathrm { o v } ( \\alpha ( \\pmb { z } ) , \\beta _ { s } ( \\pmb { s } ) )$ is zero for all $\\alpha ( \\cdot )$ and $\\beta _ { s } ( \\cdot )$ belong  \n165 ing to some universal RKHSs [38]. Since $z ~ = ~ f ( x )$ and $f ( \\cdot ) \\ \\in \\ \\mathcal { H } _ { x }$ , $\\mathbb { C } \\mathrm { o v } ( \\alpha ( \\pmb { z } ) , \\beta _ { s } ( \\pmb { s } ) ) \\ =$   \n166 $\\mathbb { C } \\mathrm { { \\bar { o v } } } ( \\alpha ( \\pmb { f } ( \\pmb { x } ) ) , \\beta _ { s } ( \\pmb { s } ) )$ , which necessitates application of a kernel on top of another kernel. This   \n167 limits the analytical tractability of our solution. However, as we argue below, it is almost sufficient to   \n168 consider transformation on $\\pmb { s }$ , only, in which case it reduces to $\\mathbb { C } \\mathrm { o } \\bar { \\mathbf { v } } ( \\pmb { f } ( \\pmb { x } ) , \\beta _ { s } ( \\pmb { s } ) )$ . Let $( \\mathcal { H } _ { s } , k _ { s } ( \\cdot , \\cdot ) )$   \n169 and $( \\mathcal { H } _ { \\boldsymbol { y } } , k _ { \\boldsymbol { y } } ( \\cdot , \\cdot ) )$ be separable4 RKHSs of functions defined on $\\mathbb { R } ^ { d _ { s } }$ and $\\mathbb { R } ^ { d _ { y } }$ , respectively. Consider   \n170 the bi-linear functional, ",
+        "bbox": [
+            140,
+            282,
+            825,
+            353
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            358,
+            825,
+            484
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            489,
+            825,
+            590
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/11c972a9cc38e240c5a1d2406c0fb36eaca0bdb5daf3640dd3b83a67a508d338.jpg",
+        "text": "$$\nh ( \\cdot , \\cdot ) : \\mathscr { H } _ { \\pmb { x } } \\times \\mathscr { H } _ { s }  \\mathbb { R } , h _ { j } ( f _ { j } , \\beta _ { s } ) : = \\mathbb { C } \\mathrm { o v } _ { \\pmb { x } , s } ( f _ { j } ( \\pmb { x } ) , \\beta _ { s } ( \\pmb { s } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            595,
+            687,
+            614
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "171 Assumption 2. We assume in the rest of this paper that the positive definite kernel functions are   \n172 bounded, i.e., ",
+        "bbox": [
+            137,
+            619,
+            830,
+            648
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/de1db98a88acbe5cfd32f88d7c9a70c9861c04c0b69a467eb7ccc490a7d142fd.jpg",
+        "text": "$$\n\\mathbb { E } _ { x } [ k _ { x } ( x , x ) ] < \\infty , \\quad \\mathbb { E } _ { s } [ k _ { s } ( s , s ) ] < \\infty , \\quad \\mathrm { a n d } \\quad \\mathbb { E } _ { y } [ k _ { y } ( y , y ) ] < \\infty .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            654,
+            715,
+            671
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "173 The assumptions in (6) guarantee that $h ( \\cdot , \\cdot )$ in (5) is bounded [40] and therefore, invoking Riesz   \n174 representation theorem [41], there exists a unique and bounded linear operator $\\Sigma _ { s x }$ , such that ",
+        "bbox": [
+            137,
+            684,
+            828,
+            713
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/38791cead28a6c7e846a31ac021dc5dc3cec38dfcfd1e3720d2fec828e408aa2.jpg",
+        "text": "$$\nh ( f , \\beta _ { s } ) = \\mathbb { C } \\mathsf { o v } _ { \\pmb { x } , s } ( f ( \\pmb { x } ) , \\beta _ { s } ( \\pmb { s } ) ) = \\langle \\beta _ { s } , \\Sigma _ { s \\pmb { x } } f \\rangle _ { \\mathscr { H } _ { s } } \\quad \\forall f \\in \\mathscr { H } _ { \\pmb { x } } , \\forall \\beta _ { s } \\in \\mathscr { H } _ { s } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            718,
+            728,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on 175 $h ( \\cdot , \\cdot )$ , we define the linear operator $h _ { f , s } : { \\mathcal { H } } _ { s } \\to { \\mathbb { R } } ^ { r }$ as ",
+        "bbox": [
+            143,
+            744,
+            606,
+            761
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4369d5d1bda99f37a113a73bade016bd476626ffbead3cf22e4e206cfbed455a.jpg",
+        "text": "$$\n\\begin{array} { r } { h _ { \\pmb { f } , \\mathscr { s } } ( \\beta _ { \\mathscr { s } } ) : = \\left[ \\begin{array} { c } { \\mathbb { C } \\mathrm { o v } _ { \\pmb { x } , \\mathscr { s } } ( f _ { 1 } ( \\pmb { x } ) , \\beta _ { \\mathscr { s } } ( \\pmb { s } ) ) } \\\\ { \\vdots } \\\\ { \\mathbb { C } \\mathrm { o v } _ { \\pmb { x } , \\mathscr { s } } ( f _ { r } ( \\pmb { x } ) , \\beta _ { \\mathscr { s } } ( \\pmb { s } ) ) } \\end{array} \\right] = \\left[ \\begin{array} { c } { \\langle \\beta _ { \\mathscr { s } } , \\sum _ { \\pmb { s } \\pmb { x } } f _ { 1 } \\rangle _ { \\mathscr { H } _ { s } } } \\\\ { \\vdots } \\\\ { \\langle \\beta _ { \\mathscr { s } } , \\sum _ { \\pmb { s } \\pmb { x } } f _ { r } \\rangle _ { \\mathscr { H } _ { s } } } \\end{array} \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            765,
+            684,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "176 The operator $h _ { f , s }$ captures all modes of non-linear dependence, since the distribution of a low  \n177 dimensional projection of high-dimensional data is approximately normal [42], [43]. In other words,   \n178 we assume that $\\bar { ( } f ( \\pmb { x } ) , \\beta _ { s } ( \\pmb { s } ) \\bar { ) }$ is an approximately Gaussian random vector.   \n179 Among the different dependence measures that have been defined through the covariance operator   \n180 we adopt the Hilbert-Schmidt Independence Criterion (HSIC) [37] which is defined as the Hilbert  \n181 Schmidt norm (HS-norm) of the covariance operator, ",
+        "bbox": [
+            142,
+            844,
+            825,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            135,
+            90,
+            828,
+            133
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/324f337b9fcba8a1fc7bb4bc26839bbe8653a587c52b8121ee5fbe778ac8d137.jpg",
+        "text": "$$\n\\mathrm { d e p } ( z , s ) : = \\| h _ { f , s } \\| _ { \\mathrm { H S } } ^ { 2 } = \\sum _ { \\beta _ { s } \\in \\mathcal { U } _ { s } } \\| h _ { f , s } ( \\beta _ { s } ) \\| _ { 2 } ^ { 2 } { = } \\sum _ { \\beta _ { s } \\in \\mathcal { U } _ { s } } \\sum _ { j = 1 } ^ { r } h ^ { 2 } ( f _ { j } , \\beta _ { s } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            140,
+            707,
+            184
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "182 where $\\mathcal { U } _ { s }$ is a countable orthonormal basis set for $\\mathcal { H } _ { s }$ . Note that, based on this definition, if the   \n183 distribution $( f ( \\pmb { x } ) , \\beta _ { s } ( \\pmb { s } ) )$ fails to be a normal distribution, we end up measuring mean dependency   \n184 of $z = f ( x )$ from $\\pmb { s }$ which is still much stronger than the linear dependency between $_ z$ and $\\pmb { s }$ [44].   \n185 Even under this assumption, empirically (Section 4) we observe that trade-offs we obtain significantly   \n186 dominate those from existing invariant representation learning algorithms. ",
+        "bbox": [
+            140,
+            189,
+            826,
+            260
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "187 The following Lemma introduces a well-defined population expression for $\\deg ( z , s )$ in (8). ",
+        "bbox": [
+            147,
+            265,
+            769,
+            280
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Lemma 2. ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            284,
+            246,
+            299
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4b98f2a38bbbcf52b4283e34b42f7f580085b832cbe224f03db0e90225c599d1.jpg",
+        "text": "$$\n\\begin{array} { r l r } { \\mathrm { d e p } ( z , s ) } & { = } & { \\displaystyle \\sum _ { j = 1 } ^ { r } \\Big \\lbrace \\mathbb { E } _ { \\alpha , s , \\alpha ^ { \\prime } , s ^ { \\prime } } \\Big [ f _ { j } ( \\alpha ) f _ { j } ( \\pmb { x } ^ { \\prime } ) k _ { s } ( s , s ^ { \\prime } ) \\Big ] + \\mathbb { E } _ { \\alpha } \\big [ f _ { j } ( \\pmb { x } ) \\big ] \\mathbb { E } _ { \\pmb { x } ^ { \\prime } } \\big [ f _ { j } ( \\pmb { x } ^ { \\prime } ) \\big ] \\mathbb { E } _ { s , s ^ { \\prime } } \\big [ k _ { s } ( s , s ^ { \\prime } ) \\big ] } \\\\ & { } & { - 2 \\mathbb { E } _ { \\alpha , s } \\Big [ f _ { j } ( \\pmb { x } ) \\mathbb { E } _ { \\pmb { x } ^ { \\prime } } \\big [ f _ { j } ( \\pmb { x } ^ { \\prime } ) \\big ] \\mathbb { E } _ { \\pmb { y } ^ { \\prime } } \\big [ k _ { s } ( s , s ^ { \\prime } ) \\big ] \\Big ] \\Big \\rbrace } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            301,
+            818,
+            375
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where 188 $( { \\pmb x } , { \\pmb s } )$ and $( { \\pmb x } ^ { \\prime } , s ^ { \\prime } )$ are independently drawn from the joint distribution $p _ { x s }$ . ",
+        "bbox": [
+            142,
+            378,
+            712,
+            395
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "89 In practice, it is necessary to empirically estimate $\\deg ( z , s )$ , since the population distributions are   \n90 typically unknown in most real-world scenarios.   \n191 Definition 3. Let $D = \\{ ( \\pmb { x } _ { 1 } , \\pmb { s } _ { 1 } , \\pmb { y } _ { 1 } ) , \\cdot \\cdot \\cdot , ( \\pmb { x } _ { n } , \\pmb { s } _ { n } , \\pmb { y } _ { n } ) \\}$ be the training data, containing $n$ i.i.d.   \n192 realizations from the joint distribution $p _ { x s y }$ . Using, the representer theorem [45], it follows that   \n193 $\\pmb { f } ( \\pmb { x } ) = \\Theta _ { E } { [ k _ { x } ( x _ { 1 } , \\pmb { x } ) , \\allowbreak \\cdot \\cdot \\cdot , k _ { x } ( x _ { n } , \\pmb { x } ) ] } ^ { T }$ , where $\\boldsymbol { \\Theta } \\in \\mathbb { R } ^ { r \\times n }$ is a free parameter matrix. ",
+        "bbox": [
+            151,
+            405,
+            823,
+            434
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            438,
+            826,
+            486
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "194 Lemma 3. Let an empirical estimation of covariance be ",
+        "bbox": [
+            140,
+            488,
+            545,
+            503
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c9a233ddd1af6d33873b84b8151053879317d27c86df66a407df22d2ac1cb49f.jpg",
+        "text": "$$\n\\mathbb { C } \\mathrm { o v } _ { \\boldsymbol { x } , s } ( f _ { j } ( \\boldsymbol { x } ) , \\beta _ { s } ( \\boldsymbol { s } ) ) \\approx \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } f _ { j } ( \\boldsymbol { x } _ { i } ) \\beta _ { s } ( \\boldsymbol { s } _ { i } ) - \\frac { 1 } { n ^ { 2 } } \\sum _ { i = 1 } ^ { n } \\sum _ { k = 1 } ^ { n } f _ { j } ( \\boldsymbol { x } _ { i } ) \\beta _ { s } ( \\boldsymbol { s } _ { k } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            510,
+            743,
+            551
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "195 Then, the empirical estimator of $\\deg ( z , s )$ is given by ",
+        "bbox": [
+            140,
+            559,
+            527,
+            574
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a96ad9e35425a14166e7e86792b46764db4cabce3df2b17114120882d12324e1.jpg",
+        "text": "$$\n\\mathrm { d e p } ^ { \\mathrm { e m p } } ( z , s ) \\quad : = \\quad \\frac { 1 } { n ^ { 2 } } \\big \\| \\Theta K _ { x } H L _ { s } \\big \\| _ { F } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            580,
+            630,
+            612
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "196 where $K _ { x } , K _ { s } \\in \\mathbb { R } ^ { n \\times n }$ are Gram matrices corresponding to $\\mathcal { H } _ { x }$ and $\\mathcal { H } _ { s }$ , respectively, ${ \\textbf { \\em H } } =$   \n197 $\\textstyle I - { \\frac { 1 } { n } } \\mathbf { 1 } \\mathbf { 1 } ^ { T }$ , and $\\mathbf { \\boldsymbol { L _ { s } } }$ is a full column-rank matrix in which $\\bar { \\pmb { L } } _ { s } \\pmb { L } _ { s } ^ { T } = \\pmb { K } _ { s }$ (Cholesky factorization).   \n198 This empirical estimator in (9) has a bias of $\\mathcal { O } ( n ^ { - 1 } )$ and a convergence rate of $\\mathcal { O } ( n ^ { - 1 / 2 } )$ . ",
+        "bbox": [
+            142,
+            617,
+            825,
+            665
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The population and empirical dependence measures between $_ z$ and $\\textbf {  { y } }$ i.e., $\\mathrm { d e p } ( z , y )$ and $\\mathrm { d e p } ^ { \\mathrm { e m p } } ( z , y )$ , respectively, can be defined and obtained similarly. ",
+        "bbox": [
+            168,
+            674,
+            825,
+            704
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 Trade-Off D ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            718,
+            299,
+            734
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "202 We now turn to the the optimization problem corresponding to the trade-off $\\mathbf { D }$ in (1). Recall that   \n203 $z = f ( x )$ is $r$ -dimensional, where the dimensionality $r$ is a free variable. A common desiderata of   \n204 learned representations is that of compactness [46] in order to avoid learning representations with   \n205 redundant information where different dimensions are highly correlated with each other. Therefore,   \n206 going beyond the assumption that each component of $f ( \\cdot )$ (i.e., $f _ { j } ( \\cdot ) ) ,$ ) belongs to a $L _ { 2 }$ −universal   \n207 RKHS $\\mathcal { H } _ { x }$ , we impose additional constraints on the representation. Specifically, we constrain the   \n208 search space of the encoder $f ( \\cdot )$ to learn a disentangled representation [46] as follows, ",
+        "bbox": [
+            140,
+            744,
+            826,
+            843
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fa3f63f71fca8ddc4c28e080aa6314e2de76526e0371a6b1e103ac322ecc52d2.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { A } _ { r } : = \\Big \\{ \\Big ( f _ { 1 } ( \\cdot ) , \\cdot \\cdot \\cdot , f _ { r } ( \\cdot ) \\Big ) \\Big | f _ { i } , f _ { j } \\in \\mathcal { H } _ { \\pmb { x } } , \\mathbb { C } \\mathrm { o v } _ { \\pmb { x } } ( f _ { i } ( \\pmb { x } ) , f _ { j } ( \\pmb { x } ) ) + \\gamma \\langle f _ { i } , f _ { j } \\rangle _ { \\mathcal { H } _ { \\pmb { x } } } = \\delta _ { i , j } \\Big \\} , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            848,
+            767,
+            877
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "209 where the regularization term $\\gamma \\langle f _ { i } , f _ { j } \\rangle _ { \\mathcal { H } _ { x } }$ , encourages orthogonality and boundedness, which in turn   \n210 forces the representation to be compact or non-redundant. Such disentangled representations have   \n211 been studied in the context of independent component analysis (ICA) [39]. Now, the optimization   \n212 problem in (1) reduces to, ",
+        "bbox": [
+            135,
+            882,
+            825,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            826,
+            119
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/debb7e21dbea877a95fe89a0338f6dc4c9d09fd147c95e39c92f7098bb6b648c.jpg",
+        "text": "$$\n\\operatorname* { s u p } _ { f \\in \\mathcal { A } _ { r } } \\Big \\{ J ( f ( x ) ) : = ( 1 - \\tau ) \\deg ( f ( x ) , y ) - \\tau \\deg ( f ( x ) , s ) \\Big \\} , \\quad 0 \\leq \\tau < 1 ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            121,
+            733,
+            151
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where as justified earlier the target loss function in213 f $_ { Y } \\mathbb { E } _ { { \\pmb x } , { \\pmb y } } [ { \\mathcal { L } } _ { Y } ( f _ { T } ( { \\pmb f } ( { \\pmb x } ) ) , { \\pmb y } ) ]$ is substituted by 214 $- \\mathrm { d e p } ( f ( \\pmb { x } ) , \\pmb { y } )$ . Fortunately, the above optimization problem lends itself to a closed-form solu215 tion as given by the next theorem. ",
+        "bbox": [
+            140,
+            155,
+            826,
+            207
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "216 Theorem 4. A solution5 to the optimization problem in (11) is the eigenfunctions corresponding to $r$   \n217 largest eigenvalues of the following generalized problem ",
+        "bbox": [
+            147,
+            208,
+            823,
+            237
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7b38713eeb35519a026428ac87ce276351eec34faaf808a48e4ee9f6991be267.jpg",
+        "text": "$$\n\\begin{array} { r } { \\left( ( 1 - \\tau ) \\Sigma _ { y x } ^ { * } \\Sigma _ { y x } - \\tau \\Sigma _ { s x } ^ { * } \\Sigma _ { s x } \\right) f = \\lambda \\Sigma _ { x x } f , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            238,
+            633,
+            265
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where 218 $\\Sigma _ { s x }$ and $\\Sigma _ { y x }$ are the covariance operators defined in (7), and $\\Sigma _ { s x } ^ { * }$ and $\\Sigma _ { y x } ^ { * }$ are the adjoint 19 operators of $\\Sigma _ { s x }$ and $\\Sigma _ { y x }$ , respectively. ",
+        "bbox": [
+            155,
+            266,
+            823,
+            295
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Remark. If the trade-off parameter $\\tau = 0$ (i.e., no semantic independence constraint is imposed), the solution in Theorem 4 resembles a supervised version of ICA in [39] which is essentially a kernelized dimensionality reduction supervised by the target attribute $\\textbf {  { y } }$ . On the other hand, if $\\tau  1$ (i.e., utility is ignored and only semantic independence is considered), the solution in Theorem 4 is the eigenfunctions corresponding to the negative eigenvalues of $\\Sigma _ { s x } ^ { * } \\Sigma _ { s x }$ , which are the directions that are least explanatory of the semantic attribute $\\pmb { s }$ . ",
+        "bbox": [
+            169,
+            296,
+            825,
+            380
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "226 An empirical version of (11) is the following optimization problem ",
+        "bbox": [
+            147,
+            387,
+            617,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/258982d04e2d26f118d620ab6c960b851c9f68e36a4118dfbe5f2a1713dce94c.jpg",
+        "text": "$$\n\\operatorname* { s u p } _ { f \\in { \\mathcal A } _ { r } } \\Big \\{ J ^ { \\mathrm { e m p } } ( f ( x ) ) : = ( 1 - \\tau ) { \\mathrm { d e p } } ^ { \\mathrm { e m p } } ( f ( x ) , y ) - \\tau { \\mathrm { d e p } } ^ { \\mathrm { e m p } } ( f ( x ) , s ) \\Big \\} , \\quad 0 \\leq \\tau < 1\n$$",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            405,
+            763,
+            435
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where de ${ \\mathfrak { p } } ^ { \\mathrm { e m p } } ( f ( { \\pmb x } ) , { \\pmb s } )$ and $\\log ^ { \\mathrm { e m p } } ( f ( x ) , y )$ are given in (9). ",
+        "bbox": [
+            158,
+            438,
+            576,
+            454
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "228 Theorem 5. Consider the Cholesky factorization $K _ { x } = L _ { x } L _ { x } ^ { T }$ , where $\\scriptstyle L _ { x }$ is a full column-rank   \n229 matrix. A solution to (13) is ",
+        "bbox": [
+            142,
+            457,
+            826,
+            486
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/91e7d582cbbb8bdb1a17db943d03b94df83f03a242a943efb48195328636206e.jpg",
+        "text": "$$\n\\pmb { f } ^ { \\mathrm { o p t } } = \\Theta ^ { \\mathrm { o p t } } \\Big [ k _ { x } ( x _ { 1 } , \\cdot ) , \\cdot \\cdot \\cdot , k _ { x } ( x _ { n } , \\cdot ) \\Big ] ^ { T }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            487,
+            616,
+            517
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where 230 $\\Theta ^ { \\mathrm { o p t } } = U ^ { T } ( L _ { x } ) ^ { \\dag }$ and the columns of $U$ are eigenvectors corresponding to $r$ largest eigenval231 ues, $\\lambda _ { 1 } , \\cdots , \\lambda _ { r }$ of the following generalized problem, ",
+        "bbox": [
+            151,
+            520,
+            823,
+            550
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/633d2294b3d3a820a86cf29105efb2a9bd3f7459405fbfbdafacc81e554c1b87.jpg",
+        "text": "$$\n\\Big ( L _ { x } ^ { T } \\big ( ( 1 - \\tau ) \\tilde { K } _ { y } - \\tau \\tilde { K } _ { s } \\big ) L _ { x } \\Big ) u = \\lambda \\Big ( L _ { x } ^ { T } H L _ { x } + n \\gamma I \\Big ) u\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            551,
+            678,
+            579
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where 32 $\\gamma$ is the regularization parameter from (10) and the supremum value of (13) is $\\textstyle \\sum _ { j = 1 } ^ { r } \\lambda _ { j }$ ",
+        "bbox": [
+            153,
+            580,
+            792,
+            595
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "233 Corollary 5.1. Embedding Dimensionality: A useful corollary of Theorem 5 is optimal embedding   \n234 dimensionality: ",
+        "bbox": [
+            147,
+            599,
+            825,
+            627
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5d591324fda08029f94448aaf3eb7048dcd6bd59db3f5213654ee80ec16f98d3.jpg",
+        "text": "$$\n\\arg \\operatorname* { s u p } _ { r } \\left\\{ \\operatorname* { s u p } _ { f \\in A _ { r } } \\Big \\{ J ^ { \\mathrm { e m p } } ( f ( x ) ) : = ( 1 - \\tau ) \\mathrm { d e p } ^ { \\mathrm { e m p } } ( f ( x ) , y ) - \\tau \\mathrm { d e p } ^ { \\mathrm { e m p } } ( f ( x ) , s ) \\Big \\} \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            205,
+            628,
+            759,
+            671
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "235 which is the number of positive eigenvalues of the generalized eigenvalue problem in (14). To   \n236 intuitively examine this result, consider two extreme cases: i) If there is no semantic independence   \n237 constraint (i.e., $\\tau = 0$ ), adding more dimensions to the optimum $r$ will not harm the representation   \n238 power of $_ z$ . ii) If we only care about semantic independence and ignore the target task (i.e., $\\tau  1$ ),   \n239 the optimal $r$ would be equal to zero, indicating that a null representation is the best for discarding all   \n240 semantic information. In this case, adding more dimension to $_ { z }$ will necessarily violate the semantic   \n241 independence constraint. More discussion can be found in the supplementary material.   \n242 In the following Theorem, we prove that the empirical solution converges to its population counterpart.   \n243 Theorem 6. Assume that $k _ { s } ( \\cdot , \\cdot )$ and $k _ { y } ( \\cdot , \\cdot )$ are bounded by one and $f _ { k } ^ { 2 } ( { \\pmb x } _ { i } )$ is bounded by $M$ for   \n244 any $k = 1 , \\ldots , r$ and $i = 1 , \\ldots , n$ for which $\\pmb { f } = ( f _ { 1 } , \\dots , f _ { r } ) \\in \\mathcal { A } _ { r }$ . For any $n > 1$ and $0 < \\delta < 1$   \n245 with probability at least $1 - \\delta$ , we have ",
+        "bbox": [
+            138,
+            671,
+            825,
+            770
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            776,
+            825,
+            837
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/db4f935e850689ae0cd4cf41c2887579c470b4b55a4009cc2cf686a36b9061ad.jpg",
+        "text": "$$\n\\Big | \\operatorname* { s u p } _ { f \\in A _ { r } } J ( f ( { \\pmb x } ) ) - \\operatorname* { s u p } _ { { \\pmb f } \\in A _ { r } } J ^ { \\mathrm { e m p } } ( { \\pmb f } ( { \\pmb x } ) ) \\Big | \\leq r M \\sqrt { \\frac { \\log ( 6 / \\delta ) } { a ^ { 2 } n } } + \\mathcal { O } \\left( \\frac { 1 } { n } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            838,
+            709,
+            876
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "246 where $0 . 2 2 \\leq a \\leq 1$ is a constant. ",
+        "bbox": [
+            142,
+            877,
+            400,
+            892
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5The term ’solution’ in any optimization problem in this paper refers to a global optima. ",
+        "bbox": [
+            191,
+            897,
+            712,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "248 We recall that label space trade-off arises when the representation $_ { z }$ is ideal and is free to be designed   \n249 optimally i.e., it does not necessarily depend on the input data $_ { \\textbf { \\em x } }$ or the encoder’s hypothesis class.   \n250 However, we assume that the representation $_ z$ is a direct effect of the target and sensitive variables $_ y$   \n251 and $\\pmb { s }$ ). Following [47], we use an additive noise model as ",
+        "bbox": [
+            140,
+            116,
+            825,
+            172
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/84b4a9fe6909fc0dfb48e8e7818ccda7ded2b6350242ee4f99a8a942c5fc6406.jpg",
+        "text": "$$\n\\pmb { z } = \\pmb { f } _ { L } ( \\pmb { y } , \\pmb { s } ) + \\pmb { e } , \\quad \\pmb { e } \\perp \\pmb { y } , \\pmb { e } \\perp \\pmb { s }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            176,
+            606,
+            194
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "252 where $\\pmb { f } _ { L } ( \\cdot , \\cdot ) \\ : \\ \\mathbb { R } ^ { d _ { y } } \\times \\mathbb { R } ^ { d _ { s } }  \\ \\mathbb { R } ^ { r }$ is a Borel-measurable function. Following Section 3.1,   \n253 we deploy $- \\mathrm { d e p } ( z , y )$ , defined similar to $\\deg ( z , s )$ in (8), as a proxy for the loss function   \n254 $\\operatorname* { i n f } _ { g _ { Y } \\in \\mathcal { H } _ { y } } \\mathbb { E } _ { { \\pmb x } , { \\pmb y } } [ \\mathcal { L } _ { T } ( g _ { T } ( { \\pmb z } ) , { \\pmb y } ) ]$ . Recall that, the desired optimization problem is given in (2). Instead   \n255 of directly optimizing over $z \\in L ^ { 2 }$ , we optimize over all Borel-measurable functions $f _ { L } ( \\cdot , \\cdot )$ by   \n256 ignoring $e$ since it is independent of both $\\textbf {  { y } }$ and $\\pmb { s }$ : ",
+        "bbox": [
+            142,
+            198,
+            826,
+            279
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/987403d30b1291add7bc3c0115699773929d30eaf9134c2fc2c558927e1c671b.jpg",
+        "text": "$$\n\\operatorname* { s u p } _ { \\pmb { f } _ { L } \\in A _ { r } ( \\pmb { y } , s ) } \\Big \\{ ( 1 - \\tau ) \\mathrm { d e p } ( \\pmb { f } _ { L } ( \\pmb { y } , s ) , \\pmb { y } ) - \\tau \\mathrm { d e p } ( \\pmb { f } _ { L } ( \\pmb { y } , s ) , \\pmb { s } ) \\Big \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            282,
+            687,
+            315
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\scriptstyle A _ { r } ( y , s )$ is defined similar to $\\mathcal { A } _ { r }$ in (10) by using $( y , s )$ instead of $_ { \\textbf { \\em x } }$ in the definition. Recall that $\\scriptstyle A _ { r } ( y , s )$ ensures that $_ { z }$ will not contain highly correlated (entangled) dimensions, and thus be minimally redundant or maximally compact. ",
+        "bbox": [
+            171,
+            319,
+            825,
+            362
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Remark. The optimization problem in (16) and its empirical counterpart can be solved similar to that of trade-off $\\mathbf { D }$ in Theorems 5 and 6 where $_ { \\textbf { \\em x } }$ is replaced with $( y , s )$ . ",
+        "bbox": [
+            163,
+            364,
+            825,
+            395
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.4 Trade-Off F ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            409,
+            297,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Here we define and discuss the trade-off achievable by practical realizations of representation learning algorithms with either fairness, invariance or semantic independence constraints. ",
+        "bbox": [
+            171,
+            434,
+            821,
+            463
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Definition 4. Feasible Space Trade-Off arises from the statistical dependence between the target feature $\\textbf {  { y } }$ and the sensitive attribute $\\pmb { s }$ conditioned on the given input data $_ { \\textbf { \\em x } }$ , the choice of hypothesis class for the learners involved, and the choice of dependence measure adopted. This setting can be formalized as, ",
+        "bbox": [
+            169,
+            465,
+            825,
+            522
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/90d781c93ac798c76db30b4a7f848f90ead774f1b0bb7a7a0e815e5b0f849d77.jpg",
+        "text": "$$\n\\operatorname* { i n f } _ { f \\in \\mathcal { H } _ { x } } \\Big \\{ ( 1 - \\tau ) \\operatorname* { i n f } _ { g _ { Y } \\in \\mathcal { H } _ { y } } \\mathbb { E } _ { \\mathbf { x } , y } \\Big [ \\mathcal { L } _ { Y } \\Big ( g _ { Y } \\big ( f ( x ) ) , y \\Big ) \\Big ] + \\tau \\widetilde { \\deg } ( f ( x ) , s ) \\Big \\} , \\quad 0 \\leq \\tau < 1 ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            207,
+            525,
+            756,
+            555
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "269 where $\\mathcal { H } _ { x }$ and $\\mathcal { H } _ { y }$ are the hypothesis class for the encoder network and target predictor, respectively,   \n270 $\\mathcal { L } _ { Y } ( \\cdot , \\cdot )$ denotes the loss function of target task, and $\\widetilde { \\mathrm { d e p } } ( f ( \\pmb { x } ) , s )$ is a parametric or non-parametric   \n271 surrogate measure of dependency quantifying the dependency between representation vector $z =$   \n272 $f ( { \\pmb x } )$ and the sensitive attribute $\\pmb { s }$ .   \n273 This setting corresponds to the trade-off $\\mathbf { F }$ in Figure 1(b), and is necessarily dominated by the   \n274 Data Space Trade-Off D. Multiple factors may lead to such sub-optimal trade-offs. These include,   \n275 hypothesis classes that are not universal RKHSs (e.g., [4] considered the case where $\\mathcal { H } _ { x }$ is universal,   \n276 but $\\mathcal { H } _ { s }$ and $\\mathcal { H } _ { y }$ are linear RKHSs), the surrogate dependence measure $\\widetilde { \\mathrm { d e p } } ( f ( \\pmb { x } ) , s )$ does not account   \n277 for all non-linear dependencies (e.g., [3, 2, 21, 4] which consider adversarially learned dependence   \n278 measures), sub-optimal optimization of (17) in terms of achieving only local optima but not the   \n279 global optima (e.g., when the hypothesis class is deep neural networks that are optimized through   \n280 stochastic gradient descent, or through stochastic gradient descent-ascent in the case of adversarial   \n281 representation learning[3, 21, 2]), and combinations thereof. ",
+        "bbox": [
+            140,
+            559,
+            825,
+            618
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            627,
+            826,
+            757
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "282 4 Numerical Estimation of Trade-Offs ",
+        "text_level": 1,
+        "bbox": [
+            151,
+            773,
+            508,
+            792
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "283 In this section, we demonstrate the practical utility of the analytical results developed in the paper   \n284 and validate our theoretical insights. For this purpose, we design an illustrative toy example that   \n285 conforms to the setting studied in the paper and numerically quantify the trade-offs that we introduced.   \n286 Experimental validation on more tasks can be found in the supplementary material. ",
+        "bbox": [
+            142,
+            805,
+            825,
+            862
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "287 Consider the following Gaussian mixture model from which we generate 4000, 2000, and 2000 ",
+        "bbox": [
+            143,
+            867,
+            799,
+            883
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3d57325ca1f11522ef0fa751e231b267870e0a8a6de342ba39b9d4b588522cd4.jpg",
+        "text": "$$\nv = [ v _ { 1 } , v _ { 2 } ] \\sim \\frac { 1 } { 2 } \\Big ( X ( m , \\Sigma ) + \\mathcal { N } ( m ^ { \\prime } , \\Sigma ) \\Big ) , \\quad m = [ 0 , 1 ] , m ^ { \\prime } = [ 1 , 1 ] , \\Sigma = \\mathrm { d i a g } ( 0 . 1 ^ { 2 } , 0 . 1 ^ { 2 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            169,
+            886,
+            800,
+            915
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/cb476a91659ba082677b8fbf209c2a8ac5d8549e7de8aa8c20de3ea4b19a3a9b.jpg",
+        "image_caption": [
+            "Figure 3: (a): A mixture of two Gaussians which generates the input data as ${ \\mathbf { \\boldsymbol { x } } } = \\boldsymbol { v } _ { 1 }$ , the sensitive attribute as $\\begin{array} { r } { \\pmb { s } = v _ { 1 } ^ { 3 } } \\end{array}$ , and the target attribute as $\\pmb { y } = [ \\widetilde { v } _ { 1 } , v _ { 2 } ^ { 3 } ]$ . (b): Two fundamental trade-offs, $\\mathbf { L }$ and $\\mathbf { D }$ , together with two baseline feasible trade-offs $\\mathbf { F }$ , ARL optimized with SGDA [21] and global optima of ARL with a linear RKHS [4]. (c), (d): The learned embedding for $\\tau = 0$ and $\\tau = 0 . 5$ , respectively. An invariant representation should collapse $v _ { 1 }$ i.e., the two colors should fully overlap with each other in the embedding. The overlap is partial for $\\tau = 0 . 5$ and as $\\tau  1$ , the optimal representation is zero. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            90,
+            821,
+            203
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "288 independent samples for training, validation and testing, respectively. Figure 3(a) shows the test   \n289 samples where the samples generated with $_ { m }$ and $m ^ { \\prime }$ are in blue and red, respectively. The input data   \n290 $_ { \\textbf { \\em x } }$ is set to $v _ { 1 }$ (the first entry of $\\textbf {  { v } }$ ), the sensitive attribute $\\pmb { s }$ is $v _ { 1 } ^ { 3 }$ , and the target attribute $\\textbf {  { y } }$ is $[ v _ { 1 } , v _ { 2 } ^ { 3 } ]$   \n291 In this problem both input data and target attribute are dependent on the sensitive attribute. We choose   \n292 all three RKHS $\\mathcal { H } _ { x }$ , $\\mathcal { H } _ { y }$ , and $\\mathcal { H } _ { s }$ to be Gaussian, which is a universal RKHS. The optimal $_ z$ is learned   \n293 for the trade-off $\\mathbf { D }$ through the closed-form solution in Theorem 5 for different invariance parameter   \n294 values $\\tau$ in $[ 0 , 1 )$ . Then, this optimal embedding is fed to a target task predictor which is a multi-layer   \n295 perceptron (MLP) with two hidden layers, and 4, 8 neurons and optimize the mean-squared error   \n296 (MSE). The $\\mathbf { X }$ -axis is a normalized version of the dependence measure used in our optimization, while   \n297 the y-axis quantifies utility normalized to $[ 0 , 1 ]$ as $\\exp ( - \\mathrm { \\mathbf { M } S E ) }$ . The same procedure is implemented   \n298 for trade-off $\\mathbf { L }$ , except that the input data is $\\textbf {  { v } }$ , instead of $_ { \\textbf { \\em x } }$ . These trade-offs are shown in Figure 3(b).   \n299 We choose the input data to be $\\textbf {  { v } }$ instead of $( y , s )$ for trade-off $\\mathbf { L }$ since $( y , s )$ is fully generated from   \n300 $\\textbf {  { v } }$ and therefore, $\\textbf {  { v } }$ perfectly explains $( y , s )$ . For $\\tau = 0$ and $\\tau = 0 . 5$ , the optimal embeddings are   \n301 illustrated in Figure 3, (c) and (d), respectively. Since the sensitive attribute is only related to $v _ { 1 }$ ,   \n302 an invariant embedding should collapse the corresponding dimension and cause the two colors to   \n303 overlap with each other.   \n304 We make the following observations, (a) Trade-off $\\mathbf { L }$ dominates trade-off $\\mathbf { D }$ as expected. (b) The   \n305 trade-offs $\\mathbf { F }$ obtained by the baselines are dominated by trade-off $\\mathbf { D }$ . Adversarial representation   \n306 learning [3, 21, 2] uses sub-optimal optimization (SGDA), while Spectral-ARL [4] uses a global   \n307 optimum solution but restricts the hypothesis class in (3) to linear RKHS. As such, the baselines are   \n308 unable to match the global optimal solution of (13), and (c) At $\\tau = 0 . 5$ the embedding does indeed   \n309 collapse $v _ { 1 }$ to an extent leading to partial overlap between the two mixtures. ",
+        "bbox": [
+            138,
+            311,
+            825,
+            532
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            539,
+            825,
+            622
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "310 5 Conclusions and Societal Impact ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            648,
+            478,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "311 This paper developed the theoretical underpinnings for identifying and determining the fundamental   \n312 trade-offs and limits of representation learning under competing objectives. These trade-offs included   \n313 i) label space trade-off which is solely induced by the statistical relation between target task and   \n314 semantic attribute; ii) data space trade-off which is due to the statistical dependence between the   \n315 input data and both target and semantic attributes. Further, we found closed-from solutions for the   \n316 global optima, both the population and empirical versions, for the underlying optimization problems,   \n317 and thus quantify the trade-offs exactly. Our results shed light on the regions of the trade-off that are   \n318 feasible or impossible to achieve by learning algorithms. Numerical results suggest that commonly   \n319 used adversarial representation learning based techniques are unable to reach the optimal trade-offs.   \n320 The theoretical results in this paper are useful for algorithmic fairness, privacy-preservation, and   \n321 domain generalization applications of representation learning. Such systems are being widely   \n322 deployed in a variety of practical applications: search engines, social media, law enforcement,   \n323 healthcare, consumer devices, financial and judicial risk assessments, face analysis, and many more.   \n324 Therefore, providing theoretical limits of performance is critically important for informed framing   \n325 of regulatory policies, deployment of such solutions, and gaining societal trust. As such, we do not   \n326 anticipate any adverse societal impacts from this work. ",
+        "bbox": [
+            140,
+            683,
+            825,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "[1] P. Roy and V. N. Boddeti, “Mitigating information leakage in image representations: A maximum entropy approach,” in IEEE Conference on Computer Vision and Pattern Recognition, 2019.   \n[2] D. Madras, E. Creager, T. Pitassi, and R. Zemel, “Learning adversarially fair and transferable representations,” arXiv preprint arXiv:1802.06309, 2018.   \n[3] Y. Ganin, E. Ustinova, H. Ajakan, P. Germain, H. Larochelle, F. Laviolette, M. Marchand, and V. Lempitsky, “Domain-adversarial training of neural networks,” The Journal of Machine Learning Research, vol. 17, no. 1, pp. 2096–2030, 2016.   \n[4] B. Sadeghi, R. Yu, and V. Boddeti, “On the global optima of kernelized adversarial representation learning,” in IEEE International Conference on Computer Vision, pp. 7971–7979, 2019.   \n[5] H. Zhao and G. J. Gordon, “Inherent tradeoffs in learning fair representations,” arXiv preprint arXiv:1906.08386, 2019.   \n[6] D. McNamara, C. S. Ong, and R. C. Williamson, “Costs and benefits of fair representation learning,” in AAAI/ACM Conference on AI, Ethics, and Society, pp. 263–270, 2019.   \n[7] S. Dutta, D. Wei, H. Yueksel, P.-Y. Chen, S. Liu, and K. Varshney, “Is there a trade-off between fairness and accuracy? a perspective using mismatched hypothesis testing,” in International Conference on Machine Learning, pp. 2803–2813, PMLR, 2020.   \n[8] H. Zhao, J. Chi, Y. Tian, and G. J. Gordon, “Trade-offs and guarantees of adversarial representation learning for information obfuscation,” arXiv preprint arXiv:1906.07902, 2019.   \n[9] N. Martinez, M. Bertran, and G. Sapiro, “Minimax pareto fairness: A multi objective perspective,” in International Conference on Machine Learning, pp. 6755–6764, PMLR, 2020.   \n[10] H. Zhao, C. Dan, B. Aragam, T. S. Jaakkola, G. J. Gordon, and P. Ravikumar, “Fundamental limits and tradeoffs in invariant representation learning,” arXiv preprint arXiv:2012.10713, 2020.   \n[11] Y. Ganin and V. Lempitsky, “Unsupervised domain adaptation by backpropagation,” in International Conference on Machine Learning, 2015.   \n[12] E. Tzeng, J. Hoffman, K. Saenko, and T. Darrell, “Adversarial discriminative domain adaptation,” in IEEE Conference on Computer Vision and Pattern Recognition, 2017.   \n[13] H. Zhao, S. Zhang, G. Wu, J. M. Moura, J. P. Costeira, and G. J. Gordon, “Adversarial multiple source domain adaptation,” Advances in Neural Information Processing Systems, vol. 31, pp. 8559–8570, 2018.   \n[14] C. Dwork, M. Hardt, T. Pitassi, O. Reingold, and R. Zemel, “Fairness through awareness,” in Innovations in Theoretical Computer Science Conference, pp. 214–226, 2012.   \n[15] S. Ruggieri, “Using t-closeness anonymity to control for non-discrimination.,” Trans. Data Priv., vol. 7, no. 2, pp. 99–129, 2014.   \n[16] M. Feldman, S. A. Friedler, J. Moeller, C. Scheidegger, and S. Venkatasubramanian, “Certifying and removing disparate impact,” in ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 259–268, 2015.   \n[17] F. Calmon, D. Wei, B. Vinzamuri, K. N. Ramamurthy, and K. R. Varshney, “Optimized preprocessing for discrimination prevention,” in Advances in Neural Information Processing Systems, pp. 3992–4001, 2017.   \n[18] R. Zemel, Y. Wu, K. Swersky, T. Pitassi, and C. Dwork, “Learning fair representations,” in International Conference on Machine Learning, pp. 325–333, 2013.   \n[19] H. Edwards and A. Storkey, “Censoring representations with an adversary,” arXiv preprint arXiv:1511.05897, 2015.   \n[20] A. Beutel, J. Chen, Z. Zhao, and E. H. Chi, “Data decisions and theoretical implications when adversarially learning fair representations,” arXiv preprint arXiv:1707.00075, 2017.   \n[21] Q. Xie, Z. Dai, Y. Du, E. Hovy, and G. Neubig, “Controllable invariance through adversarial feature learning,” in Advances in Neural Information Processing Systems, pp. 585–596, 2017.   \n[22] B. H. Zhang, B. Lemoine, and M. Mitchell, “Mitigating unwanted biases with adversarial learning,” in AAAI/ACM Conference on AI, Ethics, and Society, 2018.   \n[23] J. Song, P. Kalluri, A. Grover, S. Zhao, and S. Ermon, “Learning controllable fair representations,” in International Conference on Artificial Intelligence and Statistics (AISTATS), 2019.   \n[24] M. Bertran, N. Martinez, A. Papadaki, Q. Qiu, M. Rodrigues, G. Reeves, and G. Sapiro, “Adversarially learned representations for information obfuscation and inference,” in International Conference on Machine Learning, 2019.   \n[25] E. Creager, D. Madras, J.-H. Jacobsen, M. A. Weis, K. Swersky, T. Pitassi, and R. Zemel, “Flexibly fair representation learning by disentanglement,” in International Conference on Machine Learning (ICML), 2019.   \n[26] F. Locatello, G. Abbati, T. Rainforth, S. Bauer, B. Schölkopf, and O. Bachem, “On the fairness of disentangled representations,” in Advances in Neural Information Processing Systems, pp. 14611–14624, 2019.   \n[27] J. Mary, C. Calauzenes, and N. El Karoui, “Fairness-aware learning for continuous attributes and treatments,” in International Conference on Machine Learning, pp. 4382–4391, PMLR, 2019.   \n[28] J. Hamm, “Minimax filter: Learning to preserve privacy from inference attacks,” The Journal of Machine Learning Research, vol. 18, no. 1, pp. 4704–4734, 2017.   \n[29] M. Coavoux, S. Narayan, and S. B. Cohen, “Privacy-preserving neural representations of text,” arXiv preprint arXiv:1808.09408, 2018.   \n[30] T. Xiao, Y.-H. Tsai, K. Sohn, M. Chandraker, and M.-H. Yang, “Adversarial learning of privacy-preserving and task-oriented representations,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 34, pp. 12434–12441, 2020.   \n[31] M. Dusmanu, J. L. Schönberger, S. N. Sinha, and M. Pollefeys, “Privacy-preserving visual feature descriptors through adversarial affine subspace embedding,” in IEEE Conference on Computer Vision and Pattern Recognition, 2021.   \n[32] E. Adeli, Q. Zhao, A. Pfefferbaum, E. V. Sullivan, L. Fei-Fei, J. C. Niebles, and K. M. Pohl, “Representation learning with statistical independence to mitigate bias,” in IEEE/CVF Winter Conference on Applications of Computer Vision, pp. 2513–2523, 2021.   \n[33] V. Grari, O. E. Hajouji, S. Lamprier, and M. Detyniecki, “Learning unbiased representations via re’nyi minimization,” arXiv preprint arXiv:2009.03183, 2020.   \n[34] B. K. Sriperumbudur, K. Fukumizu, and G. R. Lanckriet, “Universality, characteristic kernels and rkhs embedding of measures.,” Journal of Machine Learning Research, vol. 12, no. 7, 2011.   \n[35] D. Greenfeld and U. Shalit, “Robust learning with the hilbert-schmidt independence criterion,” in International Conference on Machine Learning, pp. 3759–3768, PMLR, 2020.   \n[36] M. I. Belghazi, A. Baratin, S. Rajeshwar, S. Ozair, Y. Bengio, A. Courville, and D. Hjelm, “Mutual information neural estimation,” in International Conference on Machine Learning, pp. 531–540, PMLR, 2018.   \n[37] A. Gretton, O. Bousquet, A. Smola, and B. Schölkopf, “Measuring statistical dependence with hilbert-schmidt norms,” in International Conference on Algorithmic Learning Theory, pp. 63–77, Springer, 2005.   \n[38] A. Gretton, R. Herbrich, A. Smola, O. Bousquet, and B. Schölkopf, “Kernel methods for measuring independence,” Journal of Machine Learning Research, vol. 6, no. Dec, pp. 2075– 2129, 2005.   \n[39] F. R. Bach and M. I. Jordan, “Kernel independent component analysis,” Journal of Machine Learning Research, vol. 3, no. Jul, pp. 1–48, 2002.   \n[40] K. Fukumizu, F. R. Bach, and A. Gretton, “Statistical consistency of kernel canonical correlation analysis.,” Journal of Machine Learning Research, vol. 8, no. 2, 2007.   \n[41] E. Kreyszig, Introductory functional analysis with applications, vol. 1. wiley New York, 1978.   \n[42] P. Diaconis and D. Freedman, “Asymptotics of graphical projection pursuit,” The Annals of Statistics, pp. 793–815, 1984.   \n[43] P. Hall and K.-C. Li, “On almost linearity of low dimensional projections from high dimensional data,” The Annals of Statistics, pp. 867–889, 1993.   \n[44] A. Rényi, “On measures of dependence,” Acta Mathematica Academiae Scientiarum Hungarica, vol. 10, no. 3-4, pp. 441–451, 1959.   \n[45] J. Shawe-Taylor, N. Cristianini, et al., Kernel methods for pattern analysis. Cambridge university press, 2004.   \n[46] Y. Bengio, A. Courville, and P. Vincent, “Representation learning: A review and new perspectives,” IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 35, no. 8, pp. 1798–1828, 2013.   \n[47] J. M. Mooij, J. Peters, D. Janzing, J. Zscheischler, and B. Schölkopf, “Distinguishing cause from effect using observational data: methods and benchmarks,” The Journal of Machine Learning Research, vol. 17, no. 1, pp. 1103–1204, 2016. ",
+        "bbox": [
+            165,
+            104,
+            830,
+            916
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            161,
+            85,
+            828,
+            919
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            826,
+            281
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "440 Checklist ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            303,
+            254,
+            318
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            330,
+            339,
+            344
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] See Section 3.2 and Section 3.3. Particularly, see Theorem 4 and Theorem 5.   \n(b) Did you describe the limitations of your work? [Yes] See the discussion above equation (5) and below equation (8).   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A] See Section 5.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            349,
+            825,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            488,
+            493,
+            503
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] See Section 3.1. Particularly, see Assumption 1 and Assumption 2 and discussion above equation (5) and below equation (8).   \n(b) Did you include complete proofs of all theoretical results? [Yes] See supplementary material for the proofs of all Lemmas and Theorems. ",
+        "bbox": [
+            238,
+            507,
+            825,
+            580
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            585,
+            393,
+            601
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] See supplementary material.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 4 and supplementary material.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] Only one of the baseline methods, ARL, requires running multiple times with different random seeds. The error bar of ARL results is given in supplementary material.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [No] This paper is not about computational complexity and/or execution time. ",
+        "bbox": [
+            238,
+            606,
+            825,
+            780
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            210,
+            786,
+            823,
+            800
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] See supplementary material for the citation to the publicly available repository that we used.   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A] We are not using any new assets.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] ",
+        "bbox": [
+            238,
+            805,
+            825,
+            912
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            235,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            123,
+            707,
+            138
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            236,
+            142,
+            826,
+            232
+        ],
+        "page_idx": 12
+    }
+]