Add files using upload-large-folder tool

parse/train/5Dl1378QutR/5Dl1378QutR.md

@@ -0,0 +1,403 @@
+# Diversity Policy Gradient for Sample Efficient Quality-Diversity Optimization
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 A fascinating aspect of nature lies in its ability to produce a large and diverse   
+2 collection of organisms that are all high-performing in their niche. By contrast,   
+3 most AI algorithms focus on finding a single efficient solution to a given problem.   
+4 Aiming for diversity in addition to performance is a convenient way to deal with the   
+5 exploration-exploitation trade-off that plays a central role in learning. It also allows   
+6 for increased robustness when the returned collection contains several working   
+7 solutions to the considered problem, making it well-suited for real applications such   
+8 as robotics. Quality-Diversity (QD) methods are evolutionary algorithms designed   
+9 for this purpose. This paper proposes a novel algorithm, QD-PG, which combines   
+10 the strength of Policy Gradient algorithms and Quality Diversity approaches to   
+11 produce a collection of diverse and high-performing neural policies in continuous   
+12 control environments. The main contribution of this work is the introduction of a   
+13 Diversity Policy Gradient (DPG) that exploits information at the time-step level to   
+14 thrive policies towards more diversity in a sample-efficient manner. Specifically,   
+15 QD-PG selects neural controllers from a MAP-Elites grid and uses two gradient  
+16 based mutation operators to improve both quality and diversity, resulting in stable   
+17 population updates. Our results demonstrate that QD-PG generates collections of di  
+18 verse solutions that solve challenging exploration and control problems while being   
+19 two orders of magnitude more sample-efficient than its evolutionary competitors.
+
+# 20 1 Introduction
+
+21 Natural evolution has the fascinating ability to produce diverse organisms that are all well adapted to   
+22 their respective niche. Inspired by this ability to produce a tremendous diversity of living systems,   
+23 Quality-Diversity (QD) is a new family of optimization algorithms that aims at searching for a   
+24 collection of both diverse and high-performing solutions (Pugh et al., 2016; Cully & Demiris, 2017).   
+25 While classic optimization methods focus on finding a single efficient solution, QD optimization aims   
+26 to cover the range of possible solution types and to return the best solution for each type. This process   
+27 is sometimes referred to as “illumination" in opposition to optimization, as it reveals (or illuminates)   
+28 a search space of interest often called the behavior descriptor space (Mouret & Clune, 2015).   
+29 The principal advantage of QD approaches resides in their intrinsic capacity to deliver a large and   
+30 diverse set of working alternatives when a single solution fails (Cully et al., 2015). By producing a   
+31 collection of solutions instead of a unique one, QD algorithms allow to obtain different ways to solve   
+32 a single problem, leading to greater robustness, which can help to reduce the reality gap when applied   
+33 to robotics (Koos et al., 2012). Diversity seeking is the core component that allows QD algorithms to   
+34 generate large collections of diverse solutions. By encouraging the emergence of novel behaviors in   
+35 the population without focusing on performance alone, diversity seeking algorithms explore regions   
+36 of the behavior descriptor space that are unreachable for conventional algorithms (Doncieux et al.,   
+37 2019). Another benefit of QD is its ability to solve hard exploration problems where the reward signal   
+38 is sparse or deceptive, and on which standard optimization techniques are ineffective (Colas et al.,   
+39 2020). This ability can be interpreted as a direct consequence of the structured search for diversity in   
+40 the behavior descriptor space.   
+41 Quality-Diversity algorithms build on black-box optimization methods such as evolutionary algo  
+42 rithms to evolve a population of solutions (Cully & Demiris, 2017). Historically, they rely on random   
+43 mutations to explore small search spaces but struggle when facing higher-dimensional problems. As   
+44 a result, they often scale poorly to problems where neural networks with many parameters provide   
+45 state-of-the-art results (Colas et al., 2020).   
+46 Building large and efficient controllers that work with continuous actions has been a long-standing   
+47 goal in Artificial Intelligence and in particular in robotics. Deep reinforcement learning (RL), and   
+48 especially Policy Gradient (PG) methods have proven efficient at training such large controllers   
+49 (Schulman et al., 2017; Lillicrap et al., 2015; Fujimoto et al., 2018; Haarnoja et al., 2018). One of the   
+50 keys to this success lies in the fact that PG methods exploit the structure of the objective function   
+51 when the problem can be formalized as a Markov Decision Process (MDP), leading to substantial   
+52 gains in sample efficiency. Moreover, they also exploit the analytical structure of the controller when   
+53 known, which allows the sample complexity of these methods to be independent of parameter space   
+54 dimensionality (Vemula et al., 2019). In real-world applications, these gains turn out to be critical   
+55 when interacting with the environment is expensive. PG methods usually rely on simple exploration   
+56 mechanisms, like adding Gaussian noise (Fujimoto et al., 2018) or maximizing entropy (Haarnoja   
+57 et al., 2018) to explore the action space, which happens to be insufficient in hard exploration tasks   
+58 where the reward signal is sparse or deceptive (Colas et al., 2018; Nasiriany et al., 2019).   
+59 Successful attempts have been made to combine evolutionary methods and reinforcement learning   
+60 (Khadka et al., 2019; Khadka & Tumer, 2018; Pourchot & Sigaud, 2018; Shi et al., 2020). However,   
+61 all these techniques only focus on building high-performing solutions and do not explicitly encourage   
+62 diversity within the population. In this regard, they fail when confronted with hard exploration   
+63 problems. To address these problems, one needs to seek both high-performing solutions and diversity   
+64 within them.
+
+![](images/aac911aec790ff4d63477d00c31877af492e268d6cc3f1cc95ddcb90f190c436.jpg)  
+Figure 1: The agent robot is rewarded for running forward as fast as possible. Following the reward signal without further exploration leads the agent into the trap, which corresponds to a poor local minimum. QD-PG produces a collection of solutions that are diverse and high-performing, allowing to find several working alternatives to solve a deceptive control problem.
+
+# 65 Contributions
+
+66 In this work, we introduce the idea of a diversity policy gradient (DPG) that thrives solutions towards   
+67 more diversity. We show that the DPG can be used in combination with the standard policy gradient,   
+68 dubbed quality policy gradient (QPG), to produce high-performing and diverse solutions. Our   
+69 algorithm, called QD-PG, builds on MAP-Elites (Mouret & Clune, 2015), demonstrates remarkable   
+70 sample efficiency brought by off-policy PG methods, and produces collections of good solutions   
+71 in a single run (see Figure 1). We compare QD-PG to state-of-the-art RL algorithms and to several   
+72 evolutionary methods known as Evolution Strategies (ESs) augmented with a diversity objective,   
+73 namely the NS-ES family (Conti et al., 2018) and the ME-ES algorithm (Colas et al., 2020). We   
+74 show that QD-PG generates collections of robust solutions in hard exploration problems while RL   
+75 algorithms struggle to produce a single one, and that QD-PG is two orders of magnitude more sample   
+76 efficient than the best of its evolutionary competitors.
+
+# 77 2 Background
+
+# 78 Problem statement
+
+79 We consider an MDP $( S , { \mathcal { A } } , { \mathcal { R } } , { \mathcal { T } } , \gamma )$ where $s$ is the state space, $\mathcal { A }$ the action space, $\mathcal { R } : \mathcal { S } \times \mathcal { A }  \mathbb { R }$   
+80 the reward function, $\mathcal { T } : \mathcal { S } \times \mathcal { A }  \mathcal { S }$ the dynamics transition function and $\gamma$ a discount factor.   
+81 We assume that both $s$ and $\mathcal { A }$ are continuous and consider a controller, or policy, $\pi _ { \theta } : { \mathcal { S } }  A$   
+82 parameterized by $\theta \in \Theta$ , which is called a solution to the problem. We say that a solution $\theta$ is   
+83 highy-performing if the expectation over the sum of rewards is high when using $\pi _ { \theta }$ . The fitness of a   
+84 solution measures its performance $F : \Theta \to \mathbb { R }$ where $F ( \theta ) = \mathbb { E } _ { \pi _ { \theta } } \sum _ { t } \gamma ^ { t } r _ { t }$ .   
+85 To characterize the novelty of a solution w.r.t. $J$ other solutions, as in QD methods, we introduce a   
+86 behavior descriptor (BD) space $\boldsymbol { B }$ , a behavior descriptor extraction function $\xi : \Theta \to B$ , and define a   
+87 distance metric $| | . | | _ { B }$ over $\boldsymbol { B }$ . The novelty $n : \Theta \times \dot { \Theta } ^ { J }  \mathbb { R } ^ { + }$ of a solution $\theta$ w.r.t. a list of solutions   
+88 $( \theta _ { j } ) _ { j = 1 , \ldots , J }$ is defined as $\begin{array} { r } { n \left( \theta , ( \theta _ { j } ) _ { j = 1 , \dots , J } \right) = \sum _ { j } | | \xi ( \theta ) , \xi ( \theta _ { j } ) | | _ { \mathcal { B } } . } \end{array}$ . In other words, we quantify the   
+89 novelty of a solution w.r.t. a list of $J$ solutions as the sum of distances between its behavior descriptor   
+90 and the behavior descriptors of all solutions of the list. We also use the distance $| | . | | _ { B }$ to characterize   
+91 the diversity of a set of $K$ solutions $\{ \theta _ { k } \} _ { k = 1 , \dots , K }$ . We formally define diversity $d : \Theta ^ { K } \to \mathbb { R } ^ { + }$ as
+
+$$
+d \left( \{ \theta _ { k } \} _ { k = 1 , \ldots , K } \right) = \sum _ { i = 1 } ^ { K } \operatorname* { m i n } _ { k \neq i } | | { \xi } ( \theta _ { i } ) , { \xi } ( \theta _ { k } ) | | _ { \cal B } ,
+$$
+
+meaning that a set of solutions is diverse if the solutions are distant with respect to each other in the sense of $| | . | | _ { B }$ .
+
+# 94 The MAP-Elites algorithm
+
+95 MAP-Elites (Mouret & Clune, 2015) is a simple yet state-of-the-art QD algorithm that has been   
+96 successfully applied to a wide range of challenging problems such as robot damage recovery (Cully   
+97 et al., 2015), molecular robotic control (Cazenille et al., 2019) and game design (Alvarez et al., 2019).   
+98 In MAP-Elites, the behavior descriptor space $\boldsymbol { B }$ is discretized into a grid of cells, also called niches,   
+99 with the aim of filling each cell with a high-performing solution. The algorithm starts with an empty   
+100 grid and an initial random set of $K$ solutions that are evaluated and added to the grid by following   
+101 simple insertion rules. If the cell corresponding to the behavior descriptors of a solution is empty, then   
+102 the solution is added to this cell. If there is already a solution in the cell, the new solution replaces it   
+103 only if it has greater fitness. At each iteration, $P$ existing solutions are sampled uniformly from the   
+104 grid and randomly mutated to create $P$ new solutions. These new solutions are then evaluated and   
+105 added to the grid following the same insertion rules. This cycle is repeated until convergence or for a   
+106 given budget of iterations.   
+107 Though MAP-Elites is a compelling and efficient method, it suffers from a low sample efficiency   
+108 as it relies on random mutations. Recently, Colas et al. (2020) tackled this problem by updating   
+109 the solutions through an Evolution Strategy known as the Cross-Entropy method. Notably, they   
+110 showed that MAP-Elites could be scaled with their method to address complex MUJOCO control   
+111 environments at the cost of very large computational resources. In this study, we propose to harness   
+112 policy gradients (QPG and DPG) to build a more sample-efficient MAP-Elites approach.
+
+# 113 3 Key Principle: Diversity Policy Gradient
+
+114 Let us assume that we have a MAP-Elites grid containing $K$ solutions $( \theta _ { 1 } , \ldots , \theta _ { K } )$ . To increase   
+115 diversity in the grid using the DPG, we need to update one sampled solution $\theta$ from the grid using   
+116 gradient ascent. To do so, we aim to compute the gradient of the population diversity w.r.t. $\theta$ , where   
+117 diversity is defined in Equation (1). As the $K$ solutions are independent, order does not matter and   
+118 we can consider optimizing arbitrarily $\theta = \theta _ { 1 }$ . To compute the gradient of $d$ w.r.t. $\theta _ { 1 }$ , we need   
+119 to separate the terms that depend on $\theta _ { 1 }$ from the others. The terms that depend on $\theta _ { 1 }$ correspond   
+120 to the distance of $\theta _ { 1 }$ to its nearest neighbor, which we define as $\theta _ { 2 }$ , and to the distances of $\theta _ { 1 }$ to   
+121 122 $\begin{array} { r } { d ( \{ \theta _ { k } \} _ { k = 1 , \ldots , K } ) = \sum _ { j = 2 } ^ { J } | | \xi ( \theta _ { 1 } ) , \xi ( \theta _ { j } ) | | _ { \mathcal { B } } + M } \end{array}$ $\theta \mathrm { s }$ $\theta _ { 1 }$ can ar, where $\begin{array} { r } { M = \sum _ { i \notin \{ 1 , . . . , J \} } \underset { k \neq i } { \operatorname* { m i n } } | | \xi ( \theta _ { i } ) , \xi ( \theta _ { k } ) | | _ { B } . } \end{array}$ $J ^ { 1 }$ .   
+123 Only the first term of the sum depends on $\theta = \theta _ { 1 }$ . Furthermore, we observe that this term equals the   
+124 novelty of solution $\theta _ { 1 }$ w.r.t. the list $( \theta _ { j } ) _ { 2 \leq j \leq J }$ . Therefore, the gradient of diversity w.r.t. $\theta _ { 1 }$ is   
+125 $\nabla _ { \theta _ { 1 } } d \bigl ( \{ \theta _ { k } \} _ { k = 1 , \ldots , K } \bigr ) = \nabla _ { \theta _ { 1 } } n \bigl ( \theta _ { 1 } , \bigl ( \theta _ { j } \bigr ) _ { 2 \leq j \leq J } \bigr ) .$ . That is, we can increase the diversity of the population   
+126 by increasing the novelty of $\theta _ { 1 }$ w.r.t. the list $( \theta _ { j } ) _ { 2 \leq j \leq J } .$ . In practice, we replace this list by a list of   
+127 nearest neighbors of $\theta _ { 1 }$ , as this is easier to compute and the elements of $( \theta _ { j } ) _ { 2 \leq j \leq J }$ tend to be among   
+128 the nearest neighbors of $\theta _ { 1 }$ .   
+129 Under this form, the diversity gradient cannot benefit from the variance reduction methods in the RL   
+130 literature to efficiently compute policy gradients Sutton et al. (1999). To this end, we need to express   
+131 it as a gradient over the expectation of a sum of scalar quantities obtained by policy $\pi _ { \theta _ { 1 } }$ at each step   
+132 when interacting with the environment. Therefore, to build a DPG, we need information about the   
+133 novelty of a solution at the time step level. To do so, we introduce a novel space $\mathcal { D }$ , dubbed state   
+134 descriptor space and a state descriptor extraction function $\psi : { \mathcal { S } }  { \mathcal { D } }$ . We assume $\mathcal { D }$ and $\boldsymbol { B }$ have the   
+135 same dimension. Similarly to the novelty of a solution, we now define the novelty of a state $s$ w.r.t. $J$   
+136 other states $\left( s _ { j } \right) _ { j = 1 , \ldots , J }$ as $n : S \times S ^ { J } \to \mathbb { R }$ such that $\begin{array} { r } { n ( s , ( s _ { j } ) _ { j = 1 , \dots , J } ) = \sum _ { j = 1 } ^ { \tilde { J } } | | \psi ( s ) , \psi ( s _ { j } ) | | _ { \mathcal { D } } } \end{array}$   
+137 where $| | . | | _ { \mathcal { D } }$ is a distance metric over $\mathcal { D }$ .   
+138 Now, we need to link novelty defined at the time step level to novelty defined at the solution level. We   
+139 define the novelty of a state w.r.t. a set of solutions. We say that a state is novel w.r.t. some solutions   
+140 if the state is novel w.r.t. to the states visited by these solutions. More formally:
+
+$$
+n ( s , ( \theta _ { j } ) _ { j = 1 , \dots , J } ) = \sum _ { j = 1 } ^ { J } \mathbb { E } _ { \pi _ { \theta _ { j } } } \sum _ { t } | | \psi ( s ) , \psi ( s _ { t } ) | | _ { \mathcal { D } } .
+$$
+
+141 While we adopt this definition in this paper, one might as well consider other definitions where, for   
+142 instance, a state is compared to states that have been visited at the same time step during another   
+143 episode. In this context, if the following relation is satisfied:
+
+$$
+\mathbb { E } _ { \pi _ { \theta _ { 1 } } } \sum _ { t } n ( s _ { t } , ( \theta _ { j } ) _ { 2 \leq j \leq J } ) = n ( \theta _ { 1 } , ( \theta _ { j } ) _ { 2 \leq j \leq J } ) ,
+$$
+
+144 then we can compute the DPG of $d$ w.r.t. $\theta _ { 1 }$ as
+
+$$
+\nabla _ { \theta _ { 1 } } ^ { D P G } = \nabla _ { \theta _ { 1 } } \mathbb { E } _ { \pi _ { \theta _ { 1 } } } \sum _ { t } n ( s _ { t } , ( \theta _ { j } ) _ { 2 \leq j \leq J } ) .
+$$
+
+145 146 This expression corresponds to the classical policy gradient setting whecorresponding reward signal, here dubbed diversity reward, is computed as $r _ { t } ^ { D } = n ( s _ { t } , ( \theta _ { j } ) _ { \ 2 \leq j \leq J } )$ $\gamma = 1$ .   
+147 148 Therefore, this gradient can be comment reward by the diversity reward $r _ { t } ^ { D }$ d using any PG estimation technique replacing the environ-.   
+149 Equation (3) enforces a relation between $\boldsymbol { B }$ and $\mathcal { D }$ and between extraction functions $\psi$ and $\xi$ . In   
+150 practice, it may be hard to define the behavior descriptor and state descriptor of a solution that satisfy   
+151 this relation while being meaningful to the problem at hand and tractable. But a strict equality is not   
+152 necessary. It suffices that an increase on the left-hand side implies an increase on the right-hand side   
+153 so that we can still update $\theta _ { 1 }$ using (4). Furthermore, when this is not the case, the diversity gradient   
+154 update might not result in an increase of diversity in the behavior descriptor space, but in that case the   
+155 MAP-Elites insertion rule will remove the corresponding solution. We show in Section 6 that we can   
+156 define descriptors that do not satisfy the above relation all the time, but still give satisfactory results.
+
+A distinguishing feature of our approach is that we combine diversity seeking at the level of trajectories using behavior descriptors and diversity seeking in the state space using state descriptors. The former is used by MAP-Elites to select solutions from the grid and contributes structural bias towards diversity, whereas the latter is used during policy gradient steps in the RL part, see Figure 2b. We organize the literature review below according to this split between two types of diversity seeking mechanisms.
+
+# QD search in the solution space
+
+164 Simultaneously maximizing diversity and performance is the central goal of QD methods (Pugh   
+165 et al., 2016; Cully & Demiris, 2017). Among the various possible combinations offered by the   
+166 QD framework, Novelty Search with Local Competition (NSLC) (Lehman & Stanley, 2011b) and   
+167 MAP-Elites (Mouret & Clune, 2015) are the two most popular algorithms. NSLC builds on the Novelty   
+168 Search (NS) algorithm (Lehman & Stanley, 2011a) and maintains an unstructured archive of solutions   
+169 selected for their local performance while MAP-Elites uniformly samples individuals from a structured   
+170 grid that discretizes the BD space. Not clear in its current form. I suggest: "QD-PG uses the standard   
+171 grid of MAP-Elites. However, we also show in Appendix F that QD-PG can be used with alternative   
+172 archive structures.   
+173 With the objective of improving their data-efficiency, QD-ES algorithms that combine QD and ESs,   
+174 such as NSR-ES and NSRA-ES, have been applied to challenging continuous control environments in   
+175 Conti et al. (2018). But, as outlined in Colas et al. (2020), they suffer from poor sample efficiency   
+176 and the diversity and environment reward functions could be mixed in a more efficient way. In that   
+177 respect, the most closely related work w.r.t. ours is ME-ES (Colas et al., 2020). The ME-ES algorithm   
+178 also optimizes quality and diversity using MAP-Elites and two ES populations. Using these methods   
+179 was shown to be critically more efficient than population-based GA algorithms (Salimans et al., 2017),   
+180 but our results show that they are still less sample efficient than off-policy deep RL methods, as they   
+181 do not leverage the analytical computation of the policy gradient at the time step level. To the best   
+182 of our knowledge, no QD or ES algorithm use an explicit critic for both performance and diversity,   
+183 resulting in even higher data-efficiency.
+
+# QD search in the state or action spaces
+
+185 Seeking for diversity in the space of states or actions is generally framed into the RL framework. This   
+186 is the case of algorithms maintaining a population of RL agents for exploration without an explicit   
+187 diversity criterion (Jaderberg et al., 2017) or algorithms explicitly looking for diversity but in the   
+188 action space rather than in the state space like ARAC (Doan et al., 2019), P3S-TD3 (Jung et al., 2020)   
+189 and DvD (Parker-Holder et al., 2020).   
+190 An exception is Stanton & Clune (2016) who define a notion of intra-life novelty that is similar to   
+191 our state novelty defined in Section 3. However, their novelty relies on skills rather than states. Our   
+192 work is also related to algorithms using RL mechanisms to search for diversity only (Eysenbach et al.,   
+193 2018; Pong et al., 2019; Lee et al., 2019; Islam et al., 2019). These methods have proven useful in   
+194 sparse reward situations, but they are inherently limited when the reward signal can orient exploration,   
+195 as they ignore it. Other works sequentially combine diversity seeking and RL. The GEP-PG algorithm   
+196 Colas et al. (2018) combines a diversity seeking component, namely Goal Exploration Processes   
+197 (Forestier et al., 2017) and the DDPG deep RL algorithm (Lillicrap et al., 2015). This sequential   
+198 combination of exploration-then-exploitation is also present in GO-EXPLORE (Ecoffet et al., 2019).   
+199 Again, this approach is limited when the reward signal can help driving the exploration process to   
+200 efficient solutions. These sequential approaches first look for diversity in the behavior descriptor   
+201 space, then optimize performance in the state action space, whereas we do so simultaneously in the   
+202 behavior descriptor space and in the state space.
+
+To the best of our knowledge, QD-PG is the first algorithm optimizing both diversity and performance in the solution and in the state space, using a sample-efficient policy gradient computation method for the latter.
+
+# 5 Methods
+
+07 Our full algorithm is called QD-PG, its pseudo code is given in Appendix A and its architecture is   
+08 depicted in Figure 2. QD-PG is an iterative algorithm based on MAP-Elites that replaces random   
+209 mutations with policy gradient updates. As we consider a continuous action space and want to   
+210 improve sample efficiency by using an off-policy policy gradient method, we rely on the Twin   
+211 Delayed Deterministic Policy Gradient (TD3) algorithm (Fujimoto et al., 2018). See Appendix B for   
+212 a detailed description of TD3.
+
+![](images/c6cf0c77b8bf561d3c8c8a67cf66aa4bec121a2d1e41c96dfa94ada872ba1aa6.jpg)  
+Figure 2: (a): The RL part of QD-PG operates at the time step level while the QD part operates at the controller level, considering the MDP as a black box. (b) One QD-PG iteration consists of three phases: 1) A new population of solutions is sampled from the MAP-Elites grid. 2) These solutions are updated by an off-policy RL agent: half of the solutions are optimized for quality and the other half for diversity. The RL agent leverages one shared critic for each objective. 3) The newly obtained solutions are evaluated in the environment. Transitions are stored in a replay buffer while the updated solutions, their final scores and behavior descriptors are stored in the MAP-Elites grid.
+
+QD-PG maintains three permanent structures. In the QD part, a MAP-Elites grid stores the most novel and performing solutions. In the RL part, a replay buffer contains all transitions collected when evaluating solutions and an archive A stores all state descriptors obtained so far. QD-PG starts with an initial population of random solutions, evaluates them and inserts them into the MAP-Elites grid. At each iteration, solutions are sampled from the grid, copied, and updated. The updated solutions are then evaluated through one rollout in the environment and inserted into the grid according to insertion rules. Transitions collected during evaluation are stored in the replay buffer, and state descriptors are stored in the archive A. Note that these state descriptors are first filtered to avoid insertion in the archive of multiple state descriptors that are too close to each other.
+
+During the update step, half the population is updated with QPG ascent and the other half with DPG ascent. The choice of whether an agent is updated for quality or diversity is random, meaning that it can be updated for quality and later for diversity if selected again. To justify this design, we show in Section 6 that updating consecutively for quality and diversity outperforms updating based on joint criteria. Both gradients are computed from batches of transitions sampled from the replay buffer. The QPG is computed as usual from rewards whereas for DPG, we get fresh novelty rewards as
+
+$$
+r _ { t } ^ { D } = \sum _ { j = 1 } ^ { J } | | \psi ( s _ { t } ) , \psi ( s _ { j } ) | | _ { \mathcal { D } } ,
+$$
+
+228 where $\left( s _ { j } \right) _ { j = 1 , \ldots , J }$ are the $J$ nearest neighbors of state $s _ { t }$ in the archive A. Diversity rewards   
+229 must be recomputed at each update because A changes during training. Following Equation (2),   
+230 diversity rewards should be computed as the sum of the distances between the descriptor of $s _ { t }$ and   
+231 the descriptors of all the states visited by a list of $J$ solutions. In practice, we consider the $J$ nearest   
+232 neighbors of $s _ { t }$ . This choice simplifies the algorithm and is faster and works well in practice.   
+233 TD3 relies on a parameterized critic to reduce the variance of its policy gradient estimate. In QD-PG,   
+234 we maintain two parameterized critics $Q _ { w } ^ { D }$ and $Q _ { v } ^ { Q }$ , respectively dubbed diversity and quality critics,   
+235 every time a policy gradient is computed, QD-PG also updates the corresponding critic. In fact, as   
+236 in TD3, we use pairs of critics and target critics to fight the overestimation bias. We share the critic   
+237 parameters among the population as in Pourchot $\&$ Sigaud (2018). Reasons for doing so come from   
+238 the fact that diversity is not stationary, as it depends on the current population. If each agent had   
+239 its own diversity critic, since an agent may not be selected for a large number of generations before   
+240 being selected again, its critic would convey an outdated picture of the evolving diversity. We tried   
+241 this solution, and it failed. A side benefit of critic sharing is that both critics become accurate faster as   
+242 they combine experience from all agents. Additional details on QD-PG implementation are available   
+243 in Appendix C.
+
+# 244 6 Experiments
+
+In this section, we intend to answer the following matters: 1. Can QD-PG produce collections of diverse and high-performing neural policies and what are the advantages to do so? 2. Is QD-PG more sample efficient than its QD competitors? 3. To what extent are the considered benchmarks difficult for classical policy gradients methods? 4. What is the usefulness of the different components of QD-PG?
+
+# Environments
+
+We asses QD-PG capabilities in continuous control environments that exhibit high dimensional observation and action spaces as well as strong exploration difficulties. Two types of reward signals, dubbed sparse and deceptive, are known to be particularly difficult for classical RL methods. These rewards appear in many applications such as robotics or combinatorial optimization. Sparse rewards are obtained if a given condition is specified, leading to a majority of null rewards and to credit assignment difficulties. Deceptive rewards are dense signals, i.e., they are non-zero at each time step but can mislead the search process to some local optimum. In such problems, a good approach to the exploration-exploitation trade-off is essential. The agent should learn when to ignore the reward signal and explore to avoid local minima and when to follow it to increase its return. Deceptive environments constitute a natural choice to highlight QD efficiency to balance exploration and exploitation. In this study, we consider three OpenAI Gym environments based on the MUJOCO physics engine that all exhibit strong deceptive rewards (illustrated in Appendix 5). Such environments have been widely used in previous works (Parker-Holder et al., 2020; Colas et al., 2020; Frans et al., 2018; Shi et al., 2020) for their deceptive nature, a characteristic that is absent of more widespread continuous control environments like HALFCHEETAH-V2, HOPPER-V2 or still ANT-V2.
+
+In the POINT-MAZE environment, an agent represented as a green sphere must find the exit of the maze depicted in Figure 4a, represented as a red sphere. An observation contains the agent position at time $t$ , and an action corresponds to position increments along the $x$ and $y$ axes. The reward is expressed as the negative Euclidean distance between the center of gravity of the agent and the exit center. The trajectory length cannot exceed 200 steps.
+
+The ANT-MAZE environment is modified from OpenAI Gym ANT-V2 (Brockman et al., 2016) and also used in (Colas et al., 2020; Frans et al., 2018). In ANT-MAZE, a four-legged ant has to reach a goal zone located in the lower right part of the maze (colored in green in Figure 4b). Its initial position is sampled in a small circle located in the maze’s extreme bottom left. As in POINT-MAZE, the reward is expressed as the negative Euclidean distance between the ant and the center of the goal zone. Maze walls are organized so that following the gradient of the reward function drives the ant into a dead-end. In ANT-MAZE, the final performance is defined as the maximum reward received during an episode. The environment is considered solved when an agent obtains a score superior to $- 1 0$ , corresponding to reaching the goal zone. An episode consists of 3000 time steps, this horizon is three times larger than in usual MUJOCO environments, making this environment particularly challenging for RL based methods (Vemula et al., 2019).
+
+Finally, the ANT-TRAP environment also derives from ANT-V2 and is inspired from (Colas et al., 2020; Parker-Holder et al., 2020). In ANT-TRAP, the four-legged ant initially appears in front of a trap and must bypass it to run as fast as possible in the forward direction (see Figure 4c), as in ANT-V2, the reward is computed as the ant velocity on the x-axis. The trap consists of three walls forming a dead-end directly in front of the ant, leading to a strong deceptive reward. In this environment, the trajectory length cannot exceed 1000 steps. As opposed to POINT-MAZE and ANT-MAZE, where the objective is to reach the exit area, there is no unique way to solve ANT-TRAP and we expect a QD algorithm to generate various effective solutions as depicted in Figure 1.
+
+QD-PG is compared to three types of methods. First, to answer question 2, we compare QD-PG to a family of QD baselines, namely ME-ES, NSR-ES, and NSRA-ES (Colas et al., 2020). Appendix E.1 recaps the properties of all these methods. Second, to answer question 3, we compare QD-PG to a family of policy gradient baselines. Soft Actor Critic (SAC) (Haarnoja et al., 2018) and the Twin Delayed Deep Deterministic policy gradient (TD3) (Fujimoto et al., 2018) are continuous control algorithms achieving state-of-the-art results on MUJOCO benchmarks. Random Network Distillation (RND) (Burda et al., 2018) is a curiosity-driven RL agent (Schulman et al., 2017) which was shown to perform well in hard exploration settings. CEM-RL (Pourchot & Sigaud, 2018) mixes Cross-Entropy Methods (CEM) and RL to evolve a population of agents to maximize quality and obtains stateof-the-art results MUJOCO benchmarks. Finally, to answer question 4, we propose to investigate the following matters: Can we replace alternating quality and diversity updates by a single update that optimizes for the sum of both criteria? Are quality gradients updates alone enough to fill the MAP-Elites grid? Are diversity gradients updates alone enough to do so? Consequently, we consider the following ablations of QD-PG: QD-PG SUM computes a gradient to optimize the sum of the quality and diversity rewards, D-PG applies only diversity gradients to the solutions, and Q-PG applies only quality gradients, but both D-PG and Q-PG still use QD selection (see Appendix E.1).
+
+We compare QD-PG to its ablations and RL competitors in all environments and show results in Table 1a. Detailed results including graphic charts and coverage maps are given in Appendix E and more details about the evaluation procedure are given in Appendix E.1.
+
+# 7 Results
+
+# 1. Can QD-PG produce collections of neural policies and what are the advantages to do so?
+
+312 Table 1a presents QD-PG performances. In all environments, our algorithm manages to find working   
+313 solutions that avoid local minima and reach the overall objective. In addition to its exploration   
+314 capabilities, QD-PG generates collections of high performing solutions in a single run. During the   
+315 ANT-TRAP experiment, the final collection of solutions returned by QD-PG contained, among others,   
+316 5 solutions that were within a $10 \%$ performance margin from the best one. As illustrated in Figure 1,   
+317 these agents typically differ in their gaits and preferred trajectories to circumvent the trap.
+
+Generating a collection of diverse solutions comes with the benefit of having a repertoire of diverse solutions that can be used as alternatives when the MDP changes (Cully et al., 2015). We show that QD-PG is more robust than conventional policy gradient methods by changing the reward signal of the ANT-MAZE environment. We replace the original goal in the bottom right part of the maze (see Figure 3) with a new randomly located goal in the maze. Instead of running QD-PG to optimize for this new objective, we run a Bayesian optimization process to quickly find a good solution among the ones already stored in the grid. With a budget of only 20 solutions to be tested during the Bayesian optimization process, we are able to quickly recover a good solution for the new objective. We repeat this experiment 100 times, each time with a different random goal, and obtain an average performance of $- 1 0$ with a standard deviation of 9. In other words, 20 interaction episodes (corresponding to 60.000 time steps) suffice for the adaptation process to find a solution that performs well for the new objective without the need to re-train agents. More detailed results can be found in Appendix E.3. 2
+
+![](images/5dae693770ba1c498f1b1a8601153b56deb949b863f6dcdd179ab5d84b7a521d.jpg)  
+Figure 3: QD-PG produces a collection of diverse solutions. In ANT-MAZE, even after setting new randomly located goals, the MAP-Elites grid still contains solutions that are suited for the new objectives.
+
+# 2. Is it more sample efficient than its QD competitors?
+
+Table 1b compares QD-PG to Deep Neuroevolution algorithms with a diversity seeking component in terms of sample efficiency. QD-PG runs on 10 CPU cores for 2 days while its competitors used 1000 CPU cores for the same duration. Nonetheless, QD-PG matches the asymptotic performance of ME-ES using two orders of magnitude fewer samples, explaining the lower resource requirements.
+
+Table 1: Results for all environments. Final Perf. is the minimum distance to the goal in ANT-MAZE and the episode return in POINT-MAZE and ANT-TRAP. The Ratio to ours column compares the sample efficiency of a method to QD-PG.
+
+(a) Comparison to ablations and PG baselines.
+
+<table><tr><td></td><td colspan="3">Final Perf.(± std)</td></tr><tr><td>Algorithm</td><td>POINT-MAZE</td><td>ANT-MAZE</td><td>ANT-TRAP</td></tr><tr><td>QD-PG</td><td>-24(±0)</td><td>-7(±7)</td><td>1541(±86)</td></tr><tr><td>QD-PG SUM</td><td>-25(±1)</td><td>-5(±3)</td><td>1018(±6)</td></tr><tr><td>D-PG</td><td>-37(±3)</td><td>-2(±0)</td><td>1016(±8)</td></tr><tr><td>Q-PG</td><td>-128(±0)</td><td>-26(±0)</td><td>1175(±79)</td></tr><tr><td>CEM-RL</td><td>-312(±1)</td><td>-26(±0)</td><td>934(±22)</td></tr><tr><td>SAC</td><td>-127(±1)</td><td>-59(±1)</td><td>1049(±21)</td></tr><tr><td>TD3</td><td>-130(±2)</td><td>-26(±0)</td><td>1131(±7)</td></tr><tr><td>RND</td><td>-35(±10)</td><td>-27(±1)</td><td>978(±61)</td></tr></table>
+
+(b) Comparison to evolutionary competitors.   
+
+<table><tr><td></td><td colspan="3">ANT-MAZE</td></tr><tr><td>Algorithm</td><td>Final Perf.</td><td>Steps to goal</td><td>Ratio to ours</td></tr><tr><td>QD-PG</td><td>-7(±7)</td><td>1.15e8</td><td>1</td></tr><tr><td>CEM-RL</td><td>-26(±0)</td><td>8</td><td>8</td></tr><tr><td>ME-ES</td><td>-5(±1)</td><td>2.4e10</td><td>209</td></tr><tr><td>NSR-ES</td><td>-26(±0)</td><td>8</td><td>8</td></tr><tr><td>NSRA-ES</td><td>-2(±1)</td><td>2.1e10</td><td>182</td></tr></table>
+
+342 We see three reasons for the improved sample efficiency of QD-PG: 1) QD-PG leverages a replay   
+343 buffer and can re-use each sample several times. 2) QD-PG leverages novelty at the state level and   
+344 can exploit all collected transitions to maximize quality and diversity. For instance, in ANT-MAZE,   
+345 a trajectory brings 3000 samples to QD-PG while standard QD methods would consider it a unique   
+346 sample. 3) PG exploits the analytical gradient between the neural network weights and the resulting   
+347 policy action distribution and estimates only the impact of the distribution on the return. By contrast,   
+348 standard QD methods directly estimate the impact on the return of randomly modifying the weights.
+
+# 3. To what extent the considered benchmarks are difficult for policy gradients methods?
+
+Table 1a compares QD-PG to state-of-the-art policy gradient algorithms and validates that classical policy gradient methods fail to find optimal solutions in deceptive environments. TD3 quickly converges to local minima of performance resulting from being attracted in dead-ends by the deceptive gradients. While we may expect SAC to better explore due to entropy regularization, it also converges to that same local minima in ANT-TRAP and POINT-MAZE. Besides, despite its exploration mechanism based on CEM, CEM-RL also quickly converges to local optima in all benchmarks, confirming the need for a dedicated diversity seeking component. RND, which adds an exploration bonus used as an intrinsic reward (see Appendix G for more details), also demonstrates performances inferior to QD-PG in all environments but manages to solve POINT-MAZE. In ANT-MAZE and ANT-TRAP, as shown in Appendix G.2, RND extensively explores the BD space but fails to obtain high returns.
+
+# 4. What is the usefulness of the different components of QD-PG ?
+
+The ablation study in Table 1a shows that when maximising quality only, Q-PG fails due to the deceptive nature of the reward and when maximizing diversity only, D-PG sufficiently explores to solve the problem in both POINT-MAZE and ANT-MAZE but requires more steps and finds lowerperforming solutions. When optimizing simultaneously for quality and diversity, QD-PG SUM fails to learn in ANT-TRAP and manages to solve the task in ANT-MAZE but requires more samples than QD-PG. We hypothesize that quality and diversity rewards may give rise to conflicting gradients. For instance, at the beginning of training in ANT-TRAP, the quality reward drives the ant forward whereas the diversity reward drives it back to escape the trap and explore the environment. Therefore, both rewards cancel each other, preventing any learning. This study validates the usefulness of QD-PG components: 1) optimizing for diversity is required to overcome the deceptive nature of the reward; 2) adding quality optimization provides better asymptotic performance; 3) it is better to disentangle quality and diversity updates.
+
+# 8 Conclusion
+
+This paper is the first to introduce a diversity gradient to explore diversity both at the state and skill levels. Based on this component we proposed a novel algorithm, QD-PG, inspired from the Quality-Diversity literature, that produces collections of diverse and high-performing neural policies in a sample-efficient manner. We showed experimentally that QD-PG generates several solutions that achieve high returns in challenging exploration problems. Finally, we demonstrated that in a few interactions with the environment, QD-PG finds alternative solutions that still obtain good performance when the MDP changes.
+
+# References
+
+382 Alvarez, A., Dahlskog, S., Font, J., and Togelius, J. Empowering quality diversity in dungeon design with interactive constrained map-elites. In 2019 IEEE Conference on Games (CoG), pp. 1–8. IEEE, 2019.   
+385 Brockman, G., Cheung, V., Pettersson, L., Schneider, J., Schulman, J., Tang, J., and Zaremba, W. Openai gym. arXiv preprint arXiv:1606.01540, 2016.   
+87 Burda, Y., Edwards, H., Storkey, A., and Klimov, O. Exploration by random network distillation. arXiv preprint arXiv:1810.12894, 2018.   
+389 Cazenille, L., Bredeche, N., and Aubert-Kato, N. Exploring self-assembling behaviors in a swarm of bio-micro-robots using surrogate-assisted map-elites. arXiv preprint arXiv:1910.00230, 2019. Colas, C., Sigaud, O., and Oudeyer, P.-Y. GEP-PG: Decoupling exploration and exploitation in deep reinforcement learning algorithms. arXiv preprint arXiv:1802.05054, 2018. Colas, C., Madhavan, V., Huizinga, J., and Clune, J. Scaling map-elites to deep neuroevolution. In Proceedings of the 2020 Genetic and Evolutionary Computation Conference, pp. 67–75, 2020. Conti, E., Madhavan, V., Such, F. P., Lehman, J., Stanley, K., and Clune, J. Improving exploration in evolution strategies for deep reinforcement learning via a population of novelty-seeking agents. In Advances in neural information processing systems, pp. 5027–5038, 2018. Cully, A. and Demiris, Y. Quality and diversity optimization: A unifying modular framework. IEEE Transactions on Evolutionary Computation, 22(2):245–259, 2017.   
+00 Cully, A., Clune, J., Tarapore, D., and Mouret, J.-B. Robots that can adapt like animals. Nature, 521 (7553):503–507, 2015. Doan, T., Mazoure, B., Durand, A., Pineau, J., and Hjelm, R. D. Attraction-repulsion actor-critic for continuous control reinforcement learning. arXiv preprint arXiv:1909.07543, 2019.   
+04 Doncieux, S., Laflaquière, A., and Coninx, A. Novelty search: a theoretical perspective. In Proceedings of the Genetic and Evolutionary Computation Conference, pp. 99–106, 2019.   
+06 Ecoffet, A., Huizinga, J., Lehman, J., Stanley, K. O., and Clune, J. Go-explore: a new approach for hard-exploration problems. arXiv preprint arXiv:1901.10995, 2019. Eysenbach, B., Gupta, A., Ibarz, J., and Levine, S. Diversity is all you need: Learning skills without a reward function. arXiv preprint arXiv:1802.06070, 2018.   
+10 Forestier, S., Mollard, Y., and Oudeyer, P.-Y. Intrinsically motivated goal exploration processes with automatic curriculum learning. arXiv preprint arXiv:1708.02190, 2017.   
+412 Frans, K., Ho, J., Chen, X., Abbeel, P., and Schulman, J. Meta learning shared hierarchies. Proc. of ICLR, 2018.   
+414 Fujimoto, S., Van Hoof, H., and Meger, D. Addressing function approximation error in actor-critic methods. arXiv preprint arXiv:1802.09477, 2018.   
+16 Haarnoja, T., Zhou, A., Hartikainen, K., Tucker, G., Ha, S., Tan, J., Kumar, V., Zhu, H., Gupta, A., Abbeel, P., et al. Soft actor-critic algorithms and applications. arXiv preprint arXiv:1812.05905, 2018.   
+419 Islam, R., Ahmed, Z., and Precup, D. Marginalized state distribution entropy regularization in policy optimization. arXiv preprint arXiv:1912.05128, 2019. Jaderberg, M., Dalibard, V., Osindero, S., Czarnecki, W. M., Donahue, J., Razavi, A., Vinyals, O., Green, T., Dunning, I., Simonyan, K., et al. Population-based training of neural networks. arXiv preprint arXiv:1711.09846, 2017.   
+424 Jung, W., Park, G., and Sung, Y. Population-guided parallel policy search for reinforcement learning. In International Conference on Learning Representations, 2020.   
+426 Khadka, S. and Tumer, K. Evolution-guided policy gradient in reinforcement learning. In Neural Information Processing Systems, 2018.   
+428 Khadka, S., Majumdar, S., Miret, S., Tumer, E., Nassar, T., Dwiel, Z., Liu, Y., and Tumer, K. Collaborative evolutionary reinforcement learning. arXiv preprint arXiv:1905.00976, 2019. Koos, S., Mouret, J.-B., and Doncieux, S. The transferability approach: Crossing the reality gap in evolutionary robotics. IEEE Transactions on Evolutionary Computation, 17(1):122–145, 2012. Lee, L., Eysenbach, B., Parisotto, E., Xing, E., Levine, S., and Salakhutdinov, R. Efficient exploration via state marginal matching. arXiv preprint arXiv:1906.05274, 2019.   
+434 Lehman, J. and Stanley, K. O. Abandoning objectives: Evolution through the search for novelty alone. Evolutionary computation, 19(2):189–223, 2011a. Lehman, J. and Stanley, K. O. Evolving a diversity of virtual creatures through novelty search and local competition. In Proceedings of the 13th annual conference on Genetic and evolutionary computation, pp. 211–218, 2011b.   
+439 Lillicrap, T. P., Hunt, J. J., Pritzel, A., Heess, N., Erez, T., Tassa, Y., Silver, D., and Wierstra, D. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. Mouret, J.-B. and Clune, J. Illuminating search spaces by mapping elites. arXiv preprint arXiv:1504.04909, 2015. Nasiriany, S., Pong, V. H., Lin, S., and Levine, S. Planning with goal-conditioned policies. arXiv preprint arXiv:1911.08453, 2019. Parker-Holder, J., Pacchiano, A., Choromanski, K., and Roberts, S. Effective diversity in populationbased reinforcement learning. In Neural Information Processing Systems, 2020. Pong, V. H., Dalal, M., Lin, S., Nair, A., Bahl, S., and Levine, S. Skew-fit: State-covering selfsupervised reinforcement learning. arXiv preprint arXiv:1903.03698, 2019.   
+449 Pourchot, A. and Sigaud, O. Cem-rl: Combining evolutionary and gradient-based methods for policy search. arXiv preprint arXiv:1810.01222, 2018. Pugh, J. K., Soros, L. B., and Stanley, K. O. Quality diversity: A new frontier for evolutionary computation. Frontiers in Robotics and AI, 3:40, 2016. Salimans, T., Ho, J., Chen, X., Sidor, S., and Sutskever, I. Evolution strategies as a scalable alternative to reinforcement learning. arXiv preprint arXiv:1703.03864, 2017. Schulman, J., Moritz, P., Levine, S., Jordan, M., and Abbeel, P. High-dimensional continuous control using generalized advantage estimation. arXiv preprint arXiv:1506.02438, 2015. Schulman, J., Wolski, F., Dhariwal, P., Radford, A., and Klimov, O. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.   
+459 Shi, L., Li, S., Zheng, Q., Yao, M., and Pan, G. Efficient novelty search through deep reinforcement learning. IEEE Access, 8:128809–128818, 2020. Silver, D., Lever, G., Heess, N., Degris, T., Wierstra, D., and Riedmiller, M. Deterministic policy gradient algorithms. In Proceedings of the 30th International Conference in Machine Learning, 2014. Stanton, C. and Clune, J. Curiosity search: producing generalists by encouraging individuals to continually explore and acquire skills throughout their lifetime. PloS one, 11(9):e0162235, 2016. Sutton, R. S., McAllester, D. A., Singh, S. P., Mansour, Y., et al. Policy gradient methods for reinforcement learning with function approximation. In NIPs, volume 99, pp. 1057–1063. Citeseer, 1999.   
+469 Vemula, A., Sun, W., and Bagnell, J. Contrasting exploration in parameter and action space: A zerothorder optimization perspective. In The 22nd International Conference on Artificial Intelligence and Statistics, pp. 2926–2935. PMLR, 2019.
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [No] We believe that this work, in itself, is not prone to have any negative societal impact.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(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] The code and instructions to run it are available in the supplementary materials.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] Implementation details, hardware details and hyperparameters are presented in Appendix C.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] Yes, we report mean and variance for all experiments, both graphically and in result tables.   
+(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)? [Yes] Computational details are provided in Appedix C.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] We use open sourced RL environments.   
+(b) Did you mention the license of the assets? [Yes] We cite the Mujoco physics engine, for which we have licenses.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We provide appendices, source code and a demonstration website.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A] We did not used crowdsourcing or conducted research with human subjects.   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A] This work did not involve research with human subjects   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] This work did not involve research with human subjects

parse/train/5Dl1378QutR/5Dl1378QutR_content_list.json

@@ -0,0 +1,1108 @@
+[
+    {
+        "type": "text",
+        "text": "Diversity Policy Gradient for Sample Efficient Quality-Diversity Optimization ",
+        "text_level": 1,
+        "bbox": [
+            222,
+            122,
+            777,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            578,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 A fascinating aspect of nature lies in its ability to produce a large and diverse   \n2 collection of organisms that are all high-performing in their niche. By contrast,   \n3 most AI algorithms focus on finding a single efficient solution to a given problem.   \n4 Aiming for diversity in addition to performance is a convenient way to deal with the   \n5 exploration-exploitation trade-off that plays a central role in learning. It also allows   \n6 for increased robustness when the returned collection contains several working   \n7 solutions to the considered problem, making it well-suited for real applications such   \n8 as robotics. Quality-Diversity (QD) methods are evolutionary algorithms designed   \n9 for this purpose. This paper proposes a novel algorithm, QD-PG, which combines   \n10 the strength of Policy Gradient algorithms and Quality Diversity approaches to   \n11 produce a collection of diverse and high-performing neural policies in continuous   \n12 control environments. The main contribution of this work is the introduction of a   \n13 Diversity Policy Gradient (DPG) that exploits information at the time-step level to   \n14 thrive policies towards more diversity in a sample-efficient manner. Specifically,   \n15 QD-PG selects neural controllers from a MAP-Elites grid and uses two gradient  \n16 based mutation operators to improve both quality and diversity, resulting in stable   \n17 population updates. Our results demonstrate that QD-PG generates collections of di  \n18 verse solutions that solve challenging exploration and control problems while being   \n19 two orders of magnitude more sample-efficient than its evolutionary competitors. ",
+        "bbox": [
+            148,
+            349,
+            766,
+            612
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "20 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            640,
+            312,
+            656
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "21 Natural evolution has the fascinating ability to produce diverse organisms that are all well adapted to   \n22 their respective niche. Inspired by this ability to produce a tremendous diversity of living systems,   \n23 Quality-Diversity (QD) is a new family of optimization algorithms that aims at searching for a   \n24 collection of both diverse and high-performing solutions (Pugh et al., 2016; Cully & Demiris, 2017).   \n25 While classic optimization methods focus on finding a single efficient solution, QD optimization aims   \n26 to cover the range of possible solution types and to return the best solution for each type. This process   \n27 is sometimes referred to as “illumination\" in opposition to optimization, as it reveals (or illuminates)   \n28 a search space of interest often called the behavior descriptor space (Mouret & Clune, 2015).   \n29 The principal advantage of QD approaches resides in their intrinsic capacity to deliver a large and   \n30 diverse set of working alternatives when a single solution fails (Cully et al., 2015). By producing a   \n31 collection of solutions instead of a unique one, QD algorithms allow to obtain different ways to solve   \n32 a single problem, leading to greater robustness, which can help to reduce the reality gap when applied   \n33 to robotics (Koos et al., 2012). Diversity seeking is the core component that allows QD algorithms to   \n34 generate large collections of diverse solutions. By encouraging the emergence of novel behaviors in   \n35 the population without focusing on performance alone, diversity seeking algorithms explore regions   \n36 of the behavior descriptor space that are unreachable for conventional algorithms (Doncieux et al.,   \n37 2019). Another benefit of QD is its ability to solve hard exploration problems where the reward signal   \n38 is sparse or deceptive, and on which standard optimization techniques are ineffective (Colas et al.,   \n39 2020). This ability can be interpreted as a direct consequence of the structured search for diversity in   \n40 the behavior descriptor space.   \n41 Quality-Diversity algorithms build on black-box optimization methods such as evolutionary algo  \n42 rithms to evolve a population of solutions (Cully & Demiris, 2017). Historically, they rely on random   \n43 mutations to explore small search spaces but struggle when facing higher-dimensional problems. As   \n44 a result, they often scale poorly to problems where neural networks with many parameters provide   \n45 state-of-the-art results (Colas et al., 2020).   \n46 Building large and efficient controllers that work with continuous actions has been a long-standing   \n47 goal in Artificial Intelligence and in particular in robotics. Deep reinforcement learning (RL), and   \n48 especially Policy Gradient (PG) methods have proven efficient at training such large controllers   \n49 (Schulman et al., 2017; Lillicrap et al., 2015; Fujimoto et al., 2018; Haarnoja et al., 2018). One of the   \n50 keys to this success lies in the fact that PG methods exploit the structure of the objective function   \n51 when the problem can be formalized as a Markov Decision Process (MDP), leading to substantial   \n52 gains in sample efficiency. Moreover, they also exploit the analytical structure of the controller when   \n53 known, which allows the sample complexity of these methods to be independent of parameter space   \n54 dimensionality (Vemula et al., 2019). In real-world applications, these gains turn out to be critical   \n55 when interacting with the environment is expensive. PG methods usually rely on simple exploration   \n56 mechanisms, like adding Gaussian noise (Fujimoto et al., 2018) or maximizing entropy (Haarnoja   \n57 et al., 2018) to explore the action space, which happens to be insufficient in hard exploration tasks   \n58 where the reward signal is sparse or deceptive (Colas et al., 2018; Nasiriany et al., 2019).   \n59 Successful attempts have been made to combine evolutionary methods and reinforcement learning   \n60 (Khadka et al., 2019; Khadka & Tumer, 2018; Pourchot & Sigaud, 2018; Shi et al., 2020). However,   \n61 all these techniques only focus on building high-performing solutions and do not explicitly encourage   \n62 diversity within the population. In this regard, they fail when confronted with hard exploration   \n63 problems. To address these problems, one needs to seek both high-performing solutions and diversity   \n64 within them. ",
+        "bbox": [
+            147,
+            671,
+            825,
+            782
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            789,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/aac911aec790ff4d63477d00c31877af492e268d6cc3f1cc95ddcb90f190c436.jpg",
+        "image_caption": [
+            "Figure 1: The agent robot is rewarded for running forward as fast as possible. Following the reward signal without further exploration leads the agent into the trap, which corresponds to a poor local minimum. QD-PG produces a collection of solutions that are diverse and high-performing, allowing to find several working alternatives to solve a deceptive control problem. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            89,
+            818,
+            277
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            380,
+            825,
+            435
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            443,
+            825,
+            511
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            518,
+            825,
+            698
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            704,
+            825,
+            786
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "65 Contributions ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            794,
+            274,
+            808
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "66 In this work, we introduce the idea of a diversity policy gradient (DPG) that thrives solutions towards   \n67 more diversity. We show that the DPG can be used in combination with the standard policy gradient,   \n68 dubbed quality policy gradient (QPG), to produce high-performing and diverse solutions. Our   \n69 algorithm, called QD-PG, builds on MAP-Elites (Mouret & Clune, 2015), demonstrates remarkable   \n70 sample efficiency brought by off-policy PG methods, and produces collections of good solutions   \n71 in a single run (see Figure 1). We compare QD-PG to state-of-the-art RL algorithms and to several   \n72 evolutionary methods known as Evolution Strategies (ESs) augmented with a diversity objective,   \n73 namely the NS-ES family (Conti et al., 2018) and the ME-ES algorithm (Colas et al., 2020). We   \n74 show that QD-PG generates collections of robust solutions in hard exploration problems while RL   \n75 algorithms struggle to produce a single one, and that QD-PG is two orders of magnitude more sample   \n76 efficient than the best of its evolutionary competitors. ",
+        "bbox": [
+            150,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "77 2 Background ",
+        "text_level": 1,
+        "bbox": [
+            155,
+            165,
+            308,
+            183
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "78 Problem statement ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            196,
+            308,
+            210
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "79 We consider an MDP $( S , { \\mathcal { A } } , { \\mathcal { R } } , { \\mathcal { T } } , \\gamma )$ where $s$ is the state space, $\\mathcal { A }$ the action space, $\\mathcal { R } : \\mathcal { S } \\times \\mathcal { A }  \\mathbb { R }$   \n80 the reward function, $\\mathcal { T } : \\mathcal { S } \\times \\mathcal { A }  \\mathcal { S }$ the dynamics transition function and $\\gamma$ a discount factor.   \n81 We assume that both $s$ and $\\mathcal { A }$ are continuous and consider a controller, or policy, $\\pi _ { \\theta } : { \\mathcal { S } }  A$   \n82 parameterized by $\\theta \\in \\Theta$ , which is called a solution to the problem. We say that a solution $\\theta$ is   \n83 highy-performing if the expectation over the sum of rewards is high when using $\\pi _ { \\theta }$ . The fitness of a   \n84 solution measures its performance $F : \\Theta \\to \\mathbb { R }$ where $F ( \\theta ) = \\mathbb { E } _ { \\pi _ { \\theta } } \\sum _ { t } \\gamma ^ { t } r _ { t }$ .   \n85 To characterize the novelty of a solution w.r.t. $J$ other solutions, as in QD methods, we introduce a   \n86 behavior descriptor (BD) space $\\boldsymbol { B }$ , a behavior descriptor extraction function $\\xi : \\Theta \\to B$ , and define a   \n87 distance metric $| | . | | _ { B }$ over $\\boldsymbol { B }$ . The novelty $n : \\Theta \\times \\dot { \\Theta } ^ { J }  \\mathbb { R } ^ { + }$ of a solution $\\theta$ w.r.t. a list of solutions   \n88 $( \\theta _ { j } ) _ { j = 1 , \\ldots , J }$ is defined as $\\begin{array} { r } { n \\left( \\theta , ( \\theta _ { j } ) _ { j = 1 , \\dots , J } \\right) = \\sum _ { j } | | \\xi ( \\theta ) , \\xi ( \\theta _ { j } ) | | _ { \\mathcal { B } } . } \\end{array}$ . In other words, we quantify the   \n89 novelty of a solution w.r.t. a list of $J$ solutions as the sum of distances between its behavior descriptor   \n90 and the behavior descriptors of all solutions of the list. We also use the distance $| | . | | _ { B }$ to characterize   \n91 the diversity of a set of $K$ solutions $\\{ \\theta _ { k } \\} _ { k = 1 , \\dots , K }$ . We formally define diversity $d : \\Theta ^ { K } \\to \\mathbb { R } ^ { + }$ as ",
+        "bbox": [
+            147,
+            217,
+            826,
+            309
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            314,
+            825,
+            422
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4f8fb85de52e18f45a1cc3a62d4fd128be19d1368ece553d91c6eae548ffc4b4.jpg",
+        "text": "$$\nd \\left( \\{ \\theta _ { k } \\} _ { k = 1 , \\ldots , K } \\right) = \\sum _ { i = 1 } ^ { K } \\operatorname* { m i n } _ { k \\neq i } | | { \\xi } ( \\theta _ { i } ) , { \\xi } ( \\theta _ { k } ) | | _ { \\cal B } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            438,
+            650,
+            481
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "meaning that a set of solutions is diverse if the solutions are distant with respect to each other in the sense of $| | . | | _ { B }$ . ",
+        "bbox": [
+            161,
+            481,
+            821,
+            511
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "94 The MAP-Elites algorithm ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            525,
+            362,
+            540
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "95 MAP-Elites (Mouret & Clune, 2015) is a simple yet state-of-the-art QD algorithm that has been   \n96 successfully applied to a wide range of challenging problems such as robot damage recovery (Cully   \n97 et al., 2015), molecular robotic control (Cazenille et al., 2019) and game design (Alvarez et al., 2019).   \n98 In MAP-Elites, the behavior descriptor space $\\boldsymbol { B }$ is discretized into a grid of cells, also called niches,   \n99 with the aim of filling each cell with a high-performing solution. The algorithm starts with an empty   \n100 grid and an initial random set of $K$ solutions that are evaluated and added to the grid by following   \n101 simple insertion rules. If the cell corresponding to the behavior descriptors of a solution is empty, then   \n102 the solution is added to this cell. If there is already a solution in the cell, the new solution replaces it   \n103 only if it has greater fitness. At each iteration, $P$ existing solutions are sampled uniformly from the   \n104 grid and randomly mutated to create $P$ new solutions. These new solutions are then evaluated and   \n105 added to the grid following the same insertion rules. This cycle is repeated until convergence or for a   \n106 given budget of iterations.   \n107 Though MAP-Elites is a compelling and efficient method, it suffers from a low sample efficiency   \n108 as it relies on random mutations. Recently, Colas et al. (2020) tackled this problem by updating   \n109 the solutions through an Evolution Strategy known as the Cross-Entropy method. Notably, they   \n110 showed that MAP-Elites could be scaled with their method to address complex MUJOCO control   \n111 environments at the cost of very large computational resources. In this study, we propose to harness   \n112 policy gradients (QPG and DPG) to build a more sample-efficient MAP-Elites approach. ",
+        "bbox": [
+            142,
+            549,
+            826,
+            717
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            722,
+            825,
+            806
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "113 3 Key Principle: Diversity Policy Gradient ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            824,
+            545,
+            843
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "114 Let us assume that we have a MAP-Elites grid containing $K$ solutions $( \\theta _ { 1 } , \\ldots , \\theta _ { K } )$ . To increase   \n115 diversity in the grid using the DPG, we need to update one sampled solution $\\theta$ from the grid using   \n116 gradient ascent. To do so, we aim to compute the gradient of the population diversity w.r.t. $\\theta$ , where   \n117 diversity is defined in Equation (1). As the $K$ solutions are independent, order does not matter and   \n118 we can consider optimizing arbitrarily $\\theta = \\theta _ { 1 }$ . To compute the gradient of $d$ w.r.t. $\\theta _ { 1 }$ , we need   \n119 to separate the terms that depend on $\\theta _ { 1 }$ from the others. The terms that depend on $\\theta _ { 1 }$ correspond   \n120 to the distance of $\\theta _ { 1 }$ to its nearest neighbor, which we define as $\\theta _ { 2 }$ , and to the distances of $\\theta _ { 1 }$ to   \n121 122 $\\begin{array} { r } { d ( \\{ \\theta _ { k } \\} _ { k = 1 , \\ldots , K } ) = \\sum _ { j = 2 } ^ { J } | | \\xi ( \\theta _ { 1 } ) , \\xi ( \\theta _ { j } ) | | _ { \\mathcal { B } } + M } \\end{array}$ $\\theta \\mathrm { s }$ $\\theta _ { 1 }$ can ar, where $\\begin{array} { r } { M = \\sum _ { i \\notin \\{ 1 , . . . , J \\} } \\underset { k \\neq i } { \\operatorname* { m i n } } | | \\xi ( \\theta _ { i } ) , \\xi ( \\theta _ { k } ) | | _ { B } . } \\end{array}$ $J ^ { 1 }$ .   \n123 Only the first term of the sum depends on $\\theta = \\theta _ { 1 }$ . Furthermore, we observe that this term equals the   \n124 novelty of solution $\\theta _ { 1 }$ w.r.t. the list $( \\theta _ { j } ) _ { 2 \\leq j \\leq J }$ . Therefore, the gradient of diversity w.r.t. $\\theta _ { 1 }$ is   \n125 $\\nabla _ { \\theta _ { 1 } } d \\bigl ( \\{ \\theta _ { k } \\} _ { k = 1 , \\ldots , K } \\bigr ) = \\nabla _ { \\theta _ { 1 } } n \\bigl ( \\theta _ { 1 } , \\bigl ( \\theta _ { j } \\bigr ) _ { 2 \\leq j \\leq J } \\bigr ) .$ . That is, we can increase the diversity of the population   \n126 by increasing the novelty of $\\theta _ { 1 }$ w.r.t. the list $( \\theta _ { j } ) _ { 2 \\leq j \\leq J } .$ . In practice, we replace this list by a list of   \n127 nearest neighbors of $\\theta _ { 1 }$ , as this is easier to compute and the elements of $( \\theta _ { j } ) _ { 2 \\leq j \\leq J }$ tend to be among   \n128 the nearest neighbors of $\\theta _ { 1 }$ .   \n129 Under this form, the diversity gradient cannot benefit from the variance reduction methods in the RL   \n130 literature to efficiently compute policy gradients Sutton et al. (1999). To this end, we need to express   \n131 it as a gradient over the expectation of a sum of scalar quantities obtained by policy $\\pi _ { \\theta _ { 1 } }$ at each step   \n132 when interacting with the environment. Therefore, to build a DPG, we need information about the   \n133 novelty of a solution at the time step level. To do so, we introduce a novel space $\\mathcal { D }$ , dubbed state   \n134 descriptor space and a state descriptor extraction function $\\psi : { \\mathcal { S } }  { \\mathcal { D } }$ . We assume $\\mathcal { D }$ and $\\boldsymbol { B }$ have the   \n135 same dimension. Similarly to the novelty of a solution, we now define the novelty of a state $s$ w.r.t. $J$   \n136 other states $\\left( s _ { j } \\right) _ { j = 1 , \\ldots , J }$ as $n : S \\times S ^ { J } \\to \\mathbb { R }$ such that $\\begin{array} { r } { n ( s , ( s _ { j } ) _ { j = 1 , \\dots , J } ) = \\sum _ { j = 1 } ^ { \\tilde { J } } | | \\psi ( s ) , \\psi ( s _ { j } ) | | _ { \\mathcal { D } } } \\end{array}$   \n137 where $| | . | | _ { \\mathcal { D } }$ is a distance metric over $\\mathcal { D }$ .   \n138 Now, we need to link novelty defined at the time step level to novelty defined at the solution level. We   \n139 define the novelty of a state w.r.t. a set of solutions. We say that a state is novel w.r.t. some solutions   \n140 if the state is novel w.r.t. to the states visited by these solutions. More formally: ",
+        "bbox": [
+            142,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            826,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            207,
+            826,
+            271
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            276,
+            825,
+            409
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            414,
+            825,
+            457
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/42e9957f3e02bf53a4be0744fa9e40d4a9a1d23894698d465a38091ed28382f7.jpg",
+        "text": "$$\nn ( s , ( \\theta _ { j } ) _ { j = 1 , \\dots , J } ) = \\sum _ { j = 1 } ^ { J } \\mathbb { E } _ { \\pi _ { \\theta _ { j } } } \\sum _ { t } | | \\psi ( s ) , \\psi ( s _ { t } ) | | _ { \\mathcal { D } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            476,
+            668,
+            520
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "141 While we adopt this definition in this paper, one might as well consider other definitions where, for   \n142 instance, a state is compared to states that have been visited at the same time step during another   \n143 episode. In this context, if the following relation is satisfied: ",
+        "bbox": [
+            142,
+            532,
+            825,
+            575
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/56bb43f4938c74b76ab017bc043373c45da4552935f75ed1f5bd3c1ba52519ea.jpg",
+        "text": "$$\n\\mathbb { E } _ { \\pi _ { \\theta _ { 1 } } } \\sum _ { t } n ( s _ { t } , ( \\theta _ { j } ) _ { 2 \\leq j \\leq J } ) = n ( \\theta _ { 1 } , ( \\theta _ { j } ) _ { 2 \\leq j \\leq J } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            584,
+            656,
+            618
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "144 then we can compute the DPG of $d$ w.r.t. $\\theta _ { 1 }$ as ",
+        "bbox": [
+            142,
+            626,
+            480,
+            642
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f7125de6456da5a14760b0122649fbdbb9baafdb805e1a87e601a11e5dcfee4b.jpg",
+        "text": "$$\n\\nabla _ { \\theta _ { 1 } } ^ { D P G } = \\nabla _ { \\theta _ { 1 } } \\mathbb { E } _ { \\pi _ { \\theta _ { 1 } } } \\sum _ { t } n ( s _ { t } , ( \\theta _ { j } ) _ { 2 \\leq j \\leq J } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            660,
+            637,
+            694
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "145 146 This expression corresponds to the classical policy gradient setting whecorresponding reward signal, here dubbed diversity reward, is computed as $r _ { t } ^ { D } = n ( s _ { t } , ( \\theta _ { j } ) _ { \\ 2 \\leq j \\leq J } )$ $\\gamma = 1$ .   \n147 148 Therefore, this gradient can be comment reward by the diversity reward $r _ { t } ^ { D }$ d using any PG estimation technique replacing the environ-.   \n149 Equation (3) enforces a relation between $\\boldsymbol { B }$ and $\\mathcal { D }$ and between extraction functions $\\psi$ and $\\xi$ . In   \n150 practice, it may be hard to define the behavior descriptor and state descriptor of a solution that satisfy   \n151 this relation while being meaningful to the problem at hand and tractable. But a strict equality is not   \n152 necessary. It suffices that an increase on the left-hand side implies an increase on the right-hand side   \n153 so that we can still update $\\theta _ { 1 }$ using (4). Furthermore, when this is not the case, the diversity gradient   \n154 update might not result in an increase of diversity in the behavior descriptor space, but in that case the   \n155 MAP-Elites insertion rule will remove the corresponding solution. We show in Section 6 that we can   \n156 define descriptors that do not satisfy the above relation all the time, but still give satisfactory results. ",
+        "bbox": [
+            140,
+            707,
+            826,
+            766
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            770,
+            826,
+            882
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A distinguishing feature of our approach is that we combine diversity seeking at the level of trajectories using behavior descriptors and diversity seeking in the state space using state descriptors. The former is used by MAP-Elites to select solutions from the grid and contributes structural bias towards diversity, whereas the latter is used during policy gradient steps in the RL part, see Figure 2b. We organize the literature review below according to this split between two types of diversity seeking mechanisms. ",
+        "bbox": [
+            173,
+            121,
+            825,
+            190
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "QD search in the solution space ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            196,
+            395,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "164 Simultaneously maximizing diversity and performance is the central goal of QD methods (Pugh   \n165 et al., 2016; Cully & Demiris, 2017). Among the various possible combinations offered by the   \n166 QD framework, Novelty Search with Local Competition (NSLC) (Lehman & Stanley, 2011b) and   \n167 MAP-Elites (Mouret & Clune, 2015) are the two most popular algorithms. NSLC builds on the Novelty   \n168 Search (NS) algorithm (Lehman & Stanley, 2011a) and maintains an unstructured archive of solutions   \n169 selected for their local performance while MAP-Elites uniformly samples individuals from a structured   \n170 grid that discretizes the BD space. Not clear in its current form. I suggest: \"QD-PG uses the standard   \n171 grid of MAP-Elites. However, we also show in Appendix F that QD-PG can be used with alternative   \n172 archive structures.   \n173 With the objective of improving their data-efficiency, QD-ES algorithms that combine QD and ESs,   \n174 such as NSR-ES and NSRA-ES, have been applied to challenging continuous control environments in   \n175 Conti et al. (2018). But, as outlined in Colas et al. (2020), they suffer from poor sample efficiency   \n176 and the diversity and environment reward functions could be mixed in a more efficient way. In that   \n177 respect, the most closely related work w.r.t. ours is ME-ES (Colas et al., 2020). The ME-ES algorithm   \n178 also optimizes quality and diversity using MAP-Elites and two ES populations. Using these methods   \n179 was shown to be critically more efficient than population-based GA algorithms (Salimans et al., 2017),   \n180 but our results show that they are still less sample efficient than off-policy deep RL methods, as they   \n181 do not leverage the analytical computation of the policy gradient at the time step level. To the best   \n182 of our knowledge, no QD or ES algorithm use an explicit critic for both performance and diversity,   \n183 resulting in even higher data-efficiency. ",
+        "bbox": [
+            142,
+            217,
+            825,
+            342
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            348,
+            826,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "QD search in the state or action spaces ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            507,
+            442,
+            521
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "185 Seeking for diversity in the space of states or actions is generally framed into the RL framework. This   \n186 is the case of algorithms maintaining a population of RL agents for exploration without an explicit   \n187 diversity criterion (Jaderberg et al., 2017) or algorithms explicitly looking for diversity but in the   \n188 action space rather than in the state space like ARAC (Doan et al., 2019), P3S-TD3 (Jung et al., 2020)   \n189 and DvD (Parker-Holder et al., 2020).   \n190 An exception is Stanton & Clune (2016) who define a notion of intra-life novelty that is similar to   \n191 our state novelty defined in Section 3. However, their novelty relies on skills rather than states. Our   \n192 work is also related to algorithms using RL mechanisms to search for diversity only (Eysenbach et al.,   \n193 2018; Pong et al., 2019; Lee et al., 2019; Islam et al., 2019). These methods have proven useful in   \n194 sparse reward situations, but they are inherently limited when the reward signal can orient exploration,   \n195 as they ignore it. Other works sequentially combine diversity seeking and RL. The GEP-PG algorithm   \n196 Colas et al. (2018) combines a diversity seeking component, namely Goal Exploration Processes   \n197 (Forestier et al., 2017) and the DDPG deep RL algorithm (Lillicrap et al., 2015). This sequential   \n198 combination of exploration-then-exploitation is also present in GO-EXPLORE (Ecoffet et al., 2019).   \n199 Again, this approach is limited when the reward signal can help driving the exploration process to   \n200 efficient solutions. These sequential approaches first look for diversity in the behavior descriptor   \n201 space, then optimize performance in the state action space, whereas we do so simultaneously in the   \n202 behavior descriptor space and in the state space. ",
+        "bbox": [
+            140,
+            527,
+            825,
+            597
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            603,
+            826,
+            784
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To the best of our knowledge, QD-PG is the first algorithm optimizing both diversity and performance in the solution and in the state space, using a sample-efficient policy gradient computation method for the latter. ",
+        "bbox": [
+            166,
+            789,
+            823,
+            830
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 Methods ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            852,
+            277,
+            867
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "07 Our full algorithm is called QD-PG, its pseudo code is given in Appendix A and its architecture is   \n08 depicted in Figure 2. QD-PG is an iterative algorithm based on MAP-Elites that replaces random   \n209 mutations with policy gradient updates. As we consider a continuous action space and want to   \n210 improve sample efficiency by using an off-policy policy gradient method, we rely on the Twin   \n211 Delayed Deterministic Policy Gradient (TD3) algorithm (Fujimoto et al., 2018). See Appendix B for   \n212 a detailed description of TD3. ",
+        "bbox": [
+            150,
+            883,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/c6cf0c77b8bf561d3c8c8a67cf66aa4bec121a2d1e41c96dfa94ada872ba1aa6.jpg",
+        "image_caption": [
+            "Figure 2: (a): The RL part of QD-PG operates at the time step level while the QD part operates at the controller level, considering the MDP as a black box. (b) One QD-PG iteration consists of three phases: 1) A new population of solutions is sampled from the MAP-Elites grid. 2) These solutions are updated by an off-policy RL agent: half of the solutions are optimized for quality and the other half for diversity. The RL agent leverages one shared critic for each objective. 3) The newly obtained solutions are evaluated in the environment. Transitions are stored in a replay buffer while the updated solutions, their final scores and behavior descriptors are stored in the MAP-Elites grid. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            160,
+            823,
+            377
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "QD-PG maintains three permanent structures. In the QD part, a MAP-Elites grid stores the most novel and performing solutions. In the RL part, a replay buffer contains all transitions collected when evaluating solutions and an archive A stores all state descriptors obtained so far. QD-PG starts with an initial population of random solutions, evaluates them and inserts them into the MAP-Elites grid. At each iteration, solutions are sampled from the grid, copied, and updated. The updated solutions are then evaluated through one rollout in the environment and inserted into the grid according to insertion rules. Transitions collected during evaluation are stored in the replay buffer, and state descriptors are stored in the archive A. Note that these state descriptors are first filtered to avoid insertion in the archive of multiple state descriptors that are too close to each other. ",
+        "bbox": [
+            142,
+            498,
+            825,
+            625
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "During the update step, half the population is updated with QPG ascent and the other half with DPG ascent. The choice of whether an agent is updated for quality or diversity is random, meaning that it can be updated for quality and later for diversity if selected again. To justify this design, we show in Section 6 that updating consecutively for quality and diversity outperforms updating based on joint criteria. Both gradients are computed from batches of transitions sampled from the replay buffer. The QPG is computed as usual from rewards whereas for DPG, we get fresh novelty rewards as ",
+        "bbox": [
+            153,
+            628,
+            825,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1b326cebe65ad3eb1f2729ea752c7efdd5903c10a03636d4103a7c7399ea50a0.jpg",
+        "text": "$$\nr _ { t } ^ { D } = \\sum _ { j = 1 } ^ { J } | | \\psi ( s _ { t } ) , \\psi ( s _ { j } ) | | _ { \\mathcal { D } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            712,
+            593,
+            756
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "228 where $\\left( s _ { j } \\right) _ { j = 1 , \\ldots , J }$ are the $J$ nearest neighbors of state $s _ { t }$ in the archive A. Diversity rewards   \n229 must be recomputed at each update because A changes during training. Following Equation (2),   \n230 diversity rewards should be computed as the sum of the distances between the descriptor of $s _ { t }$ and   \n231 the descriptors of all the states visited by a list of $J$ solutions. In practice, we consider the $J$ nearest   \n232 neighbors of $s _ { t }$ . This choice simplifies the algorithm and is faster and works well in practice.   \n233 TD3 relies on a parameterized critic to reduce the variance of its policy gradient estimate. In QD-PG,   \n234 we maintain two parameterized critics $Q _ { w } ^ { D }$ and $Q _ { v } ^ { Q }$ , respectively dubbed diversity and quality critics,   \n235 every time a policy gradient is computed, QD-PG also updates the corresponding critic. In fact, as   \n236 in TD3, we use pairs of critics and target critics to fight the overestimation bias. We share the critic   \n237 parameters among the population as in Pourchot $\\&$ Sigaud (2018). Reasons for doing so come from   \n238 the fact that diversity is not stationary, as it depends on the current population. If each agent had   \n239 its own diversity critic, since an agent may not be selected for a large number of generations before   \n240 being selected again, its critic would convey an outdated picture of the evolving diversity. We tried   \n241 this solution, and it failed. A side benefit of critic sharing is that both critics become accurate faster as   \n242 they combine experience from all agents. Additional details on QD-PG implementation are available   \n243 in Appendix C. ",
+        "bbox": [
+            140,
+            762,
+            825,
+            835
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            92,
+            825,
+            174
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "244 6 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            194,
+            312,
+            210
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we intend to answer the following matters: 1. Can QD-PG produce collections of diverse and high-performing neural policies and what are the advantages to do so? 2. Is QD-PG more sample efficient than its QD competitors? 3. To what extent are the considered benchmarks difficult for classical policy gradients methods? 4. What is the usefulness of the different components of QD-PG? ",
+        "bbox": [
+            174,
+            224,
+            825,
+            294
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Environments ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            301,
+            274,
+            315
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We asses QD-PG capabilities in continuous control environments that exhibit high dimensional observation and action spaces as well as strong exploration difficulties. Two types of reward signals, dubbed sparse and deceptive, are known to be particularly difficult for classical RL methods. These rewards appear in many applications such as robotics or combinatorial optimization. Sparse rewards are obtained if a given condition is specified, leading to a majority of null rewards and to credit assignment difficulties. Deceptive rewards are dense signals, i.e., they are non-zero at each time step but can mislead the search process to some local optimum. In such problems, a good approach to the exploration-exploitation trade-off is essential. The agent should learn when to ignore the reward signal and explore to avoid local minima and when to follow it to increase its return. Deceptive environments constitute a natural choice to highlight QD efficiency to balance exploration and exploitation. In this study, we consider three OpenAI Gym environments based on the MUJOCO physics engine that all exhibit strong deceptive rewards (illustrated in Appendix 5). Such environments have been widely used in previous works (Parker-Holder et al., 2020; Colas et al., 2020; Frans et al., 2018; Shi et al., 2020) for their deceptive nature, a characteristic that is absent of more widespread continuous control environments like HALFCHEETAH-V2, HOPPER-V2 or still ANT-V2. ",
+        "bbox": [
+            173,
+            321,
+            825,
+            529
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the POINT-MAZE environment, an agent represented as a green sphere must find the exit of the maze depicted in Figure 4a, represented as a red sphere. An observation contains the agent position at time $t$ , and an action corresponds to position increments along the $x$ and $y$ axes. The reward is expressed as the negative Euclidean distance between the center of gravity of the agent and the exit center. The trajectory length cannot exceed 200 steps. ",
+        "bbox": [
+            171,
+            535,
+            825,
+            604
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The ANT-MAZE environment is modified from OpenAI Gym ANT-V2 (Brockman et al., 2016) and also used in (Colas et al., 2020; Frans et al., 2018). In ANT-MAZE, a four-legged ant has to reach a goal zone located in the lower right part of the maze (colored in green in Figure 4b). Its initial position is sampled in a small circle located in the maze’s extreme bottom left. As in POINT-MAZE, the reward is expressed as the negative Euclidean distance between the ant and the center of the goal zone. Maze walls are organized so that following the gradient of the reward function drives the ant into a dead-end. In ANT-MAZE, the final performance is defined as the maximum reward received during an episode. The environment is considered solved when an agent obtains a score superior to $- 1 0$ , corresponding to reaching the goal zone. An episode consists of 3000 time steps, this horizon is three times larger than in usual MUJOCO environments, making this environment particularly challenging for RL based methods (Vemula et al., 2019). ",
+        "bbox": [
+            171,
+            611,
+            825,
+            763
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, the ANT-TRAP environment also derives from ANT-V2 and is inspired from (Colas et al., 2020; Parker-Holder et al., 2020). In ANT-TRAP, the four-legged ant initially appears in front of a trap and must bypass it to run as fast as possible in the forward direction (see Figure 4c), as in ANT-V2, the reward is computed as the ant velocity on the x-axis. The trap consists of three walls forming a dead-end directly in front of the ant, leading to a strong deceptive reward. In this environment, the trajectory length cannot exceed 1000 steps. As opposed to POINT-MAZE and ANT-MAZE, where the objective is to reach the exit area, there is no unique way to solve ANT-TRAP and we expect a QD algorithm to generate various effective solutions as depicted in Figure 1. ",
+        "bbox": [
+            173,
+            770,
+            825,
+            881
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "QD-PG is compared to three types of methods. First, to answer question 2, we compare QD-PG to a family of QD baselines, namely ME-ES, NSR-ES, and NSRA-ES (Colas et al., 2020). Appendix E.1 recaps the properties of all these methods. Second, to answer question 3, we compare QD-PG to a family of policy gradient baselines. Soft Actor Critic (SAC) (Haarnoja et al., 2018) and the Twin Delayed Deep Deterministic policy gradient (TD3) (Fujimoto et al., 2018) are continuous control algorithms achieving state-of-the-art results on MUJOCO benchmarks. Random Network Distillation (RND) (Burda et al., 2018) is a curiosity-driven RL agent (Schulman et al., 2017) which was shown to perform well in hard exploration settings. CEM-RL (Pourchot & Sigaud, 2018) mixes Cross-Entropy Methods (CEM) and RL to evolve a population of agents to maximize quality and obtains stateof-the-art results MUJOCO benchmarks. Finally, to answer question 4, we propose to investigate the following matters: Can we replace alternating quality and diversity updates by a single update that optimizes for the sum of both criteria? Are quality gradients updates alone enough to fill the MAP-Elites grid? Are diversity gradients updates alone enough to do so? Consequently, we consider the following ablations of QD-PG: QD-PG SUM computes a gradient to optimize the sum of the quality and diversity rewards, D-PG applies only diversity gradients to the solutions, and Q-PG applies only quality gradients, but both D-PG and Q-PG still use QD selection (see Appendix E.1). ",
+        "bbox": [
+            169,
+            112,
+            825,
+            333
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare QD-PG to its ablations and RL competitors in all environments and show results in Table 1a. Detailed results including graphic charts and coverage maps are given in Appendix E and more details about the evaluation procedure are given in Appendix E.1. ",
+        "bbox": [
+            163,
+            339,
+            823,
+            381
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 Results ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            401,
+            266,
+            417
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "1. Can QD-PG produce collections of neural policies and what are the advantages to do so? ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            431,
+            803,
+            446
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "312 Table 1a presents QD-PG performances. In all environments, our algorithm manages to find working   \n313 solutions that avoid local minima and reach the overall objective. In addition to its exploration   \n314 capabilities, QD-PG generates collections of high performing solutions in a single run. During the   \n315 ANT-TRAP experiment, the final collection of solutions returned by QD-PG contained, among others,   \n316 5 solutions that were within a $10 \\%$ performance margin from the best one. As illustrated in Figure 1,   \n317 these agents typically differ in their gaits and preferred trajectories to circumvent the trap. ",
+        "bbox": [
+            145,
+            453,
+            825,
+            536
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Generating a collection of diverse solutions comes with the benefit of having a repertoire of diverse solutions that can be used as alternatives when the MDP changes (Cully et al., 2015). We show that QD-PG is more robust than conventional policy gradient methods by changing the reward signal of the ANT-MAZE environment. We replace the original goal in the bottom right part of the maze (see Figure 3) with a new randomly located goal in the maze. Instead of running QD-PG to optimize for this new objective, we run a Bayesian optimization process to quickly find a good solution among the ones already stored in the grid. With a budget of only 20 solutions to be tested during the Bayesian optimization process, we are able to quickly recover a good solution for the new objective. We repeat this experiment 100 times, each time with a different random goal, and obtain an average performance of $- 1 0$ with a standard deviation of 9. In other words, 20 interaction episodes (corresponding to 60.000 time steps) suffice for the adaptation process to find a solution that performs well for the new objective without the need to re-train agents. More detailed results can be found in Appendix E.3. 2 ",
+        "bbox": [
+            171,
+            542,
+            553,
+            762
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/5dae693770ba1c498f1b1a8601153b56deb949b863f6dcdd179ab5d84b7a521d.jpg",
+        "image_caption": [
+            "Figure 3: QD-PG produces a collection of diverse solutions. In ANT-MAZE, even after setting new randomly located goals, the MAP-Elites grid still contains solutions that are suited for the new objectives. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            570,
+            545,
+            825,
+            651
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            763,
+            826,
+            804
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "2. Is it more sample efficient than its QD competitors? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            810,
+            552,
+            825
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1b compares QD-PG to Deep Neuroevolution algorithms with a diversity seeking component in terms of sample efficiency. QD-PG runs on 10 CPU cores for 2 days while its competitors used 1000 CPU cores for the same duration. Nonetheless, QD-PG matches the asymptotic performance of ME-ES using two orders of magnitude fewer samples, explaining the lower resource requirements. ",
+        "bbox": [
+            176,
+            832,
+            825,
+            887
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Results for all environments. Final Perf. is the minimum distance to the goal in ANT-MAZE and the episode return in POINT-MAZE and ANT-TRAP. The Ratio to ours column compares the sample efficiency of a method to QD-PG. ",
+        "bbox": [
+            174,
+            97,
+            825,
+            138
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(a) Comparison to ablations and PG baselines. ",
+        "bbox": [
+            200,
+            147,
+            468,
+            160
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/6e501062f0928179d232e7671d6f09853e4e158312d0cc0f30bd8bfc5d5e6a01.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">Final Perf.(± std)</td></tr><tr><td>Algorithm</td><td>POINT-MAZE</td><td>ANT-MAZE</td><td>ANT-TRAP</td></tr><tr><td>QD-PG</td><td>-24(±0)</td><td>-7(±7)</td><td>1541(±86)</td></tr><tr><td>QD-PG SUM</td><td>-25(±1)</td><td>-5(±3)</td><td>1018(±6)</td></tr><tr><td>D-PG</td><td>-37(±3)</td><td>-2(±0)</td><td>1016(±8)</td></tr><tr><td>Q-PG</td><td>-128(±0)</td><td>-26(±0)</td><td>1175(±79)</td></tr><tr><td>CEM-RL</td><td>-312(±1)</td><td>-26(±0)</td><td>934(±22)</td></tr><tr><td>SAC</td><td>-127(±1)</td><td>-59(±1)</td><td>1049(±21)</td></tr><tr><td>TD3</td><td>-130(±2)</td><td>-26(±0)</td><td>1131(±7)</td></tr><tr><td>RND</td><td>-35(±10)</td><td>-27(±1)</td><td>978(±61)</td></tr></table>",
+        "bbox": [
+            173,
+            167,
+            488,
+            273
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/94bdbbd5f3f9f17eed0c94fff309f0488cde1fc4861814dd1db829388b9e96f5.jpg",
+        "table_caption": [
+            "(b) Comparison to evolutionary competitors. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">ANT-MAZE</td></tr><tr><td>Algorithm</td><td>Final Perf.</td><td>Steps to goal</td><td>Ratio to ours</td></tr><tr><td>QD-PG</td><td>-7(±7)</td><td>1.15e8</td><td>1</td></tr><tr><td>CEM-RL</td><td>-26(±0)</td><td>8</td><td>8</td></tr><tr><td>ME-ES</td><td>-5(±1)</td><td>2.4e10</td><td>209</td></tr><tr><td>NSR-ES</td><td>-26(±0)</td><td>8</td><td>8</td></tr><tr><td>NSRA-ES</td><td>-2(±1)</td><td>2.1e10</td><td>182</td></tr></table>",
+        "bbox": [
+            496,
+            167,
+            805,
+            242
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "342 We see three reasons for the improved sample efficiency of QD-PG: 1) QD-PG leverages a replay   \n343 buffer and can re-use each sample several times. 2) QD-PG leverages novelty at the state level and   \n344 can exploit all collected transitions to maximize quality and diversity. For instance, in ANT-MAZE,   \n345 a trajectory brings 3000 samples to QD-PG while standard QD methods would consider it a unique   \n346 sample. 3) PG exploits the analytical gradient between the neural network weights and the resulting   \n347 policy action distribution and estimates only the impact of the distribution on the return. By contrast,   \n348 standard QD methods directly estimate the impact on the return of randomly modifying the weights. ",
+        "bbox": [
+            147,
+            299,
+            825,
+            396
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3. To what extent the considered benchmarks are difficult for policy gradients methods? ",
+        "text_level": 1,
+        "bbox": [
+            163,
+            401,
+            784,
+            417
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 1a compares QD-PG to state-of-the-art policy gradient algorithms and validates that classical policy gradient methods fail to find optimal solutions in deceptive environments. TD3 quickly converges to local minima of performance resulting from being attracted in dead-ends by the deceptive gradients. While we may expect SAC to better explore due to entropy regularization, it also converges to that same local minima in ANT-TRAP and POINT-MAZE. Besides, despite its exploration mechanism based on CEM, CEM-RL also quickly converges to local optima in all benchmarks, confirming the need for a dedicated diversity seeking component. RND, which adds an exploration bonus used as an intrinsic reward (see Appendix G for more details), also demonstrates performances inferior to QD-PG in all environments but manages to solve POINT-MAZE. In ANT-MAZE and ANT-TRAP, as shown in Appendix G.2, RND extensively explores the BD space but fails to obtain high returns. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            561
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4. What is the usefulness of the different components of QD-PG ? ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            568,
+            627,
+            582
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The ablation study in Table 1a shows that when maximising quality only, Q-PG fails due to the deceptive nature of the reward and when maximizing diversity only, D-PG sufficiently explores to solve the problem in both POINT-MAZE and ANT-MAZE but requires more steps and finds lowerperforming solutions. When optimizing simultaneously for quality and diversity, QD-PG SUM fails to learn in ANT-TRAP and manages to solve the task in ANT-MAZE but requires more samples than QD-PG. We hypothesize that quality and diversity rewards may give rise to conflicting gradients. For instance, at the beginning of training in ANT-TRAP, the quality reward drives the ant forward whereas the diversity reward drives it back to escape the trap and explore the environment. Therefore, both rewards cancel each other, preventing any learning. This study validates the usefulness of QD-PG components: 1) optimizing for diversity is required to overcome the deceptive nature of the reward; 2) adding quality optimization provides better asymptotic performance; 3) it is better to disentangle quality and diversity updates. ",
+        "bbox": [
+            171,
+            588,
+            825,
+            753
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            773,
+            297,
+            790
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This paper is the first to introduce a diversity gradient to explore diversity both at the state and skill levels. Based on this component we proposed a novel algorithm, QD-PG, inspired from the Quality-Diversity literature, that produces collections of diverse and high-performing neural policies in a sample-efficient manner. We showed experimentally that QD-PG generates several solutions that achieve high returns in challenging exploration problems. Finally, we demonstrated that in a few interactions with the environment, QD-PG finds alternative solutions that still obtain good performance when the MDP changes. ",
+        "bbox": [
+            165,
+            804,
+            825,
+            902
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            89,
+            266,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "382 Alvarez, A., Dahlskog, S., Font, J., and Togelius, J. Empowering quality diversity in dungeon design with interactive constrained map-elites. In 2019 IEEE Conference on Games (CoG), pp. 1–8. IEEE, 2019.   \n385 Brockman, G., Cheung, V., Pettersson, L., Schneider, J., Schulman, J., Tang, J., and Zaremba, W. Openai gym. arXiv preprint arXiv:1606.01540, 2016.   \n87 Burda, Y., Edwards, H., Storkey, A., and Klimov, O. Exploration by random network distillation. arXiv preprint arXiv:1810.12894, 2018.   \n389 Cazenille, L., Bredeche, N., and Aubert-Kato, N. Exploring self-assembling behaviors in a swarm of bio-micro-robots using surrogate-assisted map-elites. arXiv preprint arXiv:1910.00230, 2019. Colas, C., Sigaud, O., and Oudeyer, P.-Y. GEP-PG: Decoupling exploration and exploitation in deep reinforcement learning algorithms. arXiv preprint arXiv:1802.05054, 2018. Colas, C., Madhavan, V., Huizinga, J., and Clune, J. Scaling map-elites to deep neuroevolution. In Proceedings of the 2020 Genetic and Evolutionary Computation Conference, pp. 67–75, 2020. Conti, E., Madhavan, V., Such, F. P., Lehman, J., Stanley, K., and Clune, J. Improving exploration in evolution strategies for deep reinforcement learning via a population of novelty-seeking agents. In Advances in neural information processing systems, pp. 5027–5038, 2018. Cully, A. and Demiris, Y. Quality and diversity optimization: A unifying modular framework. IEEE Transactions on Evolutionary Computation, 22(2):245–259, 2017.   \n00 Cully, A., Clune, J., Tarapore, D., and Mouret, J.-B. Robots that can adapt like animals. Nature, 521 (7553):503–507, 2015. Doan, T., Mazoure, B., Durand, A., Pineau, J., and Hjelm, R. D. Attraction-repulsion actor-critic for continuous control reinforcement learning. arXiv preprint arXiv:1909.07543, 2019.   \n04 Doncieux, S., Laflaquière, A., and Coninx, A. Novelty search: a theoretical perspective. In Proceedings of the Genetic and Evolutionary Computation Conference, pp. 99–106, 2019.   \n06 Ecoffet, A., Huizinga, J., Lehman, J., Stanley, K. O., and Clune, J. Go-explore: a new approach for hard-exploration problems. arXiv preprint arXiv:1901.10995, 2019. Eysenbach, B., Gupta, A., Ibarz, J., and Levine, S. Diversity is all you need: Learning skills without a reward function. arXiv preprint arXiv:1802.06070, 2018.   \n10 Forestier, S., Mollard, Y., and Oudeyer, P.-Y. Intrinsically motivated goal exploration processes with automatic curriculum learning. arXiv preprint arXiv:1708.02190, 2017.   \n412 Frans, K., Ho, J., Chen, X., Abbeel, P., and Schulman, J. Meta learning shared hierarchies. Proc. of ICLR, 2018.   \n414 Fujimoto, S., Van Hoof, H., and Meger, D. Addressing function approximation error in actor-critic methods. arXiv preprint arXiv:1802.09477, 2018.   \n16 Haarnoja, T., Zhou, A., Hartikainen, K., Tucker, G., Ha, S., Tan, J., Kumar, V., Zhu, H., Gupta, A., Abbeel, P., et al. Soft actor-critic algorithms and applications. arXiv preprint arXiv:1812.05905, 2018.   \n419 Islam, R., Ahmed, Z., and Precup, D. Marginalized state distribution entropy regularization in policy optimization. arXiv preprint arXiv:1912.05128, 2019. Jaderberg, M., Dalibard, V., Osindero, S., Czarnecki, W. M., Donahue, J., Razavi, A., Vinyals, O., Green, T., Dunning, I., Simonyan, K., et al. Population-based training of neural networks. arXiv preprint arXiv:1711.09846, 2017.   \n424 Jung, W., Park, G., and Sung, Y. Population-guided parallel policy search for reinforcement learning. In International Conference on Learning Representations, 2020.   \n426 Khadka, S. and Tumer, K. Evolution-guided policy gradient in reinforcement learning. In Neural Information Processing Systems, 2018.   \n428 Khadka, S., Majumdar, S., Miret, S., Tumer, E., Nassar, T., Dwiel, Z., Liu, Y., and Tumer, K. Collaborative evolutionary reinforcement learning. arXiv preprint arXiv:1905.00976, 2019. Koos, S., Mouret, J.-B., and Doncieux, S. The transferability approach: Crossing the reality gap in evolutionary robotics. IEEE Transactions on Evolutionary Computation, 17(1):122–145, 2012. Lee, L., Eysenbach, B., Parisotto, E., Xing, E., Levine, S., and Salakhutdinov, R. Efficient exploration via state marginal matching. arXiv preprint arXiv:1906.05274, 2019.   \n434 Lehman, J. and Stanley, K. O. Abandoning objectives: Evolution through the search for novelty alone. Evolutionary computation, 19(2):189–223, 2011a. Lehman, J. and Stanley, K. O. Evolving a diversity of virtual creatures through novelty search and local competition. In Proceedings of the 13th annual conference on Genetic and evolutionary computation, pp. 211–218, 2011b.   \n439 Lillicrap, T. P., Hunt, J. J., Pritzel, A., Heess, N., Erez, T., Tassa, Y., Silver, D., and Wierstra, D. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. Mouret, J.-B. and Clune, J. Illuminating search spaces by mapping elites. arXiv preprint arXiv:1504.04909, 2015. Nasiriany, S., Pong, V. H., Lin, S., and Levine, S. Planning with goal-conditioned policies. arXiv preprint arXiv:1911.08453, 2019. Parker-Holder, J., Pacchiano, A., Choromanski, K., and Roberts, S. Effective diversity in populationbased reinforcement learning. In Neural Information Processing Systems, 2020. Pong, V. H., Dalal, M., Lin, S., Nair, A., Bahl, S., and Levine, S. Skew-fit: State-covering selfsupervised reinforcement learning. arXiv preprint arXiv:1903.03698, 2019.   \n449 Pourchot, A. and Sigaud, O. Cem-rl: Combining evolutionary and gradient-based methods for policy search. arXiv preprint arXiv:1810.01222, 2018. Pugh, J. K., Soros, L. B., and Stanley, K. O. Quality diversity: A new frontier for evolutionary computation. Frontiers in Robotics and AI, 3:40, 2016. Salimans, T., Ho, J., Chen, X., Sidor, S., and Sutskever, I. Evolution strategies as a scalable alternative to reinforcement learning. arXiv preprint arXiv:1703.03864, 2017. Schulman, J., Moritz, P., Levine, S., Jordan, M., and Abbeel, P. High-dimensional continuous control using generalized advantage estimation. arXiv preprint arXiv:1506.02438, 2015. Schulman, J., Wolski, F., Dhariwal, P., Radford, A., and Klimov, O. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.   \n459 Shi, L., Li, S., Zheng, Q., Yao, M., and Pan, G. Efficient novelty search through deep reinforcement learning. IEEE Access, 8:128809–128818, 2020. Silver, D., Lever, G., Heess, N., Degris, T., Wierstra, D., and Riedmiller, M. Deterministic policy gradient algorithms. In Proceedings of the 30th International Conference in Machine Learning, 2014. Stanton, C. and Clune, J. Curiosity search: producing generalists by encouraging individuals to continually explore and acquire skills throughout their lifetime. PloS one, 11(9):e0162235, 2016. Sutton, R. S., McAllester, D. A., Singh, S. P., Mansour, Y., et al. Policy gradient methods for reinforcement learning with function approximation. In NIPs, volume 99, pp. 1057–1063. Citeseer, 1999.   \n469 Vemula, A., Sun, W., and Bagnell, J. Contrasting exploration in parameter and action space: A zerothorder optimization perspective. In The 22nd International Conference on Artificial Intelligence and Statistics, pp. 2926–2935. PMLR, 2019. ",
+        "bbox": [
+            151,
+            103,
+            828,
+            920
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            77,
+            828,
+            921
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            131
+        ],
+        "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]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [No] We believe that this work, in itself, is not prone to have any negative societal impact.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            136,
+            825,
+            241
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            243,
+            493,
+            258
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            238,
+            262,
+            738,
+            295
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            299,
+            393,
+            313
+        ],
+        "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] The code and instructions to run it are available in the supplementary materials.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] Implementation details, hardware details and hyperparameters are presented in Appendix C.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] Yes, we report mean and variance for all experiments, both graphically and in result tables.   \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)? [Yes] Computational details are provided in Appedix C. ",
+        "bbox": [
+            238,
+            316,
+            825,
+            489
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            214,
+            494,
+            823,
+            510
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We use open sourced RL environments.   \n(b) Did you mention the license of the assets? [Yes] We cite the Mujoco physics engine, for which we have licenses.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We provide appendices, source code and a demonstration website.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            513,
+            825,
+            662
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            215,
+            666,
+            705,
+            681
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A] We did not used crowdsourcing or conducted research with human subjects.   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A] This work did not involve research with human subjects   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] This work did not involve research with human subjects ",
+        "bbox": [
+            238,
+            685,
+            825,
+            815
+        ],
+        "page_idx": 11
+    }
+]

parse/train/ByToKu9ll/ByToKu9ll.md

@@ -0,0 +1,242 @@
+# EVALUATION OF DEFENSIVE METHODS FOR DNNS AGAINST MULTIPLE ADVERSARIAL EVASION MODELS
+
+Xinyun Chen Shanghai Jiao Tong University jungyhuk@gmail.com
+
+Bo Li University of Michigan bbbli@umich.edu
+
+Yevgeniy Vorobeychik   
+Vanderbilt University   
+yevgeniy.vorobeychik@vanderbilt.edu
+
+# ABSTRACT
+
+Due to deep cascades of nonlinear units, deep neural networks (DNNs) can automatically learn non-local generalization priors from data and have achieved high performance in various applications. However, such properties have also opened a door for adversaries to generate the so-called adversarial examples to fool DNNs. Specifically, adversaries can inject small perturbations to the input data and therefore decrease the performance of deep neural networks significantly. Even worse, these adversarial examples have the transferability to attack a black-box model based on finite queries without knowledge of the target model. Therefore, we aim to empirically compare different defensive strategies against various adversary models and analyze the cross-model efficiency for these robust learners. We conclude that the adversarial retraining framework also has the transferability, which can defend adversarial examples without requiring prior knowledge of the adversary models. We compare the general adversarial retraining framework with the state-of-the-art robust deep neural networks, such as distillation, autoencoder stacked with classifier (AEC), and our improved version, IAEC, to evaluate their robustness as well as the vulnerability in terms of the distortion required to mislead the learner. Our experimental results show that the adversarial retraining framework can defend most of the adversarial examples notably and consistently without adding additional vulnerabilities or performance penalty to the original model.
+
+# 1 INTRODUCTION
+
+Despite the success of deep neural networks (DNNs) in diverse areas, ranging from image recognition and machine translation to autonomous driving, its vulnerabilities have been exploited in the adversarial environments. Evasion attacks against such deep learning systems have recently received considerable attention. It has been shown that with small magnitude of noise added, the original instance can easily be misclassified by the otherwise accurate deep neural networks (Goodfellow et al., 2014; Papernot et al., 2016c; Nguyen et al., 2015; Szegedy et al., 2013). Such instances are also called adversarial examples.
+
+Given the strong evasion properties of these adversarial examples, some works have been proposed to test and investigate the robustness of the deep neural networks against the adversarial examples (Goodfellow et al., 2014; Kurakin et al., 2016; Huang et al., 2015; Gu & Rigazio, 2014; Jin et al., 2015). However, most of the existing works only evaluate the robustness of the proposed defense strategies over adversarial examples generated using a single attack method, or several similar methods. Meanwhile, since the evaluated adversary models, i.e., adversarial example generation methods, vary among different works that study the effectiveness of defense strategies, it remains a question how to make a comparison among different defense strategies.
+
+In this paper, we focus on providing thorough analysis for different algorithmic strategic defensive learners against various adversary models considering their robustness against adversarial examples, efficiency for cross-model learning process, resilience against additional attacks, and the vulnerabilities of these learners. Here by “cross-model test”, we mean to apply one adversarial model to generate adversarial examples, while test them on the learner trained with instances generated from different adversarial models. High “cross-model test” accuracy indicates higher robustness for learner. In addition, we propose to test the “additional attacks” in a repeated game setting to estimate learner based on against further attacks. A nice symmetry analysis for both the adversary and learner is provided through these analyses. We show that the general adversarial retraining framework performs significantly robust compared with the state-of-the-art defensive algorithms. For example, even for the black box attack, which is considered hard to defend, as long as there is a way to generate these adversarial evasion examples, the robust adversarial retraining framework can always improve the learning ability without knowing the actual adversary model. To our best knowledge, this work is the first to provide comprehensive analysis for different adversarial models and possible defensive solutions.
+
+In summary, we made the following contributions:
+
+1. Evaluate the robustness of the general robust adversarial retraining framework $( R A D )$ with the state-of-the-art AEC, Distillation, and the improved AEC, against different adversary models;   
+2. Propose an improved AutoEncoder stacked with Classifier (IAEC);   
+3. Compare the cross-model learning efficiency of different defensive methods and demonstrate the ability to defend against black-box attacks;   
+4. Demonstrate the robustness of the retraining framework RAD, AEC, IAEC, and Distillation, against new attacks by attacking these robust learners repeatedly;   
+5. Analyze the vulnerabilities induced by different defensive strategies/models based on their tolerance of the malicious distortions required to mislead the classifier.
+
+We illustrate the applicability and efficiency of different defensive strategies against various stateof-the-art adversary models based on both MNIST and CIFAR-10 datasets.
+
+# 2 RELATED WORK
+
+Efforts have been made to understand adversarial examples. Goodfellow et al. (2014) pointed out that the adversarial examples actually make use of the linear nature of the DNNs based on the observation of their generalization across architectures and training sets. Tabacof & Valle (2015) analyzed the adversarial image space and showed that adversarial images appear in large regions in the pixel space. Papernot et al. (2016c) studied the limitation of adversarial evasion examples and showed that some instances are more difficult to manipulate than the others. Sabour et al. (2015) demonstrated that the attacker can change classification to an arbitrary class by malicious manipulations. The reverse engineering problem has been proposed in Vorobeychik & Li (2014), and it theoretically proved that the black-box attack is possible and also showed one could learn a sufficiently similar classifier from queries both theoretically and empirically. Similarly, even without knowing exactly the learning algorithm, several black-box attacks have been proposed targeting DNNs, which demonstrates the transferability of such adversarial examples (Papernot et al., 2016a;b).
+
+Some training methods have been proposed to improve the robustness of deep neural networks. Jan et al. (2002) has proposed to explore the perturbed regions and apply ensemble method to enhance the robustness of classification. Zheng et al. have proposed to stabilize the state-of-the-art Inception architecture against different distortions, and it focuses on general random noise or distortions, such as compression, rescaling and cropping on images Zheng et al. (2016). Miyato et al. (2015) have proposed to apply the local distribution smoothness for statistical model to promote the smoothness of the model distribution and conduct the virtual adversarial training to enhance the performance of deep neural networks. However, all these works did not test on the adversarial examples and still had a long way to perform robustly against these real adversarial instances.
+
+While the existence of adversarial examples is attracting more and more attention, some defense strategies have been proposed to defend against such adversarial examples. In Goodfellow et al. (2014), Goodfellow et al. proposed to train the network with an adversarial objective function based on fast gradient sign method: $\tilde { J } ( \theta , x , y ) = \alpha J ( \theta , x , y ) + ( 1 - \alpha ) J ( \theta , x + \nabla _ { x } J ( \theta , x , y ) , y )$ . In a concurrent and independent work, Kurakin et al. provided an adversarial training method for a large scale dataset, i.e., ImageNet dataset Kurakin et al. (2016). However, they only used fast gradient sign-based methods to generate adversarial examples for both training and evaluation, which fails to consider the generality of defensive strategy. Huang et al. Huang et al. (2015) proposed an alternative method for adversarial training by considering an empirically stronger adversary. In their work, suppose $r ^ { \star }$ is the optimal adversarial perturbation for an instance $( x , y )$ , instead of adding $( x + r ^ { \star } , y )$ into the training dataset, they used “pseudo-samples” for training controlled by a hyperparameter $c$ , which represents the magnitude of perturbation, i.e., $\begin{array} { r } { ( x + c \frac { r ^ { \star } } { | | r ^ { \star } | | } , y ) } \end{array}$ . Several autoencoder structures Vincent et al. (2008) have been proposed against the adversarial examples by reconstructing the original images ahead of classification Gu & Rigazio (2014). Jin et al. have proposed a feedforward CNN structure to improve the robustness in the presence of adversarial noise, which is restricted to the specific type of models in Jin et al. (2015). However, the focus of these researches perform too aggressively on designing robust learning algorithms against arbitrary small perturbations (e.g., noise) neglecting the properties of actual adversarial evasion models. Therefore, studying various adversarial models and building resilient learners accordingly is important. Here we will provide comparisons for defensive algorithms facing different adversarial models to provide insights and encourage devising more efficient learner.
+
+# 3 PROBLEM
+
+To understand the phenomenon of adversarial examples in deep neural networks, we aim to analyze potential defending methods against different adversary models from various perspectives, such as the robustness of the learner itself, the cross-model generalization ability, the resilience against additional attacks, and the vulnerabilities in terms of the required distortion to attack the robust learner again. Let $X \subseteq R ^ { n }$ represent the feature space, with $n$ the number of features. For every instance $x _ { i } \in X$ , which is drawn from certain distribution $x _ { i } \sim D$ , there is a corresponding label $y _ { i } \in \mathcal { V }$ to comprise the data pair $( x _ { i } , y _ { i } )$ , where $x _ { i j }$ denotes the $j$ th feature of $x _ { i }$ .
+
+In the adversarial environments, adversary would like to accomplish the goal of evading the classifier. To formalize, suppose that $M \subseteq \mathcal { V }$ is a set of labels which an adversary wishes to attack, and let $z ( m )$ be the target label for each $m \in M$ . For example, for autonomous driving, potential adversaries may aim to manipulate a stop sign or a dead-end warning sign, to a lamppost, a tree, or an advertisement sign, to cause accidents. Since such perturbations on images towards deep neural networks are often imperceptible to human eyes, it can cause serious vulnerabilities when deploying the DNNs in real adversarial environments. The defender’s goal is to learn a classifier with parameters $w$ , $g _ { w } : x _ { i } \to \mathcal { V }$ , using a training data set of labeled instance $T = \{ ( x _ { 1 } , y _ { 1 } ) , . . . , ( x _ { m } , \bar { y } _ { m } ) \}$ . Here, we focus on deep neural networks representing the function $g _ { w } ( \cdot )$ . Therefore, the learner’s objective is to minimize the following general loss function:
+
+$$
+\operatorname* { m i n } _ { w } \mathcal { L } ( w ; \mathcal { A } ) = \sum _ { \substack { i : y _ { i } \in \mathcal { Y } \backslash M } } l ( g _ { w } ( x _ { i } ) , y _ { i } ) + \sum _ { \substack { i : y _ { i } \in M } } l ( g _ { w } ( \mathcal { A } ( w , x _ { i } ) , y _ { i } ) + \alpha \| w \| _ { p } ^ { p } ,
+$$
+
+where $l ( \cdot )$ can be arbitrary loss function and $\mathcal { A }$ represents the adversary model.
+
+The adversarial risk function in Equation 1 is general: it can be any adversary model oracle, $\mathcal { A }$ , which is used to generate the adversarial evasion instances. Traditionally, this adversarial oracle may capture evasion attack models based on minimizing evasion cost (Lowd & Meek, 2005; Li & Vorobeychik, 2014; Biggio et al., 2014), or based on actual attacker evasion behavior obtained from experimental data (Ke et al., 2016). More formally, we will discuss the potential adversary models for deep neural networks and the possible defensive models for the learner in detail below.
+
+# 3.1 ADVERSARY MODEL
+
+To mislead deep neural networks, various methods have been proposed to generate the adversarial examples. We mainly discuss three state-of-the-art adversary models $\mathcal { A }$ here for further evaluation.
+
+Fast Gradient Sign. Based on the linear view of adversarial examples, a fast way of generating these adversarial examples were proposed in Goodfellow et al. (2014). Suppose $x _ { i }$ is the original feature vector, based on adversary model $\mathcal { A } ( f g s )$ , we have ${ x _ { i } } ^ { \prime } = x _ { i } + \eta$ , where $\eta$ represents the perturbation
+
+added for the original instance. Therefore, the dot product between the weighted parameter vector $w$ and an adversarial example ${ x } _ { i } ^ { \prime }$ becomes:
+
+$$
+w ^ { T } x _ { i } { ' } = w ^ { T } x _ { i } + w ^ { T } \eta .
+$$
+
+Let ${ \cal J } ( w , x _ { i } , y _ { i } )$ be the cost used to train the neural network. By linearizing the cost function around the current value of $w$ , an optimal max-norm constrained perturbation is generated as
+
+$$
+\eta = \mathrm { { \epsilon s i g n } } { \left( \nabla _ { x } J ( w , x _ { i } , y _ { i } ) \right) } ,
+$$
+
+where the adversary can vary $\epsilon$ to generate adversarial examples with different attacking abilities for different deep neural networks.
+
+Coordinate Greedy. Another more general adversary model $\scriptstyle A ( c g )$ is the local search framework Coordinate Greedy (cg) proposed in Li et al. (2016) for approximating the optimal adversarial instance. As an illustration, we focus on binary classification, and assume that $\operatorname { \dot { \phantom { } } g } _ { w } ( x ) = \operatorname { s i g n } ( f ( x ) )$ for some continuous function $f$ , which in this case would be represented by a deep neural network.
+
+The coordinate greedy approach is quite general, but we consider a specific adversary objective in which the adversary here tries to balance between two considerations: 1) appear as benign as possible to the classifier, and 2) minimize the cost of modification of the original instance (e.g., minimally manipulate the image). Note that it is also natural to assume that the attacker obtains no value from a manipulation to the original feature vector if the result is still classified as malicious. Therefore, an adversary aiming to transform an instance $x _ { i }$ into an adversarial example $x _ { i } { } ^ { \prime }$ is solving the following optimization problem:
+
+$$
+\operatorname* { m i n } _ { { x _ { i } } ^ { \prime } \in X } \operatorname* { m i n } \{ 0 , f ( { x _ { i } } ^ { \prime } ) \} + c ( { x _ { i } } ^ { \prime } , { x _ { i } } ) ,
+$$
+
+where $c ( x _ { i } ^ { \prime } , x _ { i } )$ is the cost function of modifying from $x _ { i }$ to ${ x } _ { i } ^ { \prime }$ . Here $c ( x _ { i } ^ { \prime } , x _ { i } ) \geq 0$ , $c ( x _ { i } ^ { \prime } , x _ { i } ) = 0$ iff $x _ { i } { ' } = x _ { i }$ , and the cost function $c$ is strictly increasing in $\| { x } _ { i } ^ { \prime } - { x } _ { i } \| _ { 2 }$ and strictly convex in $x _ { i } { ' }$ . Because Problem 2 is non-convex, so the objective of adversary can be formed to minimize an upper bound:
+
+$$
+\operatorname* { m i n } _ { { x _ { i } } ^ { \prime } } Q ( x _ { i } { ' } ) \equiv f ( x _ { i } { ' } ) + c ( x _ { i } { ' } , x _ { i } ) .
+$$
+
+So the high-level idea of $c g$ is to iteratively choose a feature, and greedily update this feature according to the partial derivatives of the attacker’s objective as 3 to evade the classifier. Below, we take the exponential cost function $c ( x _ { i } { ' } , x _ { i } ) = \mathrm { e x p } \left( \lambda ( \sum _ { j } ( x _ { i j } { ' } - x _ { i j } ) ^ { 2 } + 1 ) ^ { 1 / 2 } \right)$ as an example to estimate the modification cost, which is also quite natural: options become exponentially less desirable to an attacker as they are more distant from their ideal attack. Then we take the following partial derivative to update the adversary’s objective until the convergence.
+
+$$
+\frac { \partial Q ( x _ { i } { ' } ) } { \partial x _ { i j } } = \frac { \partial f ( x _ { i } { ' } ) } { \partial x _ { i j } } + \frac { \partial c ( x _ { i } { ' } , x _ { i } ) } { \partial x _ { i j } } = \frac { \partial f ( x _ { i } { ' } ) } { \partial x _ { i j } } + \frac { \lambda c ( x _ { i } { ' } , x _ { i } ) ( x _ { i j } { ' } - x _ { i j } ) } { ( \sum _ { j } ( x _ { i j } { ' } - x _ { i j } ) ^ { 2 } + 1 ) ^ { 1 / 2 } } ,
+$$
+
+To avoid the algorithm converges only to a locally optimal solution, random restarts strategy is applied to randomly select the starting points in the feature space. As long as a global optimum has a basin of attraction with positive Lebesgue measure, or the feature space is finite, this process will asymptotically converge to a globally optimal solution with enough random restarts.
+
+Adam. Another adversary model $\mathcal { A } ( a d a m )$ applies the stochastic gradient-based optimization algorithm Adam Kingma $\&$ Ba (2014) to generate adversarial examples. Specifically, the adversary uses Adam to solve the same optimization problem as in Equation 3.
+
+# 3.2 DEFENDER MODEL
+
+Given the possible adversary models, several defensive strategies have been proposed focusing on different perspectives. Basically, the learner tries to integrate the prior knowledge of either the adversary model or the data distribution with the classification process. Here we consider different defensive strategies given the adversary model and form the interaction as a Stackelberg game. We will also consider the repeated game setting in section 4.4.
+
+Adversarial Retraining framework $( R A D )$ . A systematic defensive approach based on adversarial retraining $( R A D )$ has been proposed in Li et al. (2016). At the high level, $R A D$ starts with the original training data and iteratively updating the learner with adversarial instances that evade the previously computed classifier until the convergence. It has been proved that the algorithm will terminate and the lower bound of the empirical loss of $R A D$ is also provided. The important part for $R A D$ is to select the adversarial retraining instances. In practice, it is hard to exactly estimate the adversary model as well as the parameters used within their model. Therefore, the generalization ability of $R A D$ across different adversary models is quite important. Surprisingly, $R A D$ generalizes quite well among various adversary models without requiring to know the exact attacker strategy. We will present the cross-model analysis for $R A D$ in details in section 4.3.
+
+AutoEncoder stacked with Classifier $( A E C )$ . One of the recent and efficient defensive method is the AutoEncoder stacked with a classifier to initialize deep architectures proposed in Gu & Rigazio (2014). To assess the structure of the adversarial noise, an autoencoder on mapping adversarial examples back to the original data samples is trained and stacked with the classifier. We train the AutoEncoder with different adversarial algorithms, including the fast gradient sign method $( f g s )$ , the coordinate greedy $( c g )$ method, as well as Adam.
+
+Improved AutoEncoder stacked with Classifier (IAEC). Since the baseline $A E C$ cannot perform very well by only mapping the adversarial images back to the original image, we apply an improved AutoEncoder stacked with classifier (IAEC) defensive method. As AutoEncoder itself can not ensure that adversarial examples are denoised, we add a cross-entropy regularizer term as the loss function to help ensure that the output of AutoEncoder is classified correctly. Let $y _ { i }$ be the one-hot representation of ground truth label of an input instance $x _ { i }$ , then our loss function becomes:
+
+$$
+J ( x _ { i } ) = \| s ( x _ { i } ) - { x _ { i } } ^ { \prime } \| + H ( y _ { i } , f ( x _ { i } ) ) ,
+$$
+
+where $s ( x _ { i } )$ represents the mapping result of $x _ { i }$ by the AutoEncoder, and the cross-entropy function $H ( y _ { i } , f ( x _ { i } ) ) \stackrel { - } { = } - \sum _ { x _ { i } } y _ { i } \log f ( \stackrel { - } { x _ { i } } )$ .
+
+Distillation. Considering the fact that the knowledge extracted during training, which is in the form of probability vectors, and transferred in smaller networks to maintain accuracy comparable with those of larger networks can also be beneficial to improving generalization capabilities of deep neural networks outside of their training dataset, a defensive strategy against the adversarial examples has been proposed in Papernot et al. (2015). This defensive strategy transfers the knowledge contained in probability vectors through the distillation training step, then applies these probabilities in the next training step instead of using the original hard labels, and therefore enhances its resilience to perturbations. This defensive model is independent of the adversary models and we will evaluate its robustness and vulnerabilities in details in section 4.
+
+# 4 EXPERIMENTAL ANALYSIS
+
+In this section, we empirically compare the adversarial retraining framework $R A D$ with other stateof-the-art baseline methods Distillation Papernot et al. (2015), AutoEncoder stacked with Classifier (AEC) Gu & Rigazio (2014) and our improved AutoEncoder stacked with Classifier (IAEC) against various adversary models based on both MNIST and CIFAR-10 datasets.
+
+Basically, we first analyze the robustness of $R A D$ and Distillation, which performs the best against adversarial examples currently, by comparing the classification results before and after applying the adversarial retraining technique based on both MNIST and CIFAR-10 datasets. Then we estimate the cross-model classification robustness for $R A D , A E C$ , the improved IAEC, and Distillation. Precisely, during the cross-model evaluation, we allow the attacker to generate the adversarial examples with different adversarial algorithms, while the defender has no clue about what adversarial algorithm is used. Therefore, we are able to evaluate the resilience of the “black-box” defensive strategies without requiring to know the actual adversary model.
+
+Besides, we allow the attacker to attack these robustly enhanced learners and we compare the resilience of the $R A D$ with the baseline defensive models and show that with retraining instances generated by adam, the $R A D$ is almost unassailable for attacks based on the fast gradient sign method, which is promising to design universal defensive algorithms based on $R A D$ .
+
+Additionally, another perspective to measure the robustness of the learners is to evaluate how much noise is needed to make the learner misclassify an otherwise correct instance. As pointed out by $\mathrm { G u }$ & Rigazio (2014), even a learner can be demonstrated to perform robustly against certain adversarial examples, it may become more vulnerable in the sense of being attacked by adding much smaller magnitude of adversarial noise. This means increasing the noticeability of the smallest adversarial noise for each example becomes the key to solve the adversarial examples problem. Therefore, we compare the malicious distortion required to attack each model, aiming to evaluate the vulnerability of different learners. The distortion is measured by $\begin{array} { r } { d ( x _ { i } ^ { \prime } , x _ { i } ) = \frac { 1 } { n } \sqrt { \sum ( x _ { i } ^ { \prime } - x _ { i } ) ^ { 2 } } } \end{array}$ , where $x _ { i } ^ { \prime } =$ $\mathcal { A } ( \beta , x _ { i } )$ representing the adversarial manipulated instance based on arbitrary adversary model $\mathcal { A }$ .
+
+# 4.1 EXPERIMENTAL SETUP
+
+In our experiments, we focus on binary classification, and the adversary tries to modify a malicious instance (classified as $+ 1$ ) to evade the classifier and be classified as benign (-1). On MNIST, we select digit $" 4 "$ as the malicious (positive) class, and $" 7 "$ as the benign (negative) class. On CIFAR10, we use “Airplane” as the malicious class, and “Cat” as the benign class. We use LeNet-5 LeCun et al. (1998) to perform the binary classification, and all classifiers used to evaluate the efficiency of different adversary models and defender models are based on this model architecture. All input pixel values are normalized into $[ - 0 . 5 , 0 . 5 ]$ .
+
+With respect to adversary models, during the evaluation, all of them modify the malicious instances in the original testset to evade the classifier, and keep the benign instances untouched. Meanwhile, for iterative attack methods evaluated in our experiments, i.e., $c g$ and adam, according to our experiments, actually we can find adversarial examples with small modification cost using any $\lambda$ , even when setting $\lambda = 0$ , i.e., not considering the cost function $c ( x _ { i } ^ { \prime } , x _ { i } )$ for optimization. Therefore, we set $\lambda = 0$ for all experiments using these two attack methods.
+
+With respect to defensive models, for RAD, we only add adversarial examples generated on original malicious instances into the dataset for retraining, since the goal of adversary is trying to fool a classifier to label a malicious instance as benign, which follows the framework proposed in Li et al. (2016). As for AEC and IAEC, we use the same autoencoder architecture for removing adversarial noises proposed in Gu & Rigazio (2014), i.e., a three-hidden-layer autoencoder (784-256-128-256- 784 neurons). We train the autoencoder to map adversarial examples generated on original malicious instances to the original images, and as suggested in Gu & Rigazio (2014), we also train the autoencoder to map original data back to itself. Both AEC and IAEC stack the autoencoder with a LeNet-5 classifier.
+
+# 4.2 ROBUSTNESS ANALYSIS FOR DEFENSIVE LEARNERS
+
+To evaluate the robustness and efficiency of the adversarial retraining framework and other defensive learners, we generate adversarial examples based on the the coordinate gradient algorithm $( c g )$ , adam, and the fast gradient sign algorithm $( f g s _ { \epsilon } )$ with the size of perturbation $\epsilon = 0 . 1 \sim 0 . 5$ ( Goodfellow et al. (2014)), respectively. Figure 1 shows the analysis of recall for the traditional LeNet-5 and the robust $R A D$ classifiers on MNIST. The test error of LeNet-5 on the original dataset is $0 . 0 4 5 \%$ . It is obvious that after the adversarial retraining process based on $R A D$ , the classifiers perform nearly optimal. It is interesting to observe that with the $\epsilon$ of fgs increases, the adversarial examples generated by fgs can attack the original LeNet-5 more efficiently.
+
+Figure 2 presents the comparisons of recall for the original LeNet-5 and the adversarial retraining framework on CIFAR-10. It shows that the adversarial retraining framework works robustly against different adversarial example generation methods. Note the test error of LeNet-5 on the original dataset is $5 . 5 \%$ . From the results of recall, we can see that almost all the “generated” adversarial instances are correctly classified by the retraining framework. Additionally, sometimes the test error of $R A D$ is even smaller than that of the original model LeNet-5 based on the uncontaminated (no adversary) data. This means, with the adversarial robust retraining process, some “blind-spots” in the input space volume can be filled out without decreasing the performance on the normal test data. Moreover, surprisingly, with the increase of $\epsilon$ , the fast gradient sign method works worse for generating adversarial examples against LeNet-5, which is different for MNIST. This is actually caused by the properties of the fast gradient sign method itself. By following the gradient, the generated instance can be trapped into sub-optimal and therefore fail to converge to the global optima, so different step size can affect their final convergence. Therefore, by comparing with the results of MNIST, we can see learners on CIFAR-10 is easier to be trapped by the sub-optima and larger $\epsilon$ values can lead the learner to be trapped into these points with higher probability. On the other hand, no matter how much the strength of adversarial ability is affected by different parameters, the adversarial retraining framework works robustly by almost identifying all the manipulated instances correctly on different datasets consistently.
+
+![](images/ecbb64d765a0fe57f02c698626b68671c5333bbab455fe193a120384ed7fbfa2.jpg)  
+Figure 1: Performance of retraining with instances generated from different models based on MNIST. (a) The retraining instances are generated by $c g$ ; (b) the adversarial examples are generated by $c g$ ; (c) the adversarial examples are generated by adam.
+
+![](images/e320c714385bad3ae3f2ab6cf42a6d7f02a12f22f4fca741093ab95b014ae22c.jpg)  
+Figure 2: Performance of retraining with instances generated from different models based on CIFAR-10. (a) The retraining instances are generated by CG; (b) the adversarial examples are generated by CG; (c) the adversarial examples are generated by adam.
+
+# .3 CROSS-MODEL ANALYSIS FOR DIFFERENT DEFENSIVE LEARNERS
+
+Aiming to defend a more broad class of attacks, here we assume the the learner has no clue about which adversarial algorithm the attacker uses to generate the adversarial instances. Therefore, the defender can perform robustly as the “black-box” learner against arbitrary adversaries. Here we use different attack algorithms to generate the adversarial examples, and the retraining instances for $R A D$ are also generated across various adversary models to evaluate the learners’ generalization ability. We also compare the results with the state-of-the-art Distillation, $A E C$ and our improved $I A E C$ algorithm based on different adversarial models. Here the $A E C$ is trained on the adam model, which offers the best classification results. The IAEC is also trained corresponding to different adversary models to compare the cross-model learning ability with RAD. Table 1 shows the test error comparisons for these cross-model learners. “No adversary” presents the test error of different learners on the clean data. Basically, the adversarial retraining framework performs consistently better than AEC, IAEC, and Distillation on all different adversarial examples in terms of the classification error. This conclusion is independent of what models are used to generate adversarial retraining instances for RAD. Based on the results, the adversarial retraining framework has the potential to be applied to defend against any arbitrary attacks without requiring to know the exact adversary model. Based on the classification error results for our improved IAEC in Table 1, it is obvious that the $I A E C$ with the same adam adversary model works much more robust than AEC. This means the proposed $I A E C$ is much more robust compared with the original AEC by adding the cross-entropy regularization. Additionally, we also evaluate the cross-model classification error for $I A E C$ to test its generalization ability. Table 1 shows that the IAEC can also defend against different adversarial examples without requiring to know the exact adversary model.
+
+Table 1: Classification error of different learners against various adversary models based on MNIST   
+
+<table><tr><td>Model</td><td>A(fgso.1)</td><td>A(fgs0.5)</td><td>A(cg)</td><td>A(adam)</td><td>No adversary</td></tr><tr><td>LeNet-5</td><td>1.2%</td><td>46.1%</td><td>48.2%</td><td>48.9%</td><td>0.045%</td></tr><tr><td>RAD(fgs0.1)</td><td>0.1%</td><td>0.5%</td><td>0.4%</td><td>3.0%</td><td>0.045%</td></tr><tr><td>RAD(fgs0.5)</td><td>0.5%</td><td>0.1%</td><td>0</td><td>2.5%</td><td>0.045%</td></tr><tr><td>RAD(cg)</td><td>0.1%</td><td>1.4%</td><td>0.4%</td><td>2.9%</td><td>0.045%</td></tr><tr><td>RAD(adam)</td><td>0</td><td>0.1%</td><td>0.1%</td><td>0.1%</td><td>0.045%</td></tr><tr><td>AEC(adam)</td><td>3.2%</td><td>20.6%</td><td>9.7%</td><td>2.6%</td><td>4.5%</td></tr><tr><td>IAEC(fgs0.1)</td><td>1.3%</td><td>28.0%</td><td>18.3%</td><td>9.6%</td><td>1.1%</td></tr><tr><td>IAEC(fgs0.5)</td><td>1.2%</td><td>1.4%</td><td>2.6%</td><td>5.5%</td><td>1.0%</td></tr><tr><td>IAEC(cg)</td><td>1.6%</td><td>1.6%</td><td>1.5%</td><td>7.4%</td><td>1.2%</td></tr><tr><td>IAEC(adam)</td><td>1.2%</td><td>5.2%</td><td>7.3%</td><td>2.3%</td><td>1.7%</td></tr><tr><td>Distillation(T = 1)</td><td>0.6%</td><td>47.2%</td><td>29.4%</td><td>41.9%</td><td>0.2%</td></tr><tr><td>Distillation(T = 100)</td><td>0.3%</td><td>42.3%</td><td>12.4%</td><td>28.5%</td><td>0.2%</td></tr></table>
+
+Similarly, we show the classification error comparison results of $R A D$ across different adversary models in Table 2 compared with Distillation. As CIFAR-10 images are more complex, the error rates for adversarial retraining framework get larger compared with that on MNIST. However, overall the classification error for the retraining framework on different adversarial examples are below $13 \%$ with zero knowledge of the adversary model, while the classification error on normal data is around $6 \%$ . Therefore, even on CIFAR-10 dataset, the adversarial retraining framework is still promising to perform the “black-box” defending resiliently against various attacks. Additionally, the distillation with $T = 1$ and $T = 1 0 0$ both encounter higher test error than $R A D$ , even the distillation method performs more robustly when $T = 1 0 0$ than $T = 1$ .
+
+Table 2: Comparisons for the error rate of $R A D$ based on different adversary models on CIFAR-10   
+
+<table><tr><td>Model</td><td>A(fgso.1)</td><td>A(fgs0.5)</td><td>A(cg)</td><td>A(adam)</td><td>No adversary</td></tr><tr><td>LeNet-5</td><td>1.2%</td><td>46.1%</td><td>54.0%</td><td>52.7%</td><td>5.5%</td></tr><tr><td>RAD(fgso.1)</td><td>2.35%</td><td>2.0%</td><td>4.65%</td><td>3.0%</td><td>5.3%</td></tr><tr><td>RAD(fgs0.5)</td><td>4.4%</td><td>2.7%</td><td>5.6%</td><td>2.6%</td><td>5.8%</td></tr><tr><td>RAD(cg)</td><td>7.5%</td><td>2.45%</td><td>5.05%</td><td>2.2%</td><td>5.7%</td></tr><tr><td>RAD(adam)</td><td>16.2%</td><td>2.8%</td><td>6.15%</td><td>2.4%</td><td>5.9%</td></tr><tr><td>Distillation(T =1)</td><td>21.3%</td><td>30.8%</td><td>13.8%</td><td>22.0%</td><td>11.0%</td></tr><tr><td>Distillation(T = 100)</td><td>19.3%</td><td>25.2%</td><td>9.2%</td><td>20.2%</td><td>7.2%</td></tr></table>
+
+# 4.4 ROBUSTNESS AGAINST ADDITIONAL ATTACKS
+
+In order to test the robustness of the learner against the repeated attacks, where the attacker can again conduct attacks on the robust learners, here we evaluate how the robust learner behaves given additional attacks based on different adversary models. Table 3 presents the test error rate comparison when the attacker generates adversarial examples to attack the robust $R A D$ learner, $I A E C$ , and Distillation on MNIST. It is shown that the coordinate greedy $( c g )$ and adam are somehow efficient to attack $R A D$ , while the fast gradient sign methods fail to attack the robust $R A D$ . So if the $R A D$ is retrained with instances generated by arbitrary adversary models, it can be resilient against adversarial examples produced by the fast gradient sign method with various $\epsilon$ values. This means the $R A D$ can confer robustness to single-step attack methods but not the iterative ones. However, adversaries based on $c g$ and adam can still find the vulnerabilities to attack the model. Compared with the performance of the adversarial retraining framework $( R A D )$ against these “repeated attacks”, the $I A E C$ encounters much higher classification error when being attacked. This indicates that the adversarial retraining framework can not only enhance the resilience of the original learner (LeNet-5), but also perform robustly against the additional attacks compared with the IAEC.
+
+Similarly, Table 4 presents the test error for attacking different robust learners with various adversary models on CIFAR-10. RAD again produces lower test error compared with Distillation $T = 1$
+
+Table 3: Error rate of attacking the robust learners with additional attacks on MNIST   
+
+<table><tr><td>Model</td><td>A(fgs0.1)</td><td>A(fgs0.5)</td><td>A(cg)</td><td>A(adam)</td></tr><tr><td>RAD(fgs0.1)</td><td>0.3%</td><td>9.6%</td><td>48.1%</td><td>49.0%</td></tr><tr><td>RAD(fgs0.5)</td><td>0.8%</td><td>0.1%</td><td>45.7%</td><td>49.0%</td></tr><tr><td>RAD(cg)</td><td>0.8%</td><td>3.4%</td><td>44.6%</td><td>49.0%</td></tr><tr><td>RAD(adam)</td><td>0.1%</td><td>0.1%</td><td>40.2%</td><td>48.7%</td></tr><tr><td>IAEC(fgs0.1)</td><td>4.2%</td><td>10.3%</td><td>49.9%</td><td>49.5%</td></tr><tr><td>IAEC(fgs0.5)</td><td>5.2%</td><td>3.8%</td><td>49.8%</td><td>49.9%</td></tr><tr><td>IAEC(cg)</td><td>5.3%</td><td>3.9%</td><td>49.9%</td><td>49.4%</td></tr><tr><td>IAEC(adam)</td><td>4.6%</td><td>7.0%</td><td>49.9%</td><td>49.9%</td></tr><tr><td>Distillation(T = 100)</td><td>0.2%</td><td>0.2%</td><td>49.0%</td><td>48.7%</td></tr></table>
+
+Table 4: Error rate of attacking the robust learners with additional attacks on CIFAR-10   
+
+<table><tr><td>Model</td><td>A(fgso.1)</td><td>A(fgs0.5)</td><td>A(cg)</td><td>A(adam)</td></tr><tr><td>RAD(fgs0.1)</td><td>3.7%</td><td>2.7%</td><td>42.0%</td><td>52.7%</td></tr><tr><td>RAD(fgs0.5)</td><td>5.3%</td><td>2.8%</td><td>49.0%</td><td>52.4%</td></tr><tr><td>RAD(cg)</td><td>7.9%</td><td>2.8%</td><td>52.0%</td><td>52.7%</td></tr><tr><td>RAD(adam)</td><td>6.3%</td><td>3.1%</td><td>54.0%</td><td>52.7%</td></tr><tr><td>Distillation(T = 100)</td><td>9.05%</td><td>8.6%</td><td>54.0%</td><td>54.1%</td></tr></table>
+
+$T = 1 0 0 _ { , }$ ) given diverse adversarial attacking strategies. What is worth to mention is that these robust learners all perform accurately on the normal dataset without adversarial manipulation, which offers more potentials for the robust learners.
+
+# 4.5 VULNERABILITY OF THE DEFENSIVE LEARNERS
+
+Given the fact that the attacker can attack the learning model continuously, here we are concerned with how vulnerable the robust models become in terms of the amount of distortion needed to add to mislead the learner. We compare the average distortion for attacking the LeNet-5, RAD, IAEC, and Distillation to evaluate their robustness. As mentioned by Gu & Rigazio (2014), AEC demands smaller distortion to attack, which means $A E C$ is quite fragile, and we also gain the similar observation and confirm that attacking the original LeNet-5 model requires larger magnitude of noise than $A E C$ . Thus, we focus on the improved IAEC.
+
+In the Table 5 we present the demanded distortion to maliciously attack the $R A D$ , the $I A E C$ , and Distillation on MNIST. Note that the fast gradient sign method here is a one-step method, which will stop after computing one gradient to find the optimal perturbation of a linear approximation of the cost or model, so it cannot guarantee to find the evasion instance $x _ { i } { ' }$ and we do not consider its distortion. so here we only consider $c g$ and adam to generate distortions. We use $R A D ( . )$ to represent the adversarial retraining framework retrained with arbitrary adversarial instances since they all require the same amount of distortion to be attacked given their similar network structures. From Table 5 RAD requires the same distortion as attacking the original LeNet-5 model. However, the distortion needed for attacking the $I A E C$ is substantially smaller than that for attacking the original models. From this perspective, the $I A E C$ becomes more vulnerable compared with the original model even though it can be resilient against the adversarial examples. Similar for Distillation, smaller distortion is demanded to attack the robust learner, which means more vulnerabilities are introduced by the robust Distillation. On the contrary, the adversarial retraining framework $R A D$ can perform robustly against various diverse adversarial attacks without increasing the vulnerability penalty.
+
+Figure 3 shows the results of adding the corresponding adversarial noise to generate the misclassification for LeNet-5 model by different adversarial algorithms qualitatively. It shows that by using fast gradient sign method with $\epsilon = 0 . 5$ , the original image is almost distorted. This indicates different adversary models have different attacking strengths, so taking the stronger adversary model into account may have a chance to defend the weaker adversaries, which makes the universal defensive model promising.
+
+Table 5: Adversarial distortion required for attacking different models on MNIST   
+
+<table><tr><td>Model</td><td>A(cg)</td><td>A(adam)</td></tr><tr><td>LeNet-5</td><td>0.0118</td><td>0.0060</td></tr><tr><td>RAD(.)</td><td>0.0118</td><td>0.0060</td></tr><tr><td>IAEC(fgs0.1)</td><td>0.0042</td><td>0.0031</td></tr><tr><td>IAEC(fgs0.5)</td><td>0.0058</td><td>0.0028</td></tr><tr><td>IAEC(cg)</td><td>0.0069</td><td>0.0023</td></tr><tr><td>IAEC(adam)</td><td>0.0064</td><td>0.0029</td></tr><tr><td>Distillation(T = 100)</td><td>0.0106</td><td>0.0060</td></tr></table>
+
+![](images/e36b789f4ab07b2221ec4670e4bbee971f25978db217088dc30f0c7ab42011e2.jpg)  
+Figure 3: Visualization of adversarial examples generated by different attacker models based on MNIST. (a) Original image, (b) attacked by $f g s _ { 0 . 1 }$ , (c) attacked by $f g s _ { 0 . 5 }$ , (d) attacked by $c g$ , (e) attacked by adam.
+
+Similarly, Table 6 lists the amount of distortion needed to fool the original learner based on CIFAR10. It is shown that both the $R A D$ and Distillation need exactly the same amount of distortion with the original LeNet-5 model, which means these robust learners do not increase the vulnerability of the original model.
+
+Table 6: Adversarial distortion required for attacking different models on CIFAR-10   
+
+<table><tr><td>Model</td><td>A(cg)</td><td>A(adam)</td></tr><tr><td>LeNet-5</td><td>0.0025</td><td>0.0015</td></tr><tr><td>RAD()</td><td>0.0025</td><td>0.0015</td></tr><tr><td>Distillation(T = 100)</td><td>0.0025</td><td>0.0015</td></tr></table>
+
+The visual attacking results by injecting malicious noise are shown in Figure 4. It is clear that fgs with $\epsilon = 0 . 5$ can distort the original images the most compared with other adversary algorithms. Surprisingly, all the retraining framework based on different retraining instances only get the classification error lower than $3 . 0 \%$ .
+
+![](images/643145ffcb53a9db029ccaa143ac7eb2d6ad866eb86272d7c02ebcb796762565.jpg)  
+Figure 4: Visualization of adversarial examples generated by different attacker models based on CIFAR-10. (a) Original image, (b) attacked by $f g s _ { 0 . 1 }$ , (c) attacked by $f g s _ { 0 . 5 }$ , (d) attacked by $c g$ , (e) attacked by adam.
+
+# 5 CONCLUSION
+
+To understand the adversarial examples better, as well as the potential adversary models and corresponding defensive learners, we conduct extensive experiments to evaluate properties of different defensive strategies. We point out that $R A D$ works the best among all the defensive strategies against different adversary models, including one-step and iterative ones, in terms of the classification test error. The adversarial retraining framework, RAD, also generalizes well for the cross-model evaluation compared with AEC, IAEC, and Distillation. Moreover, both $R A D$ and Distillation do not introduce additional vulnerability penalty to the original models, while still increase the robustness. So in the future work, to generalize the robust learner across different adversary models, one direction could be to generate retraining instances based on diverse adversarial algorithms to cover as much as possible the “blind-spots” within the input space. In addition, we will dynamically optimize the choice of adversary model and the quantity of retraining instances according to the robustness requirements of a specific learner. Therefore, the tradeoff between robustness and accuracy on the normal data can be balanced based on the specific resilience demand of the learner.
+
+# REFERENCES
+
+Battista Biggio, Giorgio Fumera, and Fabio Roli. Security evaluation of pattern classifiers under attack. Knowledge and Data Engineering, IEEE Transactions on, 26(4):984–996, 2014.   
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.   
+Shixiang Gu and Luca Rigazio. Towards deep neural network architectures robust to adversarial examples. arXiv preprint arXiv:1412.5068, 2014.   
+Ruitong Huang, Bing Xu, Dale Schuurmans, and Csaba Szepesvari. Learning with adversary. arXiv preprint arXiv:1511.03034, 2015.   
+JC Jan, Shih-Lin Hung, SY Chi, and JC Chern. Neural network forecast model in deep excavation. Journal of Computing in Civil Engineering, 16(1):59–65, 2002.   
+Jonghoon Jin, Aysegul Dundar, and Eugenio Culurciello. Robust convolutional neural networks under adversarial noise. arXiv preprint arXiv:1511.06306, 2015.   
+Liyiming Ke, Bo Li, and Yevgeniy Vorobeychik. Behavioral experiments in email filter evasion. In AAAI Conference on Artificial Intelligence, 2016.   
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016.   
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   
+Bo Li and Yevgeniy Vorobeychik. Feature cross-substitution in adversarial classification. In Advances in Neural Information Processing Systems, pp. 2087–2095, 2014.   
+Bo Li, Yevgeniy Vorobeychik, and Xinyun Chen. A general retraining framework for scalable adversarial classification. arXiv preprint arXiv:1604.02606, 2016.   
+Daniel Lowd and Christopher Meek. Adversarial learning. In Proceedings of the eleventh ACM SIGKDD international conference on Knowledge discovery in data mining, pp. 641–647. ACM, 2005.   
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, Ken Nakae, and Shin Ishii. Distributional smoothing with virtual adversarial training. stat, 1050:25, 2015.   
+Anh Nguyen, Jason Yosinski, and Jeff Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 427–436. IEEE, 2015.   
+Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. arXiv preprint arXiv:1511.04508, 2015.
+
+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, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. arXiv preprint arXiv:1602.02697, 2016b.
+
+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, 2016c.
+
+Sara Sabour, Yanshuai Cao, Fartash Faghri, and David J Fleet. Adversarial manipulation of deep representations. arXiv preprint arXiv:1511.05122, 2015.
+
+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.
+
+Pedro Tabacof and Eduardo Valle. Exploring the space of adversarial images. arXiv preprint arXiv:1510.05328, 2015.
+
+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.
+
+Yevgeniy Vorobeychik and Bo Li. Optimal randomized classification in adversarial settings. In Proceedings of the 2014 international conference on Autonomous agents and multi-agent systems, pp. 485–492. International Foundation for Autonomous Agents and Multiagent Systems, 2014.
+
+Stephan Zheng, Yang Song, Thomas Leung, and Ian Goodfellow. Improving the robustness of deep neural networks via stability training. arXiv preprint arXiv:1604.04326, 2016.

parse/train/ByToKu9ll/ByToKu9ll_content_list.json

@@ -0,0 +1,1188 @@
+[
+    {
+        "type": "text",
+        "text": "EVALUATION OF DEFENSIVE METHODS FOR DNNS AGAINST MULTIPLE ADVERSARIAL EVASION MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xinyun Chen Shanghai Jiao Tong University jungyhuk@gmail.com ",
+        "bbox": [
+            184,
+            170,
+            387,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Bo Li University of Michigan bbbli@umich.edu ",
+        "bbox": [
+            660,
+            170,
+            813,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yevgeniy Vorobeychik   \nVanderbilt University   \nyevgeniy.vorobeychik@vanderbilt.edu ",
+        "bbox": [
+            183,
+            233,
+            527,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            313,
+            544,
+            327
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Due to deep cascades of nonlinear units, deep neural networks (DNNs) can automatically learn non-local generalization priors from data and have achieved high performance in various applications. However, such properties have also opened a door for adversaries to generate the so-called adversarial examples to fool DNNs. Specifically, adversaries can inject small perturbations to the input data and therefore decrease the performance of deep neural networks significantly. Even worse, these adversarial examples have the transferability to attack a black-box model based on finite queries without knowledge of the target model. Therefore, we aim to empirically compare different defensive strategies against various adversary models and analyze the cross-model efficiency for these robust learners. We conclude that the adversarial retraining framework also has the transferability, which can defend adversarial examples without requiring prior knowledge of the adversary models. We compare the general adversarial retraining framework with the state-of-the-art robust deep neural networks, such as distillation, autoencoder stacked with classifier (AEC), and our improved version, IAEC, to evaluate their robustness as well as the vulnerability in terms of the distortion required to mislead the learner. Our experimental results show that the adversarial retraining framework can defend most of the adversarial examples notably and consistently without adding additional vulnerabilities or performance penalty to the original model. ",
+        "bbox": [
+            233,
+            340,
+            764,
+            618
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            642,
+            336,
+            657
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite the success of deep neural networks (DNNs) in diverse areas, ranging from image recognition and machine translation to autonomous driving, its vulnerabilities have been exploited in the adversarial environments. Evasion attacks against such deep learning systems have recently received considerable attention. It has been shown that with small magnitude of noise added, the original instance can easily be misclassified by the otherwise accurate deep neural networks (Goodfellow et al., 2014; Papernot et al., 2016c; Nguyen et al., 2015; Szegedy et al., 2013). Such instances are also called adversarial examples. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            770
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Given the strong evasion properties of these adversarial examples, some works have been proposed to test and investigate the robustness of the deep neural networks against the adversarial examples (Goodfellow et al., 2014; Kurakin et al., 2016; Huang et al., 2015; Gu & Rigazio, 2014; Jin et al., 2015). However, most of the existing works only evaluate the robustness of the proposed defense strategies over adversarial examples generated using a single attack method, or several similar methods. Meanwhile, since the evaluated adversary models, i.e., adversarial example generation methods, vary among different works that study the effectiveness of defense strategies, it remains a question how to make a comparison among different defense strategies. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we focus on providing thorough analysis for different algorithmic strategic defensive learners against various adversary models considering their robustness against adversarial examples, efficiency for cross-model learning process, resilience against additional attacks, and the vulnerabilities of these learners. Here by “cross-model test”, we mean to apply one adversarial model to generate adversarial examples, while test them on the learner trained with instances generated from different adversarial models. High “cross-model test” accuracy indicates higher robustness for learner. In addition, we propose to test the “additional attacks” in a repeated game setting to estimate learner based on against further attacks. A nice symmetry analysis for both the adversary and learner is provided through these analyses. We show that the general adversarial retraining framework performs significantly robust compared with the state-of-the-art defensive algorithms. For example, even for the black box attack, which is considered hard to defend, as long as there is a way to generate these adversarial evasion examples, the robust adversarial retraining framework can always improve the learning ability without knowing the actual adversary model. To our best knowledge, this work is the first to provide comprehensive analysis for different adversarial models and possible defensive solutions. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            284
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, we made the following contributions: ",
+        "bbox": [
+            174,
+            291,
+            503,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. Evaluate the robustness of the general robust adversarial retraining framework $( R A D )$ with the state-of-the-art AEC, Distillation, and the improved AEC, against different adversary models;   \n2. Propose an improved AutoEncoder stacked with Classifier (IAEC);   \n3. Compare the cross-model learning efficiency of different defensive methods and demonstrate the ability to defend against black-box attacks;   \n4. Demonstrate the robustness of the retraining framework RAD, AEC, IAEC, and Distillation, against new attacks by attacking these robust learners repeatedly;   \n5. Analyze the vulnerabilities induced by different defensive strategies/models based on their tolerance of the malicious distortions required to mislead the classifier. ",
+        "bbox": [
+            210,
+            318,
+            825,
+            481
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We illustrate the applicability and efficiency of different defensive strategies against various stateof-the-art adversary models based on both MNIST and CIFAR-10 datasets. ",
+        "bbox": [
+            174,
+            493,
+            823,
+            522
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            542,
+            344,
+            559
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Efforts have been made to understand adversarial examples. Goodfellow et al. (2014) pointed out that the adversarial examples actually make use of the linear nature of the DNNs based on the observation of their generalization across architectures and training sets. Tabacof & Valle (2015) analyzed the adversarial image space and showed that adversarial images appear in large regions in the pixel space. Papernot et al. (2016c) studied the limitation of adversarial evasion examples and showed that some instances are more difficult to manipulate than the others. Sabour et al. (2015) demonstrated that the attacker can change classification to an arbitrary class by malicious manipulations. The reverse engineering problem has been proposed in Vorobeychik & Li (2014), and it theoretically proved that the black-box attack is possible and also showed one could learn a sufficiently similar classifier from queries both theoretically and empirically. Similarly, even without knowing exactly the learning algorithm, several black-box attacks have been proposed targeting DNNs, which demonstrates the transferability of such adversarial examples (Papernot et al., 2016a;b). ",
+        "bbox": [
+            174,
+            575,
+            825,
+            742
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Some training methods have been proposed to improve the robustness of deep neural networks. Jan et al. (2002) has proposed to explore the perturbed regions and apply ensemble method to enhance the robustness of classification. Zheng et al. have proposed to stabilize the state-of-the-art Inception architecture against different distortions, and it focuses on general random noise or distortions, such as compression, rescaling and cropping on images Zheng et al. (2016). Miyato et al. (2015) have proposed to apply the local distribution smoothness for statistical model to promote the smoothness of the model distribution and conduct the virtual adversarial training to enhance the performance of deep neural networks. However, all these works did not test on the adversarial examples and still had a long way to perform robustly against these real adversarial instances. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While the existence of adversarial examples is attracting more and more attention, some defense strategies have been proposed to defend against such adversarial examples. In Goodfellow et al. (2014), Goodfellow et al. proposed to train the network with an adversarial objective function based on fast gradient sign method: $\\tilde { J } ( \\theta , x , y ) = \\alpha J ( \\theta , x , y ) + ( 1 - \\alpha ) J ( \\theta , x + \\nabla _ { x } J ( \\theta , x , y ) , y )$ . In a concurrent and independent work, Kurakin et al. provided an adversarial training method for a large scale dataset, i.e., ImageNet dataset Kurakin et al. (2016). However, they only used fast gradient sign-based methods to generate adversarial examples for both training and evaluation, which fails to consider the generality of defensive strategy. Huang et al. Huang et al. (2015) proposed an alternative method for adversarial training by considering an empirically stronger adversary. In their work, suppose $r ^ { \\star }$ is the optimal adversarial perturbation for an instance $( x , y )$ , instead of adding $( x + r ^ { \\star } , y )$ into the training dataset, they used “pseudo-samples” for training controlled by a hyperparameter $c$ , which represents the magnitude of perturbation, i.e., $\\begin{array} { r } { ( x + c \\frac { r ^ { \\star } } { | | r ^ { \\star } | | } , y ) } \\end{array}$ . Several autoencoder structures Vincent et al. (2008) have been proposed against the adversarial examples by reconstructing the original images ahead of classification Gu & Rigazio (2014). Jin et al. have proposed a feedforward CNN structure to improve the robustness in the presence of adversarial noise, which is restricted to the specific type of models in Jin et al. (2015). However, the focus of these researches perform too aggressively on designing robust learning algorithms against arbitrary small perturbations (e.g., noise) neglecting the properties of actual adversarial evasion models. Therefore, studying various adversarial models and building resilient learners accordingly is important. Here we will provide comparisons for defensive algorithms facing different adversarial models to provide insights and encourage devising more efficient learner. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            102,
+            825,
+            358
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PROBLEM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            377,
+            287,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To understand the phenomenon of adversarial examples in deep neural networks, we aim to analyze potential defending methods against different adversary models from various perspectives, such as the robustness of the learner itself, the cross-model generalization ability, the resilience against additional attacks, and the vulnerabilities in terms of the required distortion to attack the robust learner again. Let $X \\subseteq R ^ { n }$ represent the feature space, with $n$ the number of features. For every instance $x _ { i } \\in X$ , which is drawn from certain distribution $x _ { i } \\sim D$ , there is a corresponding label $y _ { i } \\in \\mathcal { V }$ to comprise the data pair $( x _ { i } , y _ { i } )$ , where $x _ { i j }$ denotes the $j$ th feature of $x _ { i }$ . ",
+        "bbox": [
+            174,
+            409,
+            825,
+            507
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the adversarial environments, adversary would like to accomplish the goal of evading the classifier. To formalize, suppose that $M \\subseteq \\mathcal { V }$ is a set of labels which an adversary wishes to attack, and let $z ( m )$ be the target label for each $m \\in M$ . For example, for autonomous driving, potential adversaries may aim to manipulate a stop sign or a dead-end warning sign, to a lamppost, a tree, or an advertisement sign, to cause accidents. Since such perturbations on images towards deep neural networks are often imperceptible to human eyes, it can cause serious vulnerabilities when deploying the DNNs in real adversarial environments. The defender’s goal is to learn a classifier with parameters $w$ , $g _ { w } : x _ { i } \\to \\mathcal { V }$ , using a training data set of labeled instance $T = \\{ ( x _ { 1 } , y _ { 1 } ) , . . . , ( x _ { m } , \\bar { y } _ { m } ) \\}$ . Here, we focus on deep neural networks representing the function $g _ { w } ( \\cdot )$ . Therefore, the learner’s objective is to minimize the following general loss function: ",
+        "bbox": [
+            173,
+            512,
+            825,
+            652
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3fd81f10de28d48a813382f97c33f2a98c41ae41727107d2aab79ed636de356a.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { w } \\mathcal { L } ( w ; \\mathcal { A } ) = \\sum _ { \\substack { i : y _ { i } \\in \\mathcal { Y } \\backslash M } } l ( g _ { w } ( x _ { i } ) , y _ { i } ) + \\sum _ { \\substack { i : y _ { i } \\in M } } l ( g _ { w } ( \\mathcal { A } ( w , x _ { i } ) , y _ { i } ) + \\alpha \\| w \\| _ { p } ^ { p } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            656,
+            756,
+            693
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $l ( \\cdot )$ can be arbitrary loss function and $\\mathcal { A }$ represents the adversary model. ",
+        "bbox": [
+            174,
+            698,
+            691,
+            713
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The adversarial risk function in Equation 1 is general: it can be any adversary model oracle, $\\mathcal { A }$ , which is used to generate the adversarial evasion instances. Traditionally, this adversarial oracle may capture evasion attack models based on minimizing evasion cost (Lowd & Meek, 2005; Li & Vorobeychik, 2014; Biggio et al., 2014), or based on actual attacker evasion behavior obtained from experimental data (Ke et al., 2016). More formally, we will discuss the potential adversary models for deep neural networks and the possible defensive models for the learner in detail below. ",
+        "bbox": [
+            173,
+            719,
+            825,
+            804
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 ADVERSARY MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            820,
+            357,
+            834
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To mislead deep neural networks, various methods have been proposed to generate the adversarial examples. We mainly discuss three state-of-the-art adversary models $\\mathcal { A }$ here for further evaluation. ",
+        "bbox": [
+            174,
+            845,
+            823,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Fast Gradient Sign. Based on the linear view of adversarial examples, a fast way of generating these adversarial examples were proposed in Goodfellow et al. (2014). Suppose $x _ { i }$ is the original feature vector, based on adversary model $\\mathcal { A } ( f g s )$ , we have ${ x _ { i } } ^ { \\prime } = x _ { i } + \\eta$ , where $\\eta$ represents the perturbation ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "added for the original instance. Therefore, the dot product between the weighted parameter vector $w$ and an adversarial example ${ x } _ { i } ^ { \\prime }$ becomes: ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d0a7eca0b1a54caede9d6a214ee5d5bcdc8076c5c0a48a4221b682b432a9c937.jpg",
+        "text": "$$\nw ^ { T } x _ { i } { ' } = w ^ { T } x _ { i } + w ^ { T } \\eta .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            418,
+            138,
+            578,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let ${ \\cal J } ( w , x _ { i } , y _ { i } )$ be the cost used to train the neural network. By linearizing the cost function around the current value of $w$ , an optimal max-norm constrained perturbation is generated as ",
+        "bbox": [
+            169,
+            165,
+            823,
+            194
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d7b2edf1f2e37dfbac80239f931be8a186de8f845b81d36a5b3e165febbd4bd9.jpg",
+        "text": "$$\n\\eta = \\mathrm { { \\epsilon s i g n } } { \\left( \\nabla _ { x } J ( w , x _ { i } , y _ { i } ) \\right) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            202,
+            589,
+            219
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the adversary can vary $\\epsilon$ to generate adversarial examples with different attacking abilities for different deep neural networks. ",
+        "bbox": [
+            171,
+            227,
+            823,
+            255
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Coordinate Greedy. Another more general adversary model $\\scriptstyle A ( c g )$ is the local search framework Coordinate Greedy (cg) proposed in Li et al. (2016) for approximating the optimal adversarial instance. As an illustration, we focus on binary classification, and assume that $\\operatorname { \\dot { \\phantom { } } g } _ { w } ( x ) = \\operatorname { s i g n } ( f ( x ) )$ for some continuous function $f$ , which in this case would be represented by a deep neural network. ",
+        "bbox": [
+            174,
+            261,
+            825,
+            319
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The coordinate greedy approach is quite general, but we consider a specific adversary objective in which the adversary here tries to balance between two considerations: 1) appear as benign as possible to the classifier, and 2) minimize the cost of modification of the original instance (e.g., minimally manipulate the image). Note that it is also natural to assume that the attacker obtains no value from a manipulation to the original feature vector if the result is still classified as malicious. Therefore, an adversary aiming to transform an instance $x _ { i }$ into an adversarial example $x _ { i } { } ^ { \\prime }$ is solving the following optimization problem: ",
+        "bbox": [
+            173,
+            324,
+            825,
+            422
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8c2f64329f025f5b8122ab37d10ffb6425b0a5cac9ed5a33ea371bbe18784cee.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { { x _ { i } } ^ { \\prime } \\in X } \\operatorname* { m i n } \\{ 0 , f ( { x _ { i } } ^ { \\prime } ) \\} + c ( { x _ { i } } ^ { \\prime } , { x _ { i } } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            429,
+            612,
+            454
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $c ( x _ { i } ^ { \\prime } , x _ { i } )$ is the cost function of modifying from $x _ { i }$ to ${ x } _ { i } ^ { \\prime }$ . Here $c ( x _ { i } ^ { \\prime } , x _ { i } ) \\geq 0$ , $c ( x _ { i } ^ { \\prime } , x _ { i } ) = 0$ iff $x _ { i } { ' } = x _ { i }$ , and the cost function $c$ is strictly increasing in $\\| { x } _ { i } ^ { \\prime } - { x } _ { i } \\| _ { 2 }$ and strictly convex in $x _ { i } { ' }$ . Because Problem 2 is non-convex, so the objective of adversary can be formed to minimize an upper bound: ",
+        "bbox": [
+            173,
+            462,
+            825,
+            517
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7db4b0995ba499aa08ace278969b50a9f81a317ff43ccedcb88e4425838c4805.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { { x _ { i } } ^ { \\prime } } Q ( x _ { i } { ' } ) \\equiv f ( x _ { i } { ' } ) + c ( x _ { i } { ' } , x _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            517,
+            612,
+            541
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "So the high-level idea of $c g$ is to iteratively choose a feature, and greedily update this feature according to the partial derivatives of the attacker’s objective as 3 to evade the classifier. Below, we take the exponential cost function $c ( x _ { i } { ' } , x _ { i } ) = \\mathrm { e x p } \\left( \\lambda ( \\sum _ { j } ( x _ { i j } { ' } - x _ { i j } ) ^ { 2 } + 1 ) ^ { 1 / 2 } \\right)$ as an example to estimate the modification cost, which is also quite natural: options become exponentially less desirable to an attacker as they are more distant from their ideal attack. Then we take the following partial derivative to update the adversary’s objective until the convergence. ",
+        "bbox": [
+            173,
+            553,
+            825,
+            646
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/af1a40ec4312ad8c91b999e98c25b77cbdd0cd25f8890b6493cf75779d8eacd1.jpg",
+        "text": "$$\n\\frac { \\partial Q ( x _ { i } { ' } ) } { \\partial x _ { i j } } = \\frac { \\partial f ( x _ { i } { ' } ) } { \\partial x _ { i j } } + \\frac { \\partial c ( x _ { i } { ' } , x _ { i } ) } { \\partial x _ { i j } } = \\frac { \\partial f ( x _ { i } { ' } ) } { \\partial x _ { i j } } + \\frac { \\lambda c ( x _ { i } { ' } , x _ { i } ) ( x _ { i j } { ' } - x _ { i j } ) } { ( \\sum _ { j } ( x _ { i j } { ' } - x _ { i j } ) ^ { 2 } + 1 ) ^ { 1 / 2 } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            652,
+            753,
+            690
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To avoid the algorithm converges only to a locally optimal solution, random restarts strategy is applied to randomly select the starting points in the feature space. As long as a global optimum has a basin of attraction with positive Lebesgue measure, or the feature space is finite, this process will asymptotically converge to a globally optimal solution with enough random restarts. ",
+        "bbox": [
+            174,
+            704,
+            823,
+            761
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Adam. Another adversary model $\\mathcal { A } ( a d a m )$ applies the stochastic gradient-based optimization algorithm Adam Kingma $\\&$ Ba (2014) to generate adversarial examples. Specifically, the adversary uses Adam to solve the same optimization problem as in Equation 3. ",
+        "bbox": [
+            174,
+            767,
+            825,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 DEFENDER MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            348,
+            842
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the possible adversary models, several defensive strategies have been proposed focusing on different perspectives. Basically, the learner tries to integrate the prior knowledge of either the adversary model or the data distribution with the classification process. Here we consider different defensive strategies given the adversary model and form the interaction as a Stackelberg game. We will also consider the repeated game setting in section 4.4. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Retraining framework $( R A D )$ . A systematic defensive approach based on adversarial retraining $( R A D )$ has been proposed in Li et al. (2016). At the high level, $R A D$ starts with the original training data and iteratively updating the learner with adversarial instances that evade the previously computed classifier until the convergence. It has been proved that the algorithm will terminate and the lower bound of the empirical loss of $R A D$ is also provided. The important part for $R A D$ is to select the adversarial retraining instances. In practice, it is hard to exactly estimate the adversary model as well as the parameters used within their model. Therefore, the generalization ability of $R A D$ across different adversary models is quite important. Surprisingly, $R A D$ generalizes quite well among various adversary models without requiring to know the exact attacker strategy. We will present the cross-model analysis for $R A D$ in details in section 4.3. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "AutoEncoder stacked with Classifier $( A E C )$ . One of the recent and efficient defensive method is the AutoEncoder stacked with a classifier to initialize deep architectures proposed in Gu & Rigazio (2014). To assess the structure of the adversarial noise, an autoencoder on mapping adversarial examples back to the original data samples is trained and stacked with the classifier. We train the AutoEncoder with different adversarial algorithms, including the fast gradient sign method $( f g s )$ , the coordinate greedy $( c g )$ method, as well as Adam. ",
+        "bbox": [
+            173,
+            250,
+            825,
+            333
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Improved AutoEncoder stacked with Classifier (IAEC). Since the baseline $A E C$ cannot perform very well by only mapping the adversarial images back to the original image, we apply an improved AutoEncoder stacked with classifier (IAEC) defensive method. As AutoEncoder itself can not ensure that adversarial examples are denoised, we add a cross-entropy regularizer term as the loss function to help ensure that the output of AutoEncoder is classified correctly. Let $y _ { i }$ be the one-hot representation of ground truth label of an input instance $x _ { i }$ , then our loss function becomes: ",
+        "bbox": [
+            173,
+            339,
+            825,
+            424
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/65a33cfab3cd900ea3e5e31a6af13c03243dd0f209cdc21d2152fb5f054ac31c.jpg",
+        "text": "$$\nJ ( x _ { i } ) = \\| s ( x _ { i } ) - { x _ { i } } ^ { \\prime } \\| + H ( y _ { i } , f ( x _ { i } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            433,
+            629,
+            450
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $s ( x _ { i } )$ represents the mapping result of $x _ { i }$ by the AutoEncoder, and the cross-entropy function $H ( y _ { i } , f ( x _ { i } ) ) \\stackrel { - } { = } - \\sum _ { x _ { i } } y _ { i } \\log f ( \\stackrel { - } { x _ { i } } )$ . ",
+        "bbox": [
+            176,
+            459,
+            823,
+            491
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Distillation. Considering the fact that the knowledge extracted during training, which is in the form of probability vectors, and transferred in smaller networks to maintain accuracy comparable with those of larger networks can also be beneficial to improving generalization capabilities of deep neural networks outside of their training dataset, a defensive strategy against the adversarial examples has been proposed in Papernot et al. (2015). This defensive strategy transfers the knowledge contained in probability vectors through the distillation training step, then applies these probabilities in the next training step instead of using the original hard labels, and therefore enhances its resilience to perturbations. This defensive model is independent of the adversary models and we will evaluate its robustness and vulnerabilities in details in section 4. ",
+        "bbox": [
+            173,
+            503,
+            825,
+            630
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            654,
+            428,
+            669
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we empirically compare the adversarial retraining framework $R A D$ with other stateof-the-art baseline methods Distillation Papernot et al. (2015), AutoEncoder stacked with Classifier (AEC) Gu & Rigazio (2014) and our improved AutoEncoder stacked with Classifier (IAEC) against various adversary models based on both MNIST and CIFAR-10 datasets. ",
+        "bbox": [
+            174,
+            686,
+            823,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Basically, we first analyze the robustness of $R A D$ and Distillation, which performs the best against adversarial examples currently, by comparing the classification results before and after applying the adversarial retraining technique based on both MNIST and CIFAR-10 datasets. Then we estimate the cross-model classification robustness for $R A D , A E C$ , the improved IAEC, and Distillation. Precisely, during the cross-model evaluation, we allow the attacker to generate the adversarial examples with different adversarial algorithms, while the defender has no clue about what adversarial algorithm is used. Therefore, we are able to evaluate the resilience of the “black-box” defensive strategies without requiring to know the actual adversary model. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Besides, we allow the attacker to attack these robustly enhanced learners and we compare the resilience of the $R A D$ with the baseline defensive models and show that with retraining instances generated by adam, the $R A D$ is almost unassailable for attacks based on the fast gradient sign method, which is promising to design universal defensive algorithms based on $R A D$ . ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Additionally, another perspective to measure the robustness of the learners is to evaluate how much noise is needed to make the learner misclassify an otherwise correct instance. As pointed out by $\\mathrm { G u }$ & Rigazio (2014), even a learner can be demonstrated to perform robustly against certain adversarial examples, it may become more vulnerable in the sense of being attacked by adding much smaller magnitude of adversarial noise. This means increasing the noticeability of the smallest adversarial noise for each example becomes the key to solve the adversarial examples problem. Therefore, we compare the malicious distortion required to attack each model, aiming to evaluate the vulnerability of different learners. The distortion is measured by $\\begin{array} { r } { d ( x _ { i } ^ { \\prime } , x _ { i } ) = \\frac { 1 } { n } \\sqrt { \\sum ( x _ { i } ^ { \\prime } - x _ { i } ) ^ { 2 } } } \\end{array}$ , where $x _ { i } ^ { \\prime } =$ $\\mathcal { A } ( \\beta , x _ { i } )$ representing the adversarial manipulated instance based on arbitrary adversary model $\\mathcal { A }$ . ",
+        "bbox": [
+            174,
+            103,
+            825,
+            231
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            248,
+            375,
+            262
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we focus on binary classification, and the adversary tries to modify a malicious instance (classified as $+ 1$ ) to evade the classifier and be classified as benign (-1). On MNIST, we select digit $\" 4 \"$ as the malicious (positive) class, and $\" 7 \"$ as the benign (negative) class. On CIFAR10, we use “Airplane” as the malicious class, and “Cat” as the benign class. We use LeNet-5 LeCun et al. (1998) to perform the binary classification, and all classifiers used to evaluate the efficiency of different adversary models and defender models are based on this model architecture. All input pixel values are normalized into $[ - 0 . 5 , 0 . 5 ]$ . ",
+        "bbox": [
+            173,
+            273,
+            825,
+            372
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With respect to adversary models, during the evaluation, all of them modify the malicious instances in the original testset to evade the classifier, and keep the benign instances untouched. Meanwhile, for iterative attack methods evaluated in our experiments, i.e., $c g$ and adam, according to our experiments, actually we can find adversarial examples with small modification cost using any $\\lambda$ , even when setting $\\lambda = 0$ , i.e., not considering the cost function $c ( x _ { i } ^ { \\prime } , x _ { i } )$ for optimization. Therefore, we set $\\lambda = 0$ for all experiments using these two attack methods. ",
+        "bbox": [
+            174,
+            378,
+            825,
+            463
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With respect to defensive models, for RAD, we only add adversarial examples generated on original malicious instances into the dataset for retraining, since the goal of adversary is trying to fool a classifier to label a malicious instance as benign, which follows the framework proposed in Li et al. (2016). As for AEC and IAEC, we use the same autoencoder architecture for removing adversarial noises proposed in Gu & Rigazio (2014), i.e., a three-hidden-layer autoencoder (784-256-128-256- 784 neurons). We train the autoencoder to map adversarial examples generated on original malicious instances to the original images, and as suggested in Gu & Rigazio (2014), we also train the autoencoder to map original data back to itself. Both AEC and IAEC stack the autoencoder with a LeNet-5 classifier. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            594
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 ROBUSTNESS ANALYSIS FOR DEFENSIVE LEARNERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            613,
+            580,
+            627
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the robustness and efficiency of the adversarial retraining framework and other defensive learners, we generate adversarial examples based on the the coordinate gradient algorithm $( c g )$ , adam, and the fast gradient sign algorithm $( f g s _ { \\epsilon } )$ with the size of perturbation $\\epsilon = 0 . 1 \\sim 0 . 5$ ( Goodfellow et al. (2014)), respectively. Figure 1 shows the analysis of recall for the traditional LeNet-5 and the robust $R A D$ classifiers on MNIST. The test error of LeNet-5 on the original dataset is $0 . 0 4 5 \\%$ . It is obvious that after the adversarial retraining process based on $R A D$ , the classifiers perform nearly optimal. It is interesting to observe that with the $\\epsilon$ of fgs increases, the adversarial examples generated by fgs can attack the original LeNet-5 more efficiently. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            750
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 presents the comparisons of recall for the original LeNet-5 and the adversarial retraining framework on CIFAR-10. It shows that the adversarial retraining framework works robustly against different adversarial example generation methods. Note the test error of LeNet-5 on the original dataset is $5 . 5 \\%$ . From the results of recall, we can see that almost all the “generated” adversarial instances are correctly classified by the retraining framework. Additionally, sometimes the test error of $R A D$ is even smaller than that of the original model LeNet-5 based on the uncontaminated (no adversary) data. This means, with the adversarial robust retraining process, some “blind-spots” in the input space volume can be filled out without decreasing the performance on the normal test data. Moreover, surprisingly, with the increase of $\\epsilon$ , the fast gradient sign method works worse for generating adversarial examples against LeNet-5, which is different for MNIST. This is actually caused by the properties of the fast gradient sign method itself. By following the gradient, the generated instance can be trapped into sub-optimal and therefore fail to converge to the global optima, so different step size can affect their final convergence. Therefore, by comparing with the results of MNIST, we can see learners on CIFAR-10 is easier to be trapped by the sub-optima and larger $\\epsilon$ values can lead the learner to be trapped into these points with higher probability. On the other hand, no matter how much the strength of adversarial ability is affected by different parameters, the adversarial retraining framework works robustly by almost identifying all the manipulated instances correctly on different datasets consistently. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/ecbb64d765a0fe57f02c698626b68671c5333bbab455fe193a120384ed7fbfa2.jpg",
+        "image_caption": [
+            "Figure 1: Performance of retraining with instances generated from different models based on MNIST. (a) The retraining instances are generated by $c g$ ; (b) the adversarial examples are generated by $c g$ ; (c) the adversarial examples are generated by adam. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            108,
+            797,
+            231
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e320c714385bad3ae3f2ab6cf42a6d7f02a12f22f4fca741093ab95b014ae22c.jpg",
+        "image_caption": [
+            "Figure 2: Performance of retraining with instances generated from different models based on CIFAR-10. (a) The retraining instances are generated by CG; (b) the adversarial examples are generated by CG; (c) the adversarial examples are generated by adam. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            299,
+            795,
+            422
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            497,
+            825,
+            580
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": ".3 CROSS-MODEL ANALYSIS FOR DIFFERENT DEFENSIVE LEARNERS ",
+        "text_level": 1,
+        "bbox": [
+            187,
+            606,
+            660,
+            617
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Aiming to defend a more broad class of attacks, here we assume the the learner has no clue about which adversarial algorithm the attacker uses to generate the adversarial instances. Therefore, the defender can perform robustly as the “black-box” learner against arbitrary adversaries. Here we use different attack algorithms to generate the adversarial examples, and the retraining instances for $R A D$ are also generated across various adversary models to evaluate the learners’ generalization ability. We also compare the results with the state-of-the-art Distillation, $A E C$ and our improved $I A E C$ algorithm based on different adversarial models. Here the $A E C$ is trained on the adam model, which offers the best classification results. The IAEC is also trained corresponding to different adversary models to compare the cross-model learning ability with RAD. Table 1 shows the test error comparisons for these cross-model learners. “No adversary” presents the test error of different learners on the clean data. Basically, the adversarial retraining framework performs consistently better than AEC, IAEC, and Distillation on all different adversarial examples in terms of the classification error. This conclusion is independent of what models are used to generate adversarial retraining instances for RAD. Based on the results, the adversarial retraining framework has the potential to be applied to defend against any arbitrary attacks without requiring to know the exact adversary model. Based on the classification error results for our improved IAEC in Table 1, it is obvious that the $I A E C$ with the same adam adversary model works much more robust than AEC. This means the proposed $I A E C$ is much more robust compared with the original AEC by adding the cross-entropy regularization. Additionally, we also evaluate the cross-model classification error for $I A E C$ to test its generalization ability. Table 1 shows that the IAEC can also defend against different adversarial examples without requiring to know the exact adversary model. ",
+        "bbox": [
+            173,
+            632,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/da43a465faeca15f288172ae6ecffae2d4ea09a7b86f978d358fa11e17103d77.jpg",
+        "table_caption": [
+            "Table 1: Classification error of different learners against various adversary models based on MNIST "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>A(fgso.1)</td><td>A(fgs0.5)</td><td>A(cg)</td><td>A(adam)</td><td>No adversary</td></tr><tr><td>LeNet-5</td><td>1.2%</td><td>46.1%</td><td>48.2%</td><td>48.9%</td><td>0.045%</td></tr><tr><td>RAD(fgs0.1)</td><td>0.1%</td><td>0.5%</td><td>0.4%</td><td>3.0%</td><td>0.045%</td></tr><tr><td>RAD(fgs0.5)</td><td>0.5%</td><td>0.1%</td><td>0</td><td>2.5%</td><td>0.045%</td></tr><tr><td>RAD(cg)</td><td>0.1%</td><td>1.4%</td><td>0.4%</td><td>2.9%</td><td>0.045%</td></tr><tr><td>RAD(adam)</td><td>0</td><td>0.1%</td><td>0.1%</td><td>0.1%</td><td>0.045%</td></tr><tr><td>AEC(adam)</td><td>3.2%</td><td>20.6%</td><td>9.7%</td><td>2.6%</td><td>4.5%</td></tr><tr><td>IAEC(fgs0.1)</td><td>1.3%</td><td>28.0%</td><td>18.3%</td><td>9.6%</td><td>1.1%</td></tr><tr><td>IAEC(fgs0.5)</td><td>1.2%</td><td>1.4%</td><td>2.6%</td><td>5.5%</td><td>1.0%</td></tr><tr><td>IAEC(cg)</td><td>1.6%</td><td>1.6%</td><td>1.5%</td><td>7.4%</td><td>1.2%</td></tr><tr><td>IAEC(adam)</td><td>1.2%</td><td>5.2%</td><td>7.3%</td><td>2.3%</td><td>1.7%</td></tr><tr><td>Distillation(T = 1)</td><td>0.6%</td><td>47.2%</td><td>29.4%</td><td>41.9%</td><td>0.2%</td></tr><tr><td>Distillation(T = 100)</td><td>0.3%</td><td>42.3%</td><td>12.4%</td><td>28.5%</td><td>0.2%</td></tr></table>",
+        "bbox": [
+            202,
+            127,
+            795,
+            321
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Similarly, we show the classification error comparison results of $R A D$ across different adversary models in Table 2 compared with Distillation. As CIFAR-10 images are more complex, the error rates for adversarial retraining framework get larger compared with that on MNIST. However, overall the classification error for the retraining framework on different adversarial examples are below $13 \\%$ with zero knowledge of the adversary model, while the classification error on normal data is around $6 \\%$ . Therefore, even on CIFAR-10 dataset, the adversarial retraining framework is still promising to perform the “black-box” defending resiliently against various attacks. Additionally, the distillation with $T = 1$ and $T = 1 0 0$ both encounter higher test error than $R A D$ , even the distillation method performs more robustly when $T = 1 0 0$ than $T = 1$ . ",
+        "bbox": [
+            173,
+            349,
+            825,
+            474
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/2f6e878b9db38e2c06e9bfec75696c98ea7f3b51772dc1cad05531b0238a93df.jpg",
+        "table_caption": [
+            "Table 2: Comparisons for the error rate of $R A D$ based on different adversary models on CIFAR-10 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>A(fgso.1)</td><td>A(fgs0.5)</td><td>A(cg)</td><td>A(adam)</td><td>No adversary</td></tr><tr><td>LeNet-5</td><td>1.2%</td><td>46.1%</td><td>54.0%</td><td>52.7%</td><td>5.5%</td></tr><tr><td>RAD(fgso.1)</td><td>2.35%</td><td>2.0%</td><td>4.65%</td><td>3.0%</td><td>5.3%</td></tr><tr><td>RAD(fgs0.5)</td><td>4.4%</td><td>2.7%</td><td>5.6%</td><td>2.6%</td><td>5.8%</td></tr><tr><td>RAD(cg)</td><td>7.5%</td><td>2.45%</td><td>5.05%</td><td>2.2%</td><td>5.7%</td></tr><tr><td>RAD(adam)</td><td>16.2%</td><td>2.8%</td><td>6.15%</td><td>2.4%</td><td>5.9%</td></tr><tr><td>Distillation(T =1)</td><td>21.3%</td><td>30.8%</td><td>13.8%</td><td>22.0%</td><td>11.0%</td></tr><tr><td>Distillation(T = 100)</td><td>19.3%</td><td>25.2%</td><td>9.2%</td><td>20.2%</td><td>7.2%</td></tr></table>",
+        "bbox": [
+            200,
+            515,
+            797,
+            641
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 ROBUSTNESS AGAINST ADDITIONAL ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            667,
+            539,
+            683
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to test the robustness of the learner against the repeated attacks, where the attacker can again conduct attacks on the robust learners, here we evaluate how the robust learner behaves given additional attacks based on different adversary models. Table 3 presents the test error rate comparison when the attacker generates adversarial examples to attack the robust $R A D$ learner, $I A E C$ , and Distillation on MNIST. It is shown that the coordinate greedy $( c g )$ and adam are somehow efficient to attack $R A D$ , while the fast gradient sign methods fail to attack the robust $R A D$ . So if the $R A D$ is retrained with instances generated by arbitrary adversary models, it can be resilient against adversarial examples produced by the fast gradient sign method with various $\\epsilon$ values. This means the $R A D$ can confer robustness to single-step attack methods but not the iterative ones. However, adversaries based on $c g$ and adam can still find the vulnerabilities to attack the model. Compared with the performance of the adversarial retraining framework $( R A D )$ against these “repeated attacks”, the $I A E C$ encounters much higher classification error when being attacked. This indicates that the adversarial retraining framework can not only enhance the resilience of the original learner (LeNet-5), but also perform robustly against the additional attacks compared with the IAEC. ",
+        "bbox": [
+            173,
+            694,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Similarly, Table 4 presents the test error for attacking different robust learners with various adversary models on CIFAR-10. RAD again produces lower test error compared with Distillation $T = 1$ ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e7b570ba8d4f71e52316712107388d1234046f3378e4e25807f943aea20c14b7.jpg",
+        "table_caption": [
+            "Table 3: Error rate of attacking the robust learners with additional attacks on MNIST "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>A(fgs0.1)</td><td>A(fgs0.5)</td><td>A(cg)</td><td>A(adam)</td></tr><tr><td>RAD(fgs0.1)</td><td>0.3%</td><td>9.6%</td><td>48.1%</td><td>49.0%</td></tr><tr><td>RAD(fgs0.5)</td><td>0.8%</td><td>0.1%</td><td>45.7%</td><td>49.0%</td></tr><tr><td>RAD(cg)</td><td>0.8%</td><td>3.4%</td><td>44.6%</td><td>49.0%</td></tr><tr><td>RAD(adam)</td><td>0.1%</td><td>0.1%</td><td>40.2%</td><td>48.7%</td></tr><tr><td>IAEC(fgs0.1)</td><td>4.2%</td><td>10.3%</td><td>49.9%</td><td>49.5%</td></tr><tr><td>IAEC(fgs0.5)</td><td>5.2%</td><td>3.8%</td><td>49.8%</td><td>49.9%</td></tr><tr><td>IAEC(cg)</td><td>5.3%</td><td>3.9%</td><td>49.9%</td><td>49.4%</td></tr><tr><td>IAEC(adam)</td><td>4.6%</td><td>7.0%</td><td>49.9%</td><td>49.9%</td></tr><tr><td>Distillation(T = 100)</td><td>0.2%</td><td>0.2%</td><td>49.0%</td><td>48.7%</td></tr></table>",
+        "bbox": [
+            256,
+            127,
+            743,
+            280
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/078ff2284118865a25e606a1fdb86e9a07626a058f85e108d28d23d06014279e.jpg",
+        "table_caption": [
+            "Table 4: Error rate of attacking the robust learners with additional attacks on CIFAR-10 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>A(fgso.1)</td><td>A(fgs0.5)</td><td>A(cg)</td><td>A(adam)</td></tr><tr><td>RAD(fgs0.1)</td><td>3.7%</td><td>2.7%</td><td>42.0%</td><td>52.7%</td></tr><tr><td>RAD(fgs0.5)</td><td>5.3%</td><td>2.8%</td><td>49.0%</td><td>52.4%</td></tr><tr><td>RAD(cg)</td><td>7.9%</td><td>2.8%</td><td>52.0%</td><td>52.7%</td></tr><tr><td>RAD(adam)</td><td>6.3%</td><td>3.1%</td><td>54.0%</td><td>52.7%</td></tr><tr><td>Distillation(T = 100)</td><td>9.05%</td><td>8.6%</td><td>54.0%</td><td>54.1%</td></tr></table>",
+        "bbox": [
+            254,
+            325,
+            743,
+            424
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "$T = 1 0 0 _ { , }$ ) given diverse adversarial attacking strategies. What is worth to mention is that these robust learners all perform accurately on the normal dataset without adversarial manipulation, which offers more potentials for the robust learners. ",
+        "bbox": [
+            176,
+            455,
+            823,
+            497
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 VULNERABILITY OF THE DEFENSIVE LEARNERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            521,
+            547,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Given the fact that the attacker can attack the learning model continuously, here we are concerned with how vulnerable the robust models become in terms of the amount of distortion needed to add to mislead the learner. We compare the average distortion for attacking the LeNet-5, RAD, IAEC, and Distillation to evaluate their robustness. As mentioned by Gu & Rigazio (2014), AEC demands smaller distortion to attack, which means $A E C$ is quite fragile, and we also gain the similar observation and confirm that attacking the original LeNet-5 model requires larger magnitude of noise than $A E C$ . Thus, we focus on the improved IAEC. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            646
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the Table 5 we present the demanded distortion to maliciously attack the $R A D$ , the $I A E C$ , and Distillation on MNIST. Note that the fast gradient sign method here is a one-step method, which will stop after computing one gradient to find the optimal perturbation of a linear approximation of the cost or model, so it cannot guarantee to find the evasion instance $x _ { i } { ' }$ and we do not consider its distortion. so here we only consider $c g$ and adam to generate distortions. We use $R A D ( . )$ to represent the adversarial retraining framework retrained with arbitrary adversarial instances since they all require the same amount of distortion to be attacked given their similar network structures. From Table 5 RAD requires the same distortion as attacking the original LeNet-5 model. However, the distortion needed for attacking the $I A E C$ is substantially smaller than that for attacking the original models. From this perspective, the $I A E C$ becomes more vulnerable compared with the original model even though it can be resilient against the adversarial examples. Similar for Distillation, smaller distortion is demanded to attack the robust learner, which means more vulnerabilities are introduced by the robust Distillation. On the contrary, the adversarial retraining framework $R A D$ can perform robustly against various diverse adversarial attacks without increasing the vulnerability penalty. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            861
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows the results of adding the corresponding adversarial noise to generate the misclassification for LeNet-5 model by different adversarial algorithms qualitatively. It shows that by using fast gradient sign method with $\\epsilon = 0 . 5$ , the original image is almost distorted. This indicates different adversary models have different attacking strengths, so taking the stronger adversary model into account may have a chance to defend the weaker adversaries, which makes the universal defensive model promising. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/7d30c6ed6d0996206beafba39a7b6741e80c0463c5988246a1902b6e9c90a16b.jpg",
+        "table_caption": [
+            "Table 5: Adversarial distortion required for attacking different models on MNIST "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>A(cg)</td><td>A(adam)</td></tr><tr><td>LeNet-5</td><td>0.0118</td><td>0.0060</td></tr><tr><td>RAD(.)</td><td>0.0118</td><td>0.0060</td></tr><tr><td>IAEC(fgs0.1)</td><td>0.0042</td><td>0.0031</td></tr><tr><td>IAEC(fgs0.5)</td><td>0.0058</td><td>0.0028</td></tr><tr><td>IAEC(cg)</td><td>0.0069</td><td>0.0023</td></tr><tr><td>IAEC(adam)</td><td>0.0064</td><td>0.0029</td></tr><tr><td>Distillation(T = 100)</td><td>0.0106</td><td>0.0060</td></tr></table>",
+        "bbox": [
+            331,
+            128,
+            665,
+            253
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/e36b789f4ab07b2221ec4670e4bbee971f25978db217088dc30f0c7ab42011e2.jpg",
+        "image_caption": [
+            "Figure 3: Visualization of adversarial examples generated by different attacker models based on MNIST. (a) Original image, (b) attacked by $f g s _ { 0 . 1 }$ , (c) attacked by $f g s _ { 0 . 5 }$ , (d) attacked by $c g$ , (e) attacked by adam. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            277,
+            267,
+            715,
+            343
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            411,
+            823,
+            440
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Similarly, Table 6 lists the amount of distortion needed to fool the original learner based on CIFAR10. It is shown that both the $R A D$ and Distillation need exactly the same amount of distortion with the original LeNet-5 model, which means these robust learners do not increase the vulnerability of the original model. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            503
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/dc86053ae4aa37d84d9586d044b9048668e231b2663d20338834b5a812ada74a.jpg",
+        "table_caption": [
+            "Table 6: Adversarial distortion required for attacking different models on CIFAR-10 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>A(cg)</td><td>A(adam)</td></tr><tr><td>LeNet-5</td><td>0.0025</td><td>0.0015</td></tr><tr><td>RAD()</td><td>0.0025</td><td>0.0015</td></tr><tr><td>Distillation(T = 100)</td><td>0.0025</td><td>0.0015</td></tr></table>",
+        "bbox": [
+            331,
+            544,
+            665,
+            614
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The visual attacking results by injecting malicious noise are shown in Figure 4. It is clear that fgs with $\\epsilon = 0 . 5$ can distort the original images the most compared with other adversary algorithms. Surprisingly, all the retraining framework based on different retraining instances only get the classification error lower than $3 . 0 \\%$ . ",
+        "bbox": [
+            174,
+            628,
+            825,
+            685
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/643145ffcb53a9db029ccaa143ac7eb2d6ad866eb86272d7c02ebcb796762565.jpg",
+        "image_caption": [
+            "Figure 4: Visualization of adversarial examples generated by different attacker models based on CIFAR-10. (a) Original image, (b) attacked by $f g s _ { 0 . 1 }$ , (c) attacked by $f g s _ { 0 . 5 }$ , (d) attacked by $c g$ , (e) attacked by adam. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            299,
+            696,
+            692,
+            765
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            835,
+            318,
+            852
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To understand the adversarial examples better, as well as the potential adversary models and corresponding defensive learners, we conduct extensive experiments to evaluate properties of different defensive strategies. We point out that $R A D$ works the best among all the defensive strategies against different adversary models, including one-step and iterative ones, in terms of the classification test error. The adversarial retraining framework, RAD, also generalizes well for the cross-model evaluation compared with AEC, IAEC, and Distillation. Moreover, both $R A D$ and Distillation do not introduce additional vulnerability penalty to the original models, while still increase the robustness. So in the future work, to generalize the robust learner across different adversary models, one direction could be to generate retraining instances based on diverse adversarial algorithms to cover as much as possible the “blind-spots” within the input space. In addition, we will dynamically optimize the choice of adversary model and the quantity of retraining instances according to the robustness requirements of a specific learner. Therefore, the tradeoff between robustness and accuracy on the normal data can be balanced based on the specific resilience demand of the learner. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            228
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            251,
+            285,
+            265
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Battista Biggio, Giorgio Fumera, and Fabio Roli. Security evaluation of pattern classifiers under attack. Knowledge and Data Engineering, IEEE Transactions on, 26(4):984–996, 2014.   \nIan J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.   \nShixiang Gu and Luca Rigazio. Towards deep neural network architectures robust to adversarial examples. arXiv preprint arXiv:1412.5068, 2014.   \nRuitong Huang, Bing Xu, Dale Schuurmans, and Csaba Szepesvari. Learning with adversary. arXiv preprint arXiv:1511.03034, 2015.   \nJC Jan, Shih-Lin Hung, SY Chi, and JC Chern. Neural network forecast model in deep excavation. Journal of Computing in Civil Engineering, 16(1):59–65, 2002.   \nJonghoon Jin, Aysegul Dundar, and Eugenio Culurciello. Robust convolutional neural networks under adversarial noise. arXiv preprint arXiv:1511.06306, 2015.   \nLiyiming Ke, Bo Li, and Yevgeniy Vorobeychik. Behavioral experiments in email filter evasion. In AAAI Conference on Artificial Intelligence, 2016.   \nDiederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \nAlexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016.   \nYann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   \nBo Li and Yevgeniy Vorobeychik. Feature cross-substitution in adversarial classification. In Advances in Neural Information Processing Systems, pp. 2087–2095, 2014.   \nBo Li, Yevgeniy Vorobeychik, and Xinyun Chen. A general retraining framework for scalable adversarial classification. arXiv preprint arXiv:1604.02606, 2016.   \nDaniel Lowd and Christopher Meek. Adversarial learning. In Proceedings of the eleventh ACM SIGKDD international conference on Knowledge discovery in data mining, pp. 641–647. ACM, 2005.   \nTakeru Miyato, Shin-ichi Maeda, Masanori Koyama, Ken Nakae, and Shin Ishii. Distributional smoothing with virtual adversarial training. stat, 1050:25, 2015.   \nAnh Nguyen, Jason Yosinski, and Jeff Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 427–436. IEEE, 2015.   \nNicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. arXiv preprint arXiv:1511.04508, 2015. ",
+        "bbox": [
+            171,
+            273,
+            826,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. arXiv preprint arXiv:1602.02697, 2016b. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "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, 2016c. ",
+        "bbox": [
+            174,
+            207,
+            823,
+            250
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sara Sabour, Yanshuai Cao, Fartash Faghri, and David J Fleet. Adversarial manipulation of deep representations. arXiv preprint arXiv:1511.05122, 2015. ",
+        "bbox": [
+            173,
+            257,
+            823,
+            287
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            173,
+            295,
+            823,
+            325
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pedro Tabacof and Eduardo Valle. Exploring the space of adversarial images. arXiv preprint arXiv:1510.05328, 2015. ",
+        "bbox": [
+            173,
+            333,
+            823,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            173,
+            371,
+            823,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yevgeniy Vorobeychik and Bo Li. Optimal randomized classification in adversarial settings. In Proceedings of the 2014 international conference on Autonomous agents and multi-agent systems, pp. 485–492. International Foundation for Autonomous Agents and Multiagent Systems, 2014. ",
+        "bbox": [
+            176,
+            422,
+            823,
+            465
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stephan Zheng, Yang Song, Thomas Leung, and Ian Goodfellow. Improving the robustness of deep neural networks via stability training. arXiv preprint arXiv:1604.04326, 2016. ",
+        "bbox": [
+            174,
+            474,
+            823,
+            503
+        ],
+        "page_idx": 11
+    }
+]

parse/train/HkNKFiGex/HkNKFiGex.md

@@ -0,0 +1,260 @@
+# NEURAL PHOTO EDITING WITH INTROSPECTIVE AD-VERSARIAL NETWORKS
+
+Andrew Brock, Theodore Lim, & J.M. Ritchie
+
+# Nick Weston
+
+School of Engineering and Physical Sciences   
+Heriot-Watt University   
+Edinburgh, UK   
+{ajb5, t.lim, j.m.ritchie}@hw.ac.uk   
+Renishaw plc   
+Research Ave, North   
+Edinburgh, UK   
+Nick.Weston@renishaw.com
+
+# ABSTRACT
+
+The increasingly photorealistic sample quality of generative image models suggests their feasibility in applications beyond image generation. We present the Neural Photo Editor, an interface that leverages the power of generative neural networks to make large, semantically coherent changes to existing images. To tackle the challenge of achieving accurate reconstructions without loss of feature quality, we introduce the Introspective Adversarial Network, a novel hybridization of the VAE and GAN. Our model efficiently captures long-range dependencies through use of a computational block based on weight-shared dilated convolutions, and improves generalization performance with Orthogonal Regularization, a novel weight regularization method. We validate our contributions on CelebA, SVHN, and CIFAR-100, and produce samples and reconstructions with high visual fidelity.
+
+# 1 INTRODUCTION
+
+Editing photos typically involves some form of manipulating individual pixels, and achieving desirable results often requires significant user expertise. Given a sufficiently powerful image model, however, a user could quickly make large, photorealistic changes with ease by instead interacting with the model’s controls. Two recent advances, the Variational Autoencoder (VAE)(Kingma & Welling, 2014) and Generative Adversarial Network (GAN)(Goodfellow et al., 2014), have shown great promise for use in modeling the complex, high-dimensional distributions of natural images, but significant challenges remain before these models can be used as general-purpose image editors.
+
+VAEs are probabilistic graphical models that learn to maximize a variational lower bound on the likelihood of the data by projecting into a learned latent space, then reconstructing samples from that space. GANs learn a generative model by training one network, the "discriminator," to distinguish between real and generated data, while simultaneously training a second network, the "generator," to transform a noise vector into samples which the discriminator cannot distinguish from real data. Both approaches can be used to generate and interpolate between images by operating in a low-dimensional learned latent space, but each comes with its own set of benefits and drawbacks.
+
+VAEs have stable training dynamics, but tend to produce images that discard high-frequency details when trained using maximum likelihood. Using the intermediate activations of a pre-trained discriminative neural network as features for comparing reconstructions to originals (Lamb et al., 2016) mollifies this effect, but requires labels in order to train the discriminative network in a supervised fashion.
+
+By contrast, GANs have unstable and often oscillatory training dynamics, but produce images with sharp, photorealistic features. Basic GANs lack an inference mechanism, though techniques to train an inference network (Dumoulin et al., 2016) (Donahue et al., 2016) have recently been developed, as well as a hybridization that uses the VAE’s inference network (Larsen et al., 2015).
+
+Two key issues arise when attempting to use a latent-variable generative model to manipulate natural images. First, producing acceptable edits requires that the model be able to achieve close-to-exact reconstructions by inferring latents, or else the model’s output will not match the original image. This simultaneously necessitates an inference mechanism (or inference-by-optimization) and careful design of the model architecture, as there is a tradeoff between reconstruction accuracy and learned feature quality that varies with the size of the information bottleneck.
+
+![](images/bb41ca7b420c67f041de42331cd2d9d44d00d983c1abe4451522b81618f7637c.jpg)  
+Figure 1: The Neural Photo Editor. The original image is center. The red and blue tiles are visualizations of the latent space, and can be directly manipulated as well.
+
+Second, achieving a specific desired edit requires that the user be able to manipulate the model’s latent variables in an interpretable way. Typically, this would require that the model’s latent space be augmented during training and testing with a set of labeled attributes, such that interpolating along a latent such as "not smiling/smiling" produces a specific change. In the fully unsupervised setting, however, such semantically meaningful output features are generally controlled by an entangled set of latents which cannot be directly manipulated.
+
+In this paper, we present the Neural Photo Editor, an interface that handles both of these issues, enabling a user to make large, coherent changes to the output of unsupervised generative models by indirectly manipulating the latent vector with a "contextual paintbrush." By applying a simple interpolating mask, we enable this same exploration for existing photos despite reconstruction errors.
+
+Complementary to the Neural Photo Editor, we develop techniques to improve on common design tradeoffs in generative models. Our model, the Introspective Adversarial Network (IAN), is a hybridization of the VAE and GAN that leverages the power of the adversarial objective while maintaining the VAE’s efficient inference mechanism, improving upon previous VAE/GAN hybrids both in parametric efficiency and output quality. We employ a novel convolutional block based on dilated convolutions (Yu & Koltun, 2016) to efficiently increase the network’s receptive field, and Orthogonal Regularization, a novel weight regularizer.
+
+We demonstrate the qualitative sampling, reconstructing, and interpolating ability of the IAN on CelebA (Liu et al., 2015), SVHN (Netzer et al., 2011), CIFAR-10 (Krizhevsky & Hinton, 2009), and Imagenet (Russakovsky et al., 2015), and quantitatively demonstrate its inference capabilities with competitive performance on the semi-supervised SVHN classification task. Further quantitative experiments on CIFAR-100 (Krizhevsky & Hinton, 2009) verify the generality of our dilated convolution blocks and Orthogonal Regularization.
+
+# 2 NEURAL PHOTO EDITING
+
+We present an interface, shown in Figure 1, that turns a coarse user input into a refined, photorealistic image edit by indirectly manipulating the latent space with a "contextual paintbrush." The key idea is simple: a user selects a paint brush size and color (as with a typical image editor) and paints on the output image. Instead of changing individual pixels, the interface backpropagates the difference between the local image patch and the requested color, and takes a gradient descent step in the latent space to minimize that difference. This step results in globally coherent changes that are semantically meaningful in the context of the requested color change. Given an output image $\hat { X }$ and a user requested color $X _ { u s e r }$ , the change in latent values is $- \frac { d | | X _ { u s e r } - \hat { X } | | _ { 2 } } { d Z }$ , evaluated at the current paintbrush location each time a user requests an edit.
+
+![](images/ee59a3db2ae4092a6663370bd7f68a2ee9c7dc14ad97ca97e9d7786d06317db7.jpg)  
+Figure 2: Visualizing the interpolation mask. Top, left to right: Reconstruction, reconstruction error, original image. Bottom: Modified reconstruction, $\Delta$ , output.
+
+For example, if a user has an image of a person with light skin, dark hair, and a widow’s peak, by painting a dark color on the forehead, the system will automatically add hair in the requested area. Similarly, if a user has a photo of a person with a closed-mouth smile, the user can produce a toothy grin by painting bright white over the target’s mouth.
+
+This technique enables exploration of samples generated by the network, but fails when applied directly to existing photos, as it relies on the manipulated image being completely controlled by the latent variables, and reconstructions are usually imperfect. We circumvent this issue by introducing a simple masking technique that transfers edits from a reconstruction back to the original image.
+
+We take the output image to be a sum of the reconstruction, and a masked combination of the requested pixel-wise changes and the reconstruction error:
+
+$$
+Y = \hat { X } + M \Delta + ( 1 - M ) ( X - \hat { X } )
+$$
+
+Where $X$ is the original image, $\hat { X }$ is the model’s reconstruction of $X$ , and $\Delta$ is the difference between the modified reconstruction and $\hat { X }$ . The mask $M$ is the channel-wise mean of the absolute value of $\Delta$ , smoothed with a Gaussian filter $g$ and truncated pointwise to be between 0 and 1:
+
+$$
+M = m i n ( g ( | \bar { \Delta } | ) , 1 )
+$$
+
+The mask is designed to allow changes to the reconstruction to show through based on their magnitude. This relaxes the accuracy constraints by requiring that the reconstruction be feature-aligned rather than pixel-perfect, as only modifications to the reconstruction are applied to the original image. As long as the reconstruction is close enough and interpolations are smooth and plausible, the system will successfully transfer edits.
+
+A visualization of the masking technique is shown in Figure 2. This method adds minimal computational cost to the underlying latent space exploration and produces convincing changes of features including hair color and style, skin tone, and facial expression. A video of the interface in action is available online.1
+
+![](images/5eddbfc3033b5b8129b26c2966cc3c3c58b622b794a55ab63641164707df0738.jpg)  
+Figure 3: The Introspective Adversarial Network (IAN).
+
+# 3 INTROSPECTIVE ADVERSARIAL NETWORKS
+
+Complementary to the Neural Photo Editor, we introduce the Introspective Adversarial Network (IAN), a novel hybridization of the VAE and GAN motivated by the need for an image model with photorealistic outputs that achieves high-quality reconstructions without loss of representational power. There is typically a design tradeoff between these two goals related to the size of the latent space: a higher-dimensional latent space (i.e. a wider representational bottleneck) tends to learn less descriptive features, but produces higher quality reconstructions.
+
+We thus seek techniques to improve the capacity of the latent space without increasing its dimensionality. Similar to VAE/GAN (Larsen et al., 2015), we use the decoder network of the autoencoder as the generator network of the GAN, but instead of training a separate discriminator network, we combine the encoder and discriminator into a single network. Central to the IAN is the idea that features learned by a discriminatively trained network tend to be more expressive those learned by an encoder network trained via maximum likelihood (i.e. more useful on semi-supervised tasks), and thus better suited for inference. As the Neural Photo Editor relies on high-quality reconstructions, the inference capacity of the underlying model is critical. Accordingly, we use the discriminator of the GAN, $D$ , as a feature extractor for an inference subnetwork, $E$ , which is implemented as a fully-connected layer on top of the final convolutional layer of the discriminator. We infer latent values $Z \sim E ( X ) = q ( Z | X )$ for reconstruction and sample random values $Z \sim p ( Z )$ from a standard normal for random image generation using the generator network, $G$ .
+
+Similar to VAE/GAN and DeePSiM (Dosovitskiy & Brox, 2016), we use three distinct loss functions:
+
+• $\mathcal { L } _ { i m g }$ , the $\mathcal { L } _ { 1 }$ pixel-wise reconstruction loss, which we prefer to the $\mathcal { L } _ { 2 }$ reconstruction loss for its higher average gradient.   
+• $\mathcal { L } _ { f e a t u r e }$ , the feature-wise reconstruction loss, evaluated as the $\mathcal { L } _ { 2 }$ difference between the original and reconstruction in the space of the hidden layers of the discriminator.   
+• $\mathcal { L } _ { a d v }$ , the ternary adversarial loss, a modification of the adversarial loss that forces the discriminator to label a sample as real, generated, or reconstructed (as opposed to a binary real vs. generated label).
+
+Including the VAE’s KL divergence between the inferred latents $E ( X )$ and the prior $p ( Z )$ , the loss function for the generator and encoder network is thus:
+
+Where the $\lambda$ terms weight the relative importance of each loss. We set $\lambda _ { i m g }$ to 3 and leave the other terms at 1. The discriminator is updated solely using the ternary adversarial loss. During each training step, the generator produces reconstructions $G ( E ( X ) )$ (using the standard VAE reparameterization trick) from data $X$ and random samples $G ( Z )$ , while the discriminator observes $X$ as well as the reconstructions and random samples, and both networks are simultaneously updated.
+
+# 3.1 FEATURE-WISE LOSS
+
+We compare reconstructions using the intermediate activations, $f ( G ( E ( X ) ) )$ , of all convolutional layers of the discriminator, mirroring the perceptual losses of Discriminative Regularization (Lamb et al., 2016), VAE/GAN (Larsen et al., 2015), and DeepSiM (Dosovitskiy & Brox, 2016). We note that Feature Matching (Salimans et al., 2016) is designed to operate in a similar fashion, but without the guidance of an inference mechanism to match latent values $Z$ to particular values of $f ( G ( Z ) )$ . We find that using this loss to complement the pixel-wise difference results in sharper reconstructions that better preserve higher frequency features and edges.
+
+# 3.2 TERNARY ADVERSARIAL LOSS
+
+The standard GAN discriminator network is trained using an implicit label source (real vs fake); noting the success of augmenting the discriminator’s objective with supervised labels (Odena et al., 2016), we seek additional sources of implicit labels, in the hopes of achieving similar improvements. The ternary loss provides an additional source of supervision to the discriminator by asking it to determine if a sample is real, generated, or a reconstruction, while the generator’s goal is still to have the discriminator assign a high "real" probability to both samples and reconstructions. We thus modify the discriminator to have three output units with a softmax nonlinearity, and train it to minimize the categorical cross-entropy:
+
+$$
+{ \mathcal { L } } _ { D a d v } = - l o g ( D _ { r e a l } ( X ) ) - l o g ( D _ { g e n e r a t e d } ( G ( Z ) ) ) - l o g ( D _ { r e c o n s t r u c t e d } ( G ( E ( X ) ) ) )
+$$
+
+Where each $D$ term in Equation 4 indicates the discriminator output unit assigned to each label class. The generator is trained to produce outputs that maximize the probability of the label "real" being assigned by the discriminator by minimizing $\mathcal { L } _ { G a d v }$ :
+
+$$
+\mathcal { L } _ { G a d v } = - l o g ( D _ { r e a l } ( G ( Z ) ) ) - l o g ( D _ { r e a l } ( G ( E ( X ) ) )
+$$
+
+We posit that this loss helps maintain the balance of power early in training by preventing the discriminator from learning a small subset of features (e.g. artifacts in the generator’s output) that distinguish real and generated samples, reducing the range of useful features the generator can learn from the discriminator. We also find that this loss leads to higher sample quality, perhaps because the additional source of supervision leads to the discriminator ultimately learning a richer feature space.
+
+# 3.3 ARCHITECTURE
+
+Our model has the same basic structure as DCGAN (Radford et al., 2015), augmented with Multiscale Dilated Convolution (MDC) blocks in the generator, and Minibatch Discrimination (Salimans et al., 2016) in the discriminator. As in (Radford et al., 2015), we use Batch Normalization (Ioffe & Szegedy, 2015) and Adam (Kingma & Ba, 2014) in both networks. All of our code is publicly available.2
+
+# 3.4 MULTISCALE DILATED CONVOLUTION BLOCKS
+
+We propose a novel Inception-style (Szegedy et al., 2016) convolutional block motivated by the ideas that image features naturally occur at multiple scales, that a network’s expressivity is proportional to the range of functions it can represent divided by its total number of parameters, and by the desire to efficiently expand a network’s receptive field. The Multiscale Dilated Convolution (MDC) block applies a single FxF filter at multiple dilation factors, then performs a weighted elementwise sum of each dilated filter’s output, allowing the network to simultaneously learn a set of features and the relevant scales at which those features occur with a minimal increase in parameters. This also rapidly expands the network’s receptive field without requiring an increase in depth or the number of parameters. Dilated convolutions have previously been successfully applied in semantic segmentation (Yu & Koltun, 2016), and a similar scheme, minus the parameter sharing, is proposed in (Chen et al., 2016).
+
+![](images/06cab2de1dc14543946c0e397839ca08df89190f2f212ea3147a13ba935a15a3.jpg)  
+Figure 4: (a) Multiscale Dilated Convolution Block. (b) Visualizing a 3d3 MDC filter composition.
+
+As shown in Figure 4(a), each block is parameterized by a bank of $\mathbf { N } \mathbf { F x F }$ filters $W$ , applied with S factors of dilation, and a set of $\mathbf { N } { \ast } \mathbf { S }$ scalars $k$ , which relatively weight the output of each filter at each scale. This is naturally and efficiently implemented by reparameterizing a sparsely populated $\mathrm { F + } ( \mathrm { S } { \mathrm { - } } 1 ) ^ { \ast } ( \mathrm { F } { \mathrm { - } } 1 )$ filterbank as displayed in Figure 4(b). We propose two variants: Standard MDC, where the filter weights are tied to a base $W$ , and Full-Rank MDC, where filters are given the sparse layout of Figure 4(b) but the weights are not tied. Selecting Standard versus Full-Rank MDC blocks allows for a design tradeoff between parametric efficiency and model flexibility. In our architecture, we replace the hidden layers of the generator with Standard MDC blocks, using $\mathrm { F } { = } 5$ and $\scriptstyle \mathbf { D } = 2$ ; we specify MDC blocks by their base filter size and their maximum dilation factor (e.g. 5d2).
+
+# 3.5 ORTHOGONAL REGULARIZATION
+
+Orthogonality is a desirable quality in ConvNet filters, partially because multiplication by an orthogonal matrix leaves the norm of the original matrix unchanged. This property is valuable in deep or recurrent networks, where repeated matrix multiplication can result in signals vanishing or exploding. We note the success of initializing weights with orthogonal matrices (Saxe et al., 2014), and posit that maintaining orthogonality throughout training is also desirable. To this end, we propose a simple weight regularization technique, Orthogonal Regularization, that encourages weights to be orthogonal by pushing them towards the nearest orthogonal manifold. We augment our objective with the cost:
+
+$$
+\mathcal { L } _ { o r t h o } = \Sigma ( | W W ^ { T } - I | )
+$$
+
+Where $\Sigma$ indicates a sum across all filter banks, $W$ is a filter bank, and $I$ is the identity matrix.
+
+# 4 RELATED WORK
+
+Our architecture builds directly off of previous VAE/GAN hybrids (Larsen et al., 2015) (Dosovitskiy & Brox, 2016), with the key difference being our combination of the discriminator and the encoder to improve computational and parametric efficiency (by reusing discriminator features) as well as reconstruction accuracy (as demonstrated in our CelebA ablation studies). The methods of ALI (Dumoulin et al., 2016) and BiGAN (Donahue et al., 2016) provide an orthogonal approach to GAN inference, in which an inference network is trained by an adversarial (as opposed to a variational) process.
+
+The method of iGAN (Zhu et al., 2016) bears the most relation to our interface. The iGAN interface allows a user to impose shape or color constraints on an image of an object through use of a brush tool, then optimizes to solve for the output of a DCGAN (Radford et al., 2015) which best satisfies those constraints. Photorealistic edits are transferred to existing images via motion and color flow estimation.
+
+![](images/510977899825ff77d5fc6e0273b3f9ef6770190fa7e74614846692d054d7c09a.jpg)  
+Figure 5: CelebA and SVHN samples.
+
+Both iGAN and the Neural Photo Editor turn coarse user input into refined outputs through use of a generative model, but the methods differ in several key ways. First, we focus on editing portraits, rather than objects such as shoes or handbags, and are thus more concerned with modifying features, as opposed to overall color or shape, for which our method is less well-suited. Our edit transfer technique follows this difference as well: we directly transfer the local image changes produced by the model back onto the original image, rather than estimating and mimicking motion and color flow.
+
+Second, our interface applies user edits one step at a time, rather than iteratively optimizing the output. This highlights the difference in design approaches: iGAN seeks to produce outputs that best match a given set of user constraints, while we seek to allow a user to guide the latent space traversal.
+
+Finally, we explicitly tailor our model design to the task at hand and jointly train an inference network which we use at test time to produce reconstructions in a single shot. In contrast, iGAN trains an inference network to minimize the $\mathcal { L } _ { 2 }$ loss after training the generator network, and use the inference network to get an initial estimate of the inferred latents, which are then iteratively optimized.
+
+Another related interface (Champanard, 2016) refines simple user input into complex textures through use of artistic style transfer (Gatys et al., 2015). Other related work (White, 2016) also circumvents the need for labeled attributes by constructing latent vectors by analogy and bias-correcting them.
+
+# 5 EXPERIMENTS
+
+We qualitatively evaluate the IAN on 64x64 CelebA (Liu et al., 2015), 32x32 SVHN (Netzer et al., 2011), 32x32 CIFAR-10 (Krizhevsky & Hinton, 2009), and $6 4 \mathrm { x } 6 4$ Imagenet (Russakovsky et al., 2015). Our models are implemented in Theano (Team, 2016) with Lasagne (Dieleman et al., 2015). Samples from the IAN, randomly selected and shown in Figure 5, display the visual fidelity typical of adversarially trained networks. The IAN demonstrates high quality reconstructions on previously unseen data, shown in Figure 6, and smooth, plausible interpolations, even between drastically different samples. CIFAR and Imagenet samples, along with additional comparisons to samples from other models, are available in the appendix.
+
+# 5.1 DISCRIMINATIVE EXPERIMENTS
+
+We quantitatively demonstrate the effectiveness of our MDC blocks and Orthogonal Regularization on the CIFAR-100 (Krizhevsky & Hinton, 2009) benchmark. Using standard data augmentation, we train a set of 40-layer, $_ { \mathrm { k = } 1 2 }$ DenseNets (Huang et al., 2016) for 50 epochs, annealing the learning rate at 25 and 37 epochs. We add varying amounts of Orthogonal Regularization and modify the standard DenseNet architecture by replacing every 3x3 filterbank with 3d3 MDC blocks, and report the test error after training in Table 1. In addition, we compare to performance using full $7 \mathbf { x } 7$ filters.
+
+![](images/09acb38288cf98ef47fe1871fa9835d29cfd8eee73911cbd325f64e6adec78e2.jpg)  
+Figure 6: CelebA and SVHN Reconstructions and Interpolations. The outermost images are originals, the adjacent images are reconstructions.
+
+There is a noticeable increase in performance with the progressive addition of our modifications, despite a negligible increase in the number of parameters. Adding Orthogonal Regularization improves the network’s generalization ability; we suspect this is because it encourages the filter weights to remain close to a desirable, non-zero manifold, increasing the likelihood that all of the available model capacity is used by preventing the magnitude of the weights from overly diminishing. Replacing 3x3 filters with MDC blocks yields additional performance gains; we suspect this is due to an increase in the expressive power and receptive field of the network, allowing it to learn longer-range dependencies with ease. We also note that substituting Full-Rank MDC blocks into a 40-Layer DenseNet improves performance by a relative $5 \%$ , with the only increased computational cost coming from using the larger filters.
+
+For use in evaluating the IAN, we additionally train 40-layer, $_ { \mathrm { k = } 1 2 }$ DenseNets on the CelebA attribute classification task with varying amounts of Orthogonal Regularization. A plot of the train and validation error during training is available in Figure 7. The addition of of Orthogonal Regularization improves the validation error from $6 . 5 5 \%$ to $4 . 2 2 \%$ , further demonstrating its utility.
+
+# 5.2 EVALUATING MODIFICATIONS
+
+For use in editing photos, a model must produce reconstructions which are photorealistic and featurealigned, and have smooth, plausible interpolations between outputs. We perform an ablation study to investigate the effects of our proposals, and employ several metrics to evaluate model quality given these goals. In this study, we progressively add modifications to a VAE/GAN (Larsen et al., 2015) baseline, and train each network for 50 epochs.
+
+For reconstruction accuracy, pixel-wise distance does not tend to correlate well with perceptual similarity. In addition to pixel-wise $\mathcal { L } _ { 2 }$ distance, we therefore compare model reconstruction accuracy in terms of:
+
+• Feature-wise $\mathcal { L } _ { 2 }$ distance in the final layer of a 40-Layer $_ { \mathrm { k = } 1 2 }$ DenseNet trained for the CelebA attribute classification task.   
+• Trait reconstruction error. We run our classification DenseNet to predict a binary attribute vector $y ( X )$ given an image $\mathbf { X }$ , and $y ( G ( E ( X ) ) )$ given a model’s reconstruction, then measure the percent error.   
+• Fiducial keypoint Error, measured as the mean $\mathcal { L } _ { 2 }$ distance between the facial landmarks predicted by the system of (Sankaranarayanan et al., 2016).
+
+Table 1: Error rates on CIFAR- $1 0 0 +$ after 50 epochs.   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>#Params</td><td rowspan=1 colspan=1>MDC</td><td rowspan=1 colspan=1>Ortho. Reg.</td><td rowspan=1 colspan=1>Error (%)</td></tr><tr><td rowspan=1 colspan=1>Baseline DenseNet (D=40,K=12)</td><td rowspan=1 colspan=1>1.0M</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>26.71</td></tr><tr><td rowspan=1 colspan=1>DenseNet with Ortho. Reg.</td><td rowspan=1 colspan=1>1.0M</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>1e-3</td><td rowspan=1 colspan=1>26.51</td></tr><tr><td rowspan=1 colspan=1>DenseNet with Ortho. Reg</td><td rowspan=1 colspan=1>1.0M</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>1e-1</td><td rowspan=1 colspan=1>26.46</td></tr><tr><td rowspan=1 colspan=1>DenseNet with 7x7 Filters</td><td rowspan=1 colspan=1>5.0M</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>26.39</td></tr><tr><td rowspan=1 colspan=1>DenseNet with 3d3MDC</td><td rowspan=1 colspan=1>1.0M</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>26.02</td></tr><tr><td rowspan=1 colspan=1>DenseNet with Ortho. Reg &amp; MDC</td><td rowspan=1 colspan=1>1.0M</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>1e-3</td><td rowspan=1 colspan=1>25.72</td></tr><tr><td rowspan=1 colspan=1>DenseNet with Ortho.Reg&amp;MDC</td><td rowspan=1 colspan=1>1.0M</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>1e-1</td><td rowspan=1 colspan=1>25.39</td></tr><tr><td rowspan=1 colspan=1>DenseNet (Huang et al., 2016), 300 epochs</td><td rowspan=1 colspan=1>1.0M</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>24.42</td></tr><tr><td rowspan=1 colspan=1>DenseNet with Full MDC, 300 epochs</td><td rowspan=1 colspan=1>2.8M</td><td rowspan=1 colspan=1>full</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>23.30</td></tr></table>
+
+Table 2: CelebA investigations.   
+
+<table><tr><td rowspan=1 colspan=1>MDC</td><td rowspan=1 colspan=1>Ortho. Reg.</td><td rowspan=1 colspan=1>Ternary</td><td rowspan=1 colspan=1>Pixel</td><td rowspan=1 colspan=1>Feature</td><td rowspan=1 colspan=1>Trait(%)</td><td rowspan=1 colspan=1>Keypoint</td><td rowspan=1 colspan=1>Inception</td></tr><tr><td rowspan=1 colspan=2>VAE/GAN Baseline</td><td rowspan=1 colspan=1>line</td><td rowspan=1 colspan=1>0.295</td><td rowspan=1 colspan=1>4.86</td><td rowspan=1 colspan=1>0.197</td><td rowspan=1 colspan=1>2.21</td><td rowspan=1 colspan=1>1389(±64)</td></tr><tr><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>0.285</td><td rowspan=1 colspan=1>4.76</td><td rowspan=1 colspan=1>0.189</td><td rowspan=1 colspan=1>2.11</td><td rowspan=1 colspan=1>1772(±37)</td></tr><tr><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>0.258</td><td rowspan=1 colspan=1>4.67</td><td rowspan=1 colspan=1>0.182</td><td rowspan=1 colspan=1>1.79</td><td rowspan=1 colspan=1>2160(±70)</td></tr><tr><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>0.248</td><td rowspan=1 colspan=1>4.69</td><td rowspan=1 colspan=1>0.172</td><td rowspan=1 colspan=1>1.54</td><td rowspan=1 colspan=1>2365(±97)</td></tr><tr><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>0.230</td><td rowspan=1 colspan=1>4.39</td><td rowspan=1 colspan=1>0.165</td><td rowspan=1 colspan=1>1.47</td><td rowspan=1 colspan=1>3158(±98)</td></tr><tr><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>0.254</td><td rowspan=1 colspan=1>4.60</td><td rowspan=1 colspan=1>0.177</td><td rowspan=1 colspan=1>1.67</td><td rowspan=1 colspan=1>2648(±69)</td></tr><tr><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>0.239</td><td rowspan=1 colspan=1>4.51</td><td rowspan=1 colspan=1>0.164</td><td rowspan=1 colspan=1>1.57</td><td rowspan=1 colspan=1>3161(±70)</td></tr><tr><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>0.221</td><td rowspan=1 colspan=1>4.37</td><td rowspan=1 colspan=1>0.158</td><td rowspan=1 colspan=1>0.99</td><td rowspan=1 colspan=1>3300(±123)</td></tr><tr><td rowspan=1 colspan=1>【</td><td rowspan=1 colspan=1>了</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>0.192</td><td rowspan=1 colspan=1>4.33</td><td rowspan=1 colspan=1>0.155</td><td rowspan=1 colspan=1>0.97</td><td rowspan=1 colspan=1>3627(±146)</td></tr></table>
+
+Gauging the visual quality of the model’s outputs is notoriously difficult, but the Inception score recently proposed by (Salimans et al., 2016) has been found to correlate positively with humanevaluated sample quality. Using our CelebA attribute classification network in place of the Inception (Szegedy et al., 2016) model, we compare the Inception score of each model evaluated on 50,000 random samples. We posit that this metric is also indicative of interpolation quality, as a high visual quality score on a large sample population suggests that the model’s output quality remains high regardless of the state of the latent space.
+
+Results of this ablation study are presented in Table 2; samples and reconstructions from each configuration are available in the appendix, along with comparisons between a fully-trained IAN and related models. As with our discriminative experiments, we find that the progressive addition of modifications results in consistent performance improvements across our reconstruction metrics and the Inception score.
+
+We note that the single largest gains come from the inclusion of MDC blocks, suggesting that the network’s receptive field is a critical aspect of network design for both generative and discriminative tasks, with an increased receptive field correlating positively with reconstruction accuracy and sample quality.
+
+The improvements from Orthogonal Regularization suggest that encouraging weights to lie close to the orthogonal manifold is beneficial for improving the sample and reconstruction quality of generative neural networks by preventing learned weights from collapsing to an undesirable manifold; this is consistent with our experience iterating through network designs, where we have found mode collapse to occur less frequently while using Orthogonal Regularization.
+
+Finally, the increase in sample quality and reconstruction accuracy through use of the ternary adversarial loss suggests that including the "reconstructed" target in the discriminator’s objective does lead to the discriminator learning a richer feature space. This comes along with our observations that training with the ternary loss, where we have observed that the generator and discriminator losses tend to be more balanced than when training with the standard binary loss.
+
+Table 3: Error rates on Semi-Supervised SVHN with 1000 training examples. Figure 7: Performance on CelebA Classification task with varying Orthogonal Regularization.   
+
+<table><tr><td>Method</td><td>Error rate</td></tr><tr><td>VAE (M1+ M2) (Kingma et al.,2014)</td><td>36.02%</td></tr><tr><td>SWWAE with dropout (Zhao et al.,2015)</td><td>23.56%</td></tr><tr><td>DCGAN + L2-SVM (Radford et al.,2015)</td><td>22.18%(±1.13%)</td></tr><tr><td>SDGM (Maalge et al., 2016)</td><td>16.61%(±0.24%)</td></tr><tr><td>ALI (L2-SVM) (Dumoulin et al., 2016)</td><td>19.14%(±0.50%)</td></tr><tr><td>IAN (ours,L2-SVM)</td><td>18.50%(±0.38%)</td></tr><tr><td>IAN (ours, Improved-GAN)</td><td>8.34%(±0.91%)</td></tr><tr><td>Improved-GAN (Salimans et al., 2016)</td><td>8.11%(±1.3%)</td></tr><tr><td>ALI (Improved-GAN)</td><td>7.3%</td></tr><tr><td colspan="2">Table3</td></tr></table>
+
+![](images/675e2187393fc42a1103a2d900d34370f161fa5252f349e195730ccdb12ae8fc.jpg)  
+Figure 7
+
+# 5.3 SEMI-SUPERVISED LEARNING WITH SVHN
+
+We quantitatively evaluate the inference abilities of our architecture by applying it to the semisupervised SVHN classification task using two different procedures. We first evaluate using the procedure of (Radford et al., 2015) by training an L2-SVM on the output of the FC layer of the encoder subnetwork, and report average test error and standard deviation across 100 different SVMs, each trained on 1000 random examples from the training set.
+
+Next, we use the procedure of (Salimans et al., 2016), where the discriminator outputs a distribution over the $K$ object categories and an additional "fake" category, for a total of $K { + 1 }$ outputs. The discriminator is trained to predict the category when given labeled data, to assign the "fake" label when provided data from the generator, and to assign $\bar { k } \in \{ 1 , . . . , K \}$ when provided unlabeled real data. We modify feature-matching based Improved-GAN to include the encoder subnetwork and reconstruction losses detailed in Section 3, but do not include the ternary adversarial loss.
+
+Our performance, as shown in Table 3, is competitive with other networks evaluated in these fashions, achieving $1 8 . 5 \%$ mean classification accuracy when using SVMs and $8 . 3 4 \%$ accuracy when using the method of Improved-GAN. When using SVMs, our method tends to demonstrate improvement over previous methods, particularly over standard VAEs. We believe this is due to the encoder subnetwork being based on more descriptive features (i.e. those of the discriminator), and therefore better suited to discriminating between SVHN classes.
+
+We find the lack of improvement when using the method of Improved-GAN unsurprising, as the IAN architecture does not change the goal of the discriminator; any changes in behavior are thus indirectly due to changes in the generator, whose loss is only slightly modified from feature-matching Improved-GAN.
+
+# 6 CONCLUSION
+
+We introduced the Neural Photo Editor, a novel interface for exploring the learned latent space of generative models and for making specific semantic changes to natural images. Our interface makes use of the Introspective Adversarial Network, a hybridization of the VAE and GAN that outputs high fidelity samples and reconstructions, and achieves competitive performance in a semi-supervised classification task. The IAN makes use of Multiscale Dilated Convolution Blocks and Orthogonal Regularization, two improvements designed to improve model expressivity and feature quality for convolutional networks.
+
+# ACKNOWLEDGMENTS
+
+This research was made possible by grants and support from Renishaw plc and the Edinburgh Centre For Robotics. The work presented herein is also partially funded under the European H2020 Programme BEACONING project, Grant Agreement nr. 687676.
+
+REFERENCES   
+A.J. Champanard. Semantic style transfer and turning two-bit doodles into fine artwork. arXiv Preprint arXiv: 1603.01768, 2016.   
+L-C. Chen, G. Papandreou, I. Kokkinos, K. Murphy, , and A. L. Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. arXiv Preprint arXiv:1606.00915, 2016.   
+S. Dieleman, J. Schlüter, C. Raffel, E. Olson, S.K. Sønderby, D. Nouri, and E. Battenberg. Lasagne: First release., 2015. URL http://dx.doi.org/10.5281/zenodo.27878.   
+J. Donahue, P. Krähenbühl, and T. Darrell. Adversarial feature learning. arXiv preprint arXiv:1605.09782, 2016.   
+A. Dosovitskiy and T. Brox. Generating images with perceptual similarity metrics based on deep networks. arXiv Preprint arXiv:1602.02644, 2016.   
+V. Dumoulin, I. Belghazi, B. Poole, A. Lamb, M. Arjovsky, O. Mastropietro, and A. Courville. Adversarially learned inference. arXiv Preprint arXiv: 1606.0070, 2016.   
+L.A. Gatys, A.S. Ecker, and M. Bethge. A neural algorithm of artistic style. arXiv Preprint arXiv: 1508.06576, 2015.   
+I. Goodfellow, J. Pouget-Abadie, Jean, M. Mehdi, X. Bing, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems, pp. 2672–2680, 2014.   
+G. Huang, Z. Liu, K.Q. Weinberger, and L. van der Maaten. Densely connected convolutional networks. arXiv Preprint arXiv:1608.06993, 2016.   
+S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML 2015, 2015.   
+D.P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv Preprint arXiv: 1412.6980, 2014.   
+D.P. Kingma and M. Welling. Auto-encoding variational bayes. In ICLR 2014, 2014.   
+D.P. Kingma, S Mohamed, D.J. Rezende, and M. Welling. Semi-supervised learning with deep generative models. In Advances in Neural Information Processing Systems, pp. 3581–3589, 2014.   
+A. Krizhevsky and G. Hinton. Learning multiple layers of features from tiny images, 2009.   
+A. Lamb, V. Dumoulin, and A. Courville. Discriminative regularization for generative models. arXiv preprint arXiv:1602.03220, 2016.   
+A.B.L. Larsen, S.K. Sønderby, and O. Winther. Autoencoding beyond pixels using a learned similarity metric. arXiv preprint arXiv:1512.09300, 2015.   
+Z. Liu, P. Luo, X. Wang, and X. Tang. Deep learning face attributes in the wild. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3730–3738, 2015.   
+L. Maaløe, C.K. Sønderby, S.K. Sønderby, and O. Winther. Auxiliary deep generative models. arXiv preprint arXiv:1602.05473, 2016.   
+Y. Netzer, T. Wang, A. Coates, A. Bissacco, B. Wu, and A.Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS workshop on deep learning and unsupervised feature learning, volume 2011, pp. 4. Granada, Spain, 2011.   
+A. Odena, C. Olah, and J. Shiens. Conditional image synthesis with auxiliary classifier gans. arXiv Preprint arXiv: 1610.09585, 2016.   
+A. Radford, L. Metz, and S. Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.   
+O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.   
+T. Salimans, I. Goodfellow, W. Zaremba, V. Cheung, A. Radford, and X. Chen. Improved techniques for training gans. arXiv Preprint arXiv: 1606.03498, 2016.   
+S. Sankaranarayanan, R. Ranjan, C. D. Castillo, and R. Chellappa. An all-in-one convolutional neural network for face analysis. arXiv Preprint arXiv:1611.00851, 2016.   
+A.M. Saxe, J. L. McClelland, and S. Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. In ICLR 2014, 2014.   
+C. Szegedy, S. Ioffe, and V. Vanhoucke. Inception-v4, inception-resnet and the impact of residual connections on learning. arXiv Preprint arXiv: 1602.07261, 2016.   
+The Theano Development Team. Theano: A python framework for fast computation of mathematical expressions. arXiv Preprint arXiv: 1605.02688, 2016.   
+T. White. Sampling generative networks. arXiv Preprint arXiv:1609.04468, 2016.   
+F. Yu and V. Koltun. Multi-scale context aggregation by dilated convolutions. In ICLR 2016, 2016.   
+J. Zhao, M. Mathieu, R. Goroshin, and Y. Lecun. Stacked what-where auto-encoders. arXiv preprint arXiv:1506.02351, 2015.   
+J.-Y. Zhu, P. Krähenbuhl, E. Shechtman, and A. A. Efros. Generative visual manipulation on the natural image manifold. In ECCV 2016, 2016.
+
+![](images/667c4e636421add6a983628f34ed42736c7ceb7b0bf94ee8dcb8c25927fa48be.jpg)  
+Figure 7: Comparing samples from different models. From top: VAE(Kingma & Welling, 2014), DCGAN (Goodfellow et al., 2014), VAE/GAN from (Larsen et al., 2015), ALI from(Dumoulin et al., 2016), IAN (ours).
+
+![](images/d57168d78c04507291733989df912a8dad2a2198f75b4bbd34d39605590b8b11.jpg)  
+Table 4: Reconstructions and samples from CelebA ablation Study.
+
+![](images/d3e733e57fe4cb2afb4fc0a653d775afc0c21482a77070654a9344b93a6ca501.jpg)  
+Figure 8: Samples, reconstructions, and interpolations on CIFAR-10. Top three rows: samples, bottom three rows: reconstructions and interpolations. Our model achieves an Inception score of $6 . 8 8 ( \pm 0 . 0 8 )$ , on par with the $6 . 8 6 ( \pm 0 . 0 6 ) $ achieved by Improved-GAN with historical averaging.
+
+![](images/bb7d1bd177f78dbbe9f649235db84f51524cc73faa583131df7f1e712e6e0d60.jpg)  
+Figure 9: Samples, reconstructions, and interpolations on Imagenet. Top three rows: samples, bottom three rows: reconstructions and interpolations. Our model achieves an Inception score of $8 . 5 6 ( \pm 0 . 0 9 )$ .

parse/train/HkNKFiGex/HkNKFiGex_content_list.json

@@ -0,0 +1,1222 @@
+[
+    {
+        "type": "text",
+        "text": "NEURAL PHOTO EDITING WITH INTROSPECTIVE AD-VERSARIAL NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            826,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Andrew Brock, Theodore Lim, & J.M. Ritchie ",
+        "bbox": [
+            186,
+            170,
+            508,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Nick Weston ",
+        "text_level": 1,
+        "bbox": [
+            562,
+            170,
+            650,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "School of Engineering and Physical Sciences   \nHeriot-Watt University   \nEdinburgh, UK   \n{ajb5, t.lim, j.m.ritchie}@hw.ac.uk   \nRenishaw plc   \nResearch Ave, North   \nEdinburgh, UK   \nNick.Weston@renishaw.com ",
+        "bbox": [
+            184,
+            185,
+            527,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            562,
+            185,
+            799,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            276,
+            544,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The increasingly photorealistic sample quality of generative image models suggests their feasibility in applications beyond image generation. We present the Neural Photo Editor, an interface that leverages the power of generative neural networks to make large, semantically coherent changes to existing images. To tackle the challenge of achieving accurate reconstructions without loss of feature quality, we introduce the Introspective Adversarial Network, a novel hybridization of the VAE and GAN. Our model efficiently captures long-range dependencies through use of a computational block based on weight-shared dilated convolutions, and improves generalization performance with Orthogonal Regularization, a novel weight regularization method. We validate our contributions on CelebA, SVHN, and CIFAR-100, and produce samples and reconstructions with high visual fidelity. ",
+        "bbox": [
+            233,
+            308,
+            766,
+            460
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            488,
+            336,
+            503
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Editing photos typically involves some form of manipulating individual pixels, and achieving desirable results often requires significant user expertise. Given a sufficiently powerful image model, however, a user could quickly make large, photorealistic changes with ease by instead interacting with the model’s controls. Two recent advances, the Variational Autoencoder (VAE)(Kingma & Welling, 2014) and Generative Adversarial Network (GAN)(Goodfellow et al., 2014), have shown great promise for use in modeling the complex, high-dimensional distributions of natural images, but significant challenges remain before these models can be used as general-purpose image editors. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            616
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "VAEs are probabilistic graphical models that learn to maximize a variational lower bound on the likelihood of the data by projecting into a learned latent space, then reconstructing samples from that space. GANs learn a generative model by training one network, the \"discriminator,\" to distinguish between real and generated data, while simultaneously training a second network, the \"generator,\" to transform a noise vector into samples which the discriminator cannot distinguish from real data. Both approaches can be used to generate and interpolate between images by operating in a low-dimensional learned latent space, but each comes with its own set of benefits and drawbacks. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            720
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "VAEs have stable training dynamics, but tend to produce images that discard high-frequency details when trained using maximum likelihood. Using the intermediate activations of a pre-trained discriminative neural network as features for comparing reconstructions to originals (Lamb et al., 2016) mollifies this effect, but requires labels in order to train the discriminative network in a supervised fashion. ",
+        "bbox": [
+            176,
+            728,
+            825,
+            797
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "By contrast, GANs have unstable and often oscillatory training dynamics, but produce images with sharp, photorealistic features. Basic GANs lack an inference mechanism, though techniques to train an inference network (Dumoulin et al., 2016) (Donahue et al., 2016) have recently been developed, as well as a hybridization that uses the VAE’s inference network (Larsen et al., 2015). ",
+        "bbox": [
+            176,
+            804,
+            823,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Two key issues arise when attempting to use a latent-variable generative model to manipulate natural images. First, producing acceptable edits requires that the model be able to achieve close-to-exact reconstructions by inferring latents, or else the model’s output will not match the original image. This simultaneously necessitates an inference mechanism (or inference-by-optimization) and careful design of the model architecture, as there is a tradeoff between reconstruction accuracy and learned feature quality that varies with the size of the information bottleneck. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/bb41ca7b420c67f041de42331cd2d9d44d00d983c1abe4451522b81618f7637c.jpg",
+        "image_caption": [
+            "Figure 1: The Neural Photo Editor. The original image is center. The red and blue tiles are visualizations of the latent space, and can be directly manipulated as well. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            99,
+            813,
+            308
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            388,
+            823,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Second, achieving a specific desired edit requires that the user be able to manipulate the model’s latent variables in an interpretable way. Typically, this would require that the model’s latent space be augmented during training and testing with a set of labeled attributes, such that interpolating along a latent such as \"not smiling/smiling\" produces a specific change. In the fully unsupervised setting, however, such semantically meaningful output features are generally controlled by an entangled set of latents which cannot be directly manipulated. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            507
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present the Neural Photo Editor, an interface that handles both of these issues, enabling a user to make large, coherent changes to the output of unsupervised generative models by indirectly manipulating the latent vector with a \"contextual paintbrush.\" By applying a simple interpolating mask, we enable this same exploration for existing photos despite reconstruction errors. ",
+        "bbox": [
+            176,
+            513,
+            825,
+            569
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Complementary to the Neural Photo Editor, we develop techniques to improve on common design tradeoffs in generative models. Our model, the Introspective Adversarial Network (IAN), is a hybridization of the VAE and GAN that leverages the power of the adversarial objective while maintaining the VAE’s efficient inference mechanism, improving upon previous VAE/GAN hybrids both in parametric efficiency and output quality. We employ a novel convolutional block based on dilated convolutions (Yu & Koltun, 2016) to efficiently increase the network’s receptive field, and Orthogonal Regularization, a novel weight regularizer. ",
+        "bbox": [
+            174,
+            577,
+            825,
+            674
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate the qualitative sampling, reconstructing, and interpolating ability of the IAN on CelebA (Liu et al., 2015), SVHN (Netzer et al., 2011), CIFAR-10 (Krizhevsky & Hinton, 2009), and Imagenet (Russakovsky et al., 2015), and quantitatively demonstrate its inference capabilities with competitive performance on the semi-supervised SVHN classification task. Further quantitative experiments on CIFAR-100 (Krizhevsky & Hinton, 2009) verify the generality of our dilated convolution blocks and Orthogonal Regularization. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 NEURAL PHOTO EDITING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            790,
+            418,
+            806
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We present an interface, shown in Figure 1, that turns a coarse user input into a refined, photorealistic image edit by indirectly manipulating the latent space with a \"contextual paintbrush.\" The key idea is simple: a user selects a paint brush size and color (as with a typical image editor) and paints on the output image. Instead of changing individual pixels, the interface backpropagates the difference between the local image patch and the requested color, and takes a gradient descent step in the latent space to minimize that difference. This step results in globally coherent changes that are semantically meaningful in the context of the requested color change. Given an output image $\\hat { X }$ and a user requested color $X _ { u s e r }$ , the change in latent values is $- \\frac { d | | X _ { u s e r } - \\hat { X } | | _ { 2 } } { d Z }$ , evaluated at the current paintbrush location each time a user requests an edit. ",
+        "bbox": [
+            174,
+            824,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/ee59a3db2ae4092a6663370bd7f68a2ee9c7dc14ad97ca97e9d7786d06317db7.jpg",
+        "image_caption": [
+            "Figure 2: Visualizing the interpolation mask. Top, left to right: Reconstruction, reconstruction error, original image. Bottom: Modified reconstruction, $\\Delta$ , output. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            284,
+            103,
+            714,
+            323
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            409,
+            821,
+            441
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For example, if a user has an image of a person with light skin, dark hair, and a widow’s peak, by painting a dark color on the forehead, the system will automatically add hair in the requested area. Similarly, if a user has a photo of a person with a closed-mouth smile, the user can produce a toothy grin by painting bright white over the target’s mouth. ",
+        "bbox": [
+            174,
+            448,
+            825,
+            503
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This technique enables exploration of samples generated by the network, but fails when applied directly to existing photos, as it relies on the manipulated image being completely controlled by the latent variables, and reconstructions are usually imperfect. We circumvent this issue by introducing a simple masking technique that transfers edits from a reconstruction back to the original image. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            568
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We take the output image to be a sum of the reconstruction, and a masked combination of the requested pixel-wise changes and the reconstruction error: ",
+        "bbox": [
+            173,
+            574,
+            823,
+            603
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8bc37b1236819685ceb99383062715900276e4709953287014a0784e6180a9d1.jpg",
+        "text": "$$\nY = \\hat { X } + M \\Delta + ( 1 - M ) ( X - \\hat { X } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            636,
+            622,
+            655
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Where $X$ is the original image, $\\hat { X }$ is the model’s reconstruction of $X$ , and $\\Delta$ is the difference between the modified reconstruction and $\\hat { X }$ . The mask $M$ is the channel-wise mean of the absolute value of $\\Delta$ , smoothed with a Gaussian filter $g$ and truncated pointwise to be between 0 and 1: ",
+        "bbox": [
+            173,
+            683,
+            825,
+            729
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5aecdad093eb2e25dd71beacddc95f856a90dfb131f94947f93998ee9f1df089.jpg",
+        "text": "$$\nM = m i n ( g ( | \\bar { \\Delta } | ) , 1 )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            747,
+            571,
+            766
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The mask is designed to allow changes to the reconstruction to show through based on their magnitude. This relaxes the accuracy constraints by requiring that the reconstruction be feature-aligned rather than pixel-perfect, as only modifications to the reconstruction are applied to the original image. As long as the reconstruction is close enough and interpolations are smooth and plausible, the system will successfully transfer edits. ",
+        "bbox": [
+            173,
+            790,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A visualization of the masking technique is shown in Figure 2. This method adds minimal computational cost to the underlying latent space exploration and produces convincing changes of features including hair color and style, skin tone, and facial expression. A video of the interface in action is available online.1 ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/5eddbfc3033b5b8129b26c2966cc3c3c58b622b794a55ab63641164707df0738.jpg",
+        "image_caption": [
+            "Figure 3: The Introspective Adversarial Network (IAN). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            98,
+            805,
+            327
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 INTROSPECTIVE ADVERSARIAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            387,
+            570,
+            402
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Complementary to the Neural Photo Editor, we introduce the Introspective Adversarial Network (IAN), a novel hybridization of the VAE and GAN motivated by the need for an image model with photorealistic outputs that achieves high-quality reconstructions without loss of representational power. There is typically a design tradeoff between these two goals related to the size of the latent space: a higher-dimensional latent space (i.e. a wider representational bottleneck) tends to learn less descriptive features, but produces higher quality reconstructions. ",
+        "bbox": [
+            173,
+            417,
+            825,
+            502
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We thus seek techniques to improve the capacity of the latent space without increasing its dimensionality. Similar to VAE/GAN (Larsen et al., 2015), we use the decoder network of the autoencoder as the generator network of the GAN, but instead of training a separate discriminator network, we combine the encoder and discriminator into a single network. Central to the IAN is the idea that features learned by a discriminatively trained network tend to be more expressive those learned by an encoder network trained via maximum likelihood (i.e. more useful on semi-supervised tasks), and thus better suited for inference. As the Neural Photo Editor relies on high-quality reconstructions, the inference capacity of the underlying model is critical. Accordingly, we use the discriminator of the GAN, $D$ , as a feature extractor for an inference subnetwork, $E$ , which is implemented as a fully-connected layer on top of the final convolutional layer of the discriminator. We infer latent values $Z \\sim E ( X ) = q ( Z | X )$ for reconstruction and sample random values $Z \\sim p ( Z )$ from a standard normal for random image generation using the generator network, $G$ . ",
+        "bbox": [
+            174,
+            508,
+            825,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Similar to VAE/GAN and DeePSiM (Dosovitskiy & Brox, 2016), we use three distinct loss functions: ",
+        "bbox": [
+            179,
+            683,
+            821,
+            696
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• $\\mathcal { L } _ { i m g }$ , the $\\mathcal { L } _ { 1 }$ pixel-wise reconstruction loss, which we prefer to the $\\mathcal { L } _ { 2 }$ reconstruction loss for its higher average gradient.   \n• $\\mathcal { L } _ { f e a t u r e }$ , the feature-wise reconstruction loss, evaluated as the $\\mathcal { L } _ { 2 }$ difference between the original and reconstruction in the space of the hidden layers of the discriminator.   \n• $\\mathcal { L } _ { a d v }$ , the ternary adversarial loss, a modification of the adversarial loss that forces the discriminator to label a sample as real, generated, or reconstructed (as opposed to a binary real vs. generated label). ",
+        "bbox": [
+            215,
+            709,
+            825,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Including the VAE’s KL divergence between the inferred latents $E ( X )$ and the prior $p ( Z )$ , the loss function for the generator and encoder network is thus: ",
+        "bbox": [
+            173,
+            832,
+            823,
+            859
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Where the $\\lambda$ terms weight the relative importance of each loss. We set $\\lambda _ { i m g }$ to 3 and leave the other terms at 1. The discriminator is updated solely using the ternary adversarial loss. During each training step, the generator produces reconstructions $G ( E ( X ) )$ (using the standard VAE reparameterization trick) from data $X$ and random samples $G ( Z )$ , while the discriminator observes $X$ as well as the reconstructions and random samples, and both networks are simultaneously updated. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 FEATURE-WISE LOSS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            190,
+            362,
+            204
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We compare reconstructions using the intermediate activations, $f ( G ( E ( X ) ) )$ , of all convolutional layers of the discriminator, mirroring the perceptual losses of Discriminative Regularization (Lamb et al., 2016), VAE/GAN (Larsen et al., 2015), and DeepSiM (Dosovitskiy & Brox, 2016). We note that Feature Matching (Salimans et al., 2016) is designed to operate in a similar fashion, but without the guidance of an inference mechanism to match latent values $Z$ to particular values of $f ( G ( Z ) )$ . We find that using this loss to complement the pixel-wise difference results in sharper reconstructions that better preserve higher frequency features and edges. ",
+        "bbox": [
+            174,
+            215,
+            826,
+            314
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 TERNARY ADVERSARIAL LOSS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            330,
+            429,
+            345
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The standard GAN discriminator network is trained using an implicit label source (real vs fake); noting the success of augmenting the discriminator’s objective with supervised labels (Odena et al., 2016), we seek additional sources of implicit labels, in the hopes of achieving similar improvements. The ternary loss provides an additional source of supervision to the discriminator by asking it to determine if a sample is real, generated, or a reconstruction, while the generator’s goal is still to have the discriminator assign a high \"real\" probability to both samples and reconstructions. We thus modify the discriminator to have three output units with a softmax nonlinearity, and train it to minimize the categorical cross-entropy: ",
+        "bbox": [
+            174,
+            356,
+            825,
+            469
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c894b617987bac3b87a3091cf3d1f8f88b8bbebaf3b2b218e73fcd2dc7274e4c.jpg",
+        "text": "$$\n{ \\mathcal { L } } _ { D a d v } = - l o g ( D _ { r e a l } ( X ) ) - l o g ( D _ { g e n e r a t e d } ( G ( Z ) ) ) - l o g ( D _ { r e c o n s t r u c t e d } ( G ( E ( X ) ) ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            496,
+            782,
+            515
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Where each $D$ term in Equation 4 indicates the discriminator output unit assigned to each label class. The generator is trained to produce outputs that maximize the probability of the label \"real\" being assigned by the discriminator by minimizing $\\mathcal { L } _ { G a d v }$ : ",
+        "bbox": [
+            174,
+            527,
+            828,
+            571
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2aa2fe6e674a6e27c08cca0c12fa867395ceeeeb44ef5b799017b0037cbf2c10.jpg",
+        "text": "$$\n\\mathcal { L } _ { G a d v } = - l o g ( D _ { r e a l } ( G ( Z ) ) ) - l o g ( D _ { r e a l } ( G ( E ( X ) ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            589,
+            683,
+            608
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We posit that this loss helps maintain the balance of power early in training by preventing the discriminator from learning a small subset of features (e.g. artifacts in the generator’s output) that distinguish real and generated samples, reducing the range of useful features the generator can learn from the discriminator. We also find that this loss leads to higher sample quality, perhaps because the additional source of supervision leads to the discriminator ultimately learning a richer feature space. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            688
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            705,
+            326,
+            719
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our model has the same basic structure as DCGAN (Radford et al., 2015), augmented with Multiscale Dilated Convolution (MDC) blocks in the generator, and Minibatch Discrimination (Salimans et al., 2016) in the discriminator. As in (Radford et al., 2015), we use Batch Normalization (Ioffe & Szegedy, 2015) and Adam (Kingma & Ba, 2014) in both networks. All of our code is publicly available.2 ",
+        "bbox": [
+            174,
+            731,
+            826,
+            786
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 MULTISCALE DILATED CONVOLUTION BLOCKS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            804,
+            544,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We propose a novel Inception-style (Szegedy et al., 2016) convolutional block motivated by the ideas that image features naturally occur at multiple scales, that a network’s expressivity is proportional to the range of functions it can represent divided by its total number of parameters, and by the desire to efficiently expand a network’s receptive field. The Multiscale Dilated Convolution (MDC) block applies a single FxF filter at multiple dilation factors, then performs a weighted elementwise sum of each dilated filter’s output, allowing the network to simultaneously learn a set of features and the relevant scales at which those features occur with a minimal increase in parameters. This also rapidly expands the network’s receptive field without requiring an increase in depth or the number of parameters. Dilated convolutions have previously been successfully applied in semantic segmentation (Yu & Koltun, 2016), and a similar scheme, minus the parameter sharing, is proposed in (Chen et al., 2016). ",
+        "bbox": [
+            174,
+            829,
+            825,
+            900
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/06cab2de1dc14543946c0e397839ca08df89190f2f212ea3147a13ba935a15a3.jpg",
+        "image_caption": [
+            "Figure 4: (a) Multiscale Dilated Convolution Block. (b) Visualizing a 3d3 MDC filter composition. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            263,
+            101,
+            732,
+            262
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            315,
+            825,
+            400
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 4(a), each block is parameterized by a bank of $\\mathbf { N } \\mathbf { F x F }$ filters $W$ , applied with S factors of dilation, and a set of $\\mathbf { N } { \\ast } \\mathbf { S }$ scalars $k$ , which relatively weight the output of each filter at each scale. This is naturally and efficiently implemented by reparameterizing a sparsely populated $\\mathrm { F + } ( \\mathrm { S } { \\mathrm { - } } 1 ) ^ { \\ast } ( \\mathrm { F } { \\mathrm { - } } 1 )$ filterbank as displayed in Figure 4(b). We propose two variants: Standard MDC, where the filter weights are tied to a base $W$ , and Full-Rank MDC, where filters are given the sparse layout of Figure 4(b) but the weights are not tied. Selecting Standard versus Full-Rank MDC blocks allows for a design tradeoff between parametric efficiency and model flexibility. In our architecture, we replace the hidden layers of the generator with Standard MDC blocks, using $\\mathrm { F } { = } 5$ and $\\scriptstyle \\mathbf { D } = 2$ ; we specify MDC blocks by their base filter size and their maximum dilation factor (e.g. 5d2). ",
+        "bbox": [
+            174,
+            406,
+            826,
+            532
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.5 ORTHOGONAL REGULARIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            550,
+            444,
+            564
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Orthogonality is a desirable quality in ConvNet filters, partially because multiplication by an orthogonal matrix leaves the norm of the original matrix unchanged. This property is valuable in deep or recurrent networks, where repeated matrix multiplication can result in signals vanishing or exploding. We note the success of initializing weights with orthogonal matrices (Saxe et al., 2014), and posit that maintaining orthogonality throughout training is also desirable. To this end, we propose a simple weight regularization technique, Orthogonal Regularization, that encourages weights to be orthogonal by pushing them towards the nearest orthogonal manifold. We augment our objective with the cost: ",
+        "bbox": [
+            173,
+            575,
+            825,
+            674
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f84da2cd590ff38ac7df2b5e46610cfb6fd4751b5917cb4b68ad9c6d8d15aaaf.jpg",
+        "text": "$$\n\\mathcal { L } _ { o r t h o } = \\Sigma ( | W W ^ { T } - I | )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            693,
+            588,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Where $\\Sigma$ indicates a sum across all filter banks, $W$ is a filter bank, and $I$ is the identity matrix. ",
+        "bbox": [
+            169,
+            723,
+            792,
+            738
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            758,
+            344,
+            775
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our architecture builds directly off of previous VAE/GAN hybrids (Larsen et al., 2015) (Dosovitskiy & Brox, 2016), with the key difference being our combination of the discriminator and the encoder to improve computational and parametric efficiency (by reusing discriminator features) as well as reconstruction accuracy (as demonstrated in our CelebA ablation studies). The methods of ALI (Dumoulin et al., 2016) and BiGAN (Donahue et al., 2016) provide an orthogonal approach to GAN inference, in which an inference network is trained by an adversarial (as opposed to a variational) process. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The method of iGAN (Zhu et al., 2016) bears the most relation to our interface. The iGAN interface allows a user to impose shape or color constraints on an image of an object through use of a brush tool, then optimizes to solve for the output of a DCGAN (Radford et al., 2015) which best satisfies those constraints. Photorealistic edits are transferred to existing images via motion and color flow estimation. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/510977899825ff77d5fc6e0273b3f9ef6770190fa7e74614846692d054d7c09a.jpg",
+        "image_caption": [
+            "Figure 5: CelebA and SVHN samples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            99,
+            803,
+            306
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            366,
+            823,
+            409
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Both iGAN and the Neural Photo Editor turn coarse user input into refined outputs through use of a generative model, but the methods differ in several key ways. First, we focus on editing portraits, rather than objects such as shoes or handbags, and are thus more concerned with modifying features, as opposed to overall color or shape, for which our method is less well-suited. Our edit transfer technique follows this difference as well: we directly transfer the local image changes produced by the model back onto the original image, rather than estimating and mimicking motion and color flow. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            500
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Second, our interface applies user edits one step at a time, rather than iteratively optimizing the output. This highlights the difference in design approaches: iGAN seeks to produce outputs that best match a given set of user constraints, while we seek to allow a user to guide the latent space traversal. ",
+        "bbox": [
+            176,
+            507,
+            825,
+            549
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, we explicitly tailor our model design to the task at hand and jointly train an inference network which we use at test time to produce reconstructions in a single shot. In contrast, iGAN trains an inference network to minimize the $\\mathcal { L } _ { 2 }$ loss after training the generator network, and use the inference network to get an initial estimate of the inferred latents, which are then iteratively optimized. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            611
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Another related interface (Champanard, 2016) refines simple user input into complex textures through use of artistic style transfer (Gatys et al., 2015). Other related work (White, 2016) also circumvents the need for labeled attributes by constructing latent vectors by analogy and bias-correcting them. ",
+        "bbox": [
+            174,
+            618,
+            825,
+            661
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            326,
+            696
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We qualitatively evaluate the IAN on 64x64 CelebA (Liu et al., 2015), 32x32 SVHN (Netzer et al., 2011), 32x32 CIFAR-10 (Krizhevsky & Hinton, 2009), and $6 4 \\mathrm { x } 6 4$ Imagenet (Russakovsky et al., 2015). Our models are implemented in Theano (Team, 2016) with Lasagne (Dieleman et al., 2015). Samples from the IAN, randomly selected and shown in Figure 5, display the visual fidelity typical of adversarially trained networks. The IAN demonstrates high quality reconstructions on previously unseen data, shown in Figure 6, and smooth, plausible interpolations, even between drastically different samples. CIFAR and Imagenet samples, along with additional comparisons to samples from other models, are available in the appendix. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            824
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 DISCRIMINATIVE EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            437,
+            856
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We quantitatively demonstrate the effectiveness of our MDC blocks and Orthogonal Regularization on the CIFAR-100 (Krizhevsky & Hinton, 2009) benchmark. Using standard data augmentation, we train a set of 40-layer, $_ { \\mathrm { k = } 1 2 }$ DenseNets (Huang et al., 2016) for 50 epochs, annealing the learning rate at 25 and 37 epochs. We add varying amounts of Orthogonal Regularization and modify the standard DenseNet architecture by replacing every 3x3 filterbank with 3d3 MDC blocks, and report the test error after training in Table 1. In addition, we compare to performance using full $7 \\mathbf { x } 7$ filters. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/09acb38288cf98ef47fe1871fa9835d29cfd8eee73911cbd325f64e6adec78e2.jpg",
+        "image_caption": [
+            "Figure 6: CelebA and SVHN Reconstructions and Interpolations. The outermost images are originals, the adjacent images are reconstructions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            99,
+            803,
+            306
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            385,
+            823,
+            414
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "There is a noticeable increase in performance with the progressive addition of our modifications, despite a negligible increase in the number of parameters. Adding Orthogonal Regularization improves the network’s generalization ability; we suspect this is because it encourages the filter weights to remain close to a desirable, non-zero manifold, increasing the likelihood that all of the available model capacity is used by preventing the magnitude of the weights from overly diminishing. Replacing 3x3 filters with MDC blocks yields additional performance gains; we suspect this is due to an increase in the expressive power and receptive field of the network, allowing it to learn longer-range dependencies with ease. We also note that substituting Full-Rank MDC blocks into a 40-Layer DenseNet improves performance by a relative $5 \\%$ , with the only increased computational cost coming from using the larger filters. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            560
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For use in evaluating the IAN, we additionally train 40-layer, $_ { \\mathrm { k = } 1 2 }$ DenseNets on the CelebA attribute classification task with varying amounts of Orthogonal Regularization. A plot of the train and validation error during training is available in Figure 7. The addition of of Orthogonal Regularization improves the validation error from $6 . 5 5 \\%$ to $4 . 2 2 \\%$ , further demonstrating its utility. ",
+        "bbox": [
+            174,
+            566,
+            825,
+            622
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 EVALUATING MODIFICATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            645,
+            423,
+            660
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For use in editing photos, a model must produce reconstructions which are photorealistic and featurealigned, and have smooth, plausible interpolations between outputs. We perform an ablation study to investigate the effects of our proposals, and employ several metrics to evaluate model quality given these goals. In this study, we progressively add modifications to a VAE/GAN (Larsen et al., 2015) baseline, and train each network for 50 epochs. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            743
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For reconstruction accuracy, pixel-wise distance does not tend to correlate well with perceptual similarity. In addition to pixel-wise $\\mathcal { L } _ { 2 }$ distance, we therefore compare model reconstruction accuracy in terms of: ",
+        "bbox": [
+            174,
+            750,
+            825,
+            791
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• Feature-wise $\\mathcal { L } _ { 2 }$ distance in the final layer of a 40-Layer $_ { \\mathrm { k = } 1 2 }$ DenseNet trained for the CelebA attribute classification task.   \n• Trait reconstruction error. We run our classification DenseNet to predict a binary attribute vector $y ( X )$ given an image $\\mathbf { X }$ , and $y ( G ( E ( X ) ) )$ given a model’s reconstruction, then measure the percent error.   \n• Fiducial keypoint Error, measured as the mean $\\mathcal { L } _ { 2 }$ distance between the facial landmarks predicted by the system of (Sankaranarayanan et al., 2016). ",
+        "bbox": [
+            215,
+            806,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/2d2a566d5fec15a0cc1c4f3edb798efec469096354daf75072afc9054fd7a3ae.jpg",
+        "table_caption": [
+            "Table 1: Error rates on CIFAR- $1 0 0 +$ after 50 epochs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>#Params</td><td rowspan=1 colspan=1>MDC</td><td rowspan=1 colspan=1>Ortho. Reg.</td><td rowspan=1 colspan=1>Error (%)</td></tr><tr><td rowspan=1 colspan=1>Baseline DenseNet (D=40,K=12)</td><td rowspan=1 colspan=1>1.0M</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>26.71</td></tr><tr><td rowspan=1 colspan=1>DenseNet with Ortho. Reg.</td><td rowspan=1 colspan=1>1.0M</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>1e-3</td><td rowspan=1 colspan=1>26.51</td></tr><tr><td rowspan=1 colspan=1>DenseNet with Ortho. Reg</td><td rowspan=1 colspan=1>1.0M</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>1e-1</td><td rowspan=1 colspan=1>26.46</td></tr><tr><td rowspan=1 colspan=1>DenseNet with 7x7 Filters</td><td rowspan=1 colspan=1>5.0M</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>26.39</td></tr><tr><td rowspan=1 colspan=1>DenseNet with 3d3MDC</td><td rowspan=1 colspan=1>1.0M</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>26.02</td></tr><tr><td rowspan=1 colspan=1>DenseNet with Ortho. Reg &amp; MDC</td><td rowspan=1 colspan=1>1.0M</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>1e-3</td><td rowspan=1 colspan=1>25.72</td></tr><tr><td rowspan=1 colspan=1>DenseNet with Ortho.Reg&amp;MDC</td><td rowspan=1 colspan=1>1.0M</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>1e-1</td><td rowspan=1 colspan=1>25.39</td></tr><tr><td rowspan=1 colspan=1>DenseNet (Huang et al., 2016), 300 epochs</td><td rowspan=1 colspan=1>1.0M</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>24.42</td></tr><tr><td rowspan=1 colspan=1>DenseNet with Full MDC, 300 epochs</td><td rowspan=1 colspan=1>2.8M</td><td rowspan=1 colspan=1>full</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>23.30</td></tr></table>",
+        "bbox": [
+            189,
+            101,
+            808,
+            248
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/e84b09ce16351d0609171cdc2ecd513a430b16747dd9b1e917ea184849650741.jpg",
+        "table_caption": [
+            "Table 2: CelebA investigations. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>MDC</td><td rowspan=1 colspan=1>Ortho. Reg.</td><td rowspan=1 colspan=1>Ternary</td><td rowspan=1 colspan=1>Pixel</td><td rowspan=1 colspan=1>Feature</td><td rowspan=1 colspan=1>Trait(%)</td><td rowspan=1 colspan=1>Keypoint</td><td rowspan=1 colspan=1>Inception</td></tr><tr><td rowspan=1 colspan=2>VAE/GAN Baseline</td><td rowspan=1 colspan=1>line</td><td rowspan=1 colspan=1>0.295</td><td rowspan=1 colspan=1>4.86</td><td rowspan=1 colspan=1>0.197</td><td rowspan=1 colspan=1>2.21</td><td rowspan=1 colspan=1>1389(±64)</td></tr><tr><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>0.285</td><td rowspan=1 colspan=1>4.76</td><td rowspan=1 colspan=1>0.189</td><td rowspan=1 colspan=1>2.11</td><td rowspan=1 colspan=1>1772(±37)</td></tr><tr><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>0.258</td><td rowspan=1 colspan=1>4.67</td><td rowspan=1 colspan=1>0.182</td><td rowspan=1 colspan=1>1.79</td><td rowspan=1 colspan=1>2160(±70)</td></tr><tr><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>0.248</td><td rowspan=1 colspan=1>4.69</td><td rowspan=1 colspan=1>0.172</td><td rowspan=1 colspan=1>1.54</td><td rowspan=1 colspan=1>2365(±97)</td></tr><tr><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>0.230</td><td rowspan=1 colspan=1>4.39</td><td rowspan=1 colspan=1>0.165</td><td rowspan=1 colspan=1>1.47</td><td rowspan=1 colspan=1>3158(±98)</td></tr><tr><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>0.254</td><td rowspan=1 colspan=1>4.60</td><td rowspan=1 colspan=1>0.177</td><td rowspan=1 colspan=1>1.67</td><td rowspan=1 colspan=1>2648(±69)</td></tr><tr><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>0.239</td><td rowspan=1 colspan=1>4.51</td><td rowspan=1 colspan=1>0.164</td><td rowspan=1 colspan=1>1.57</td><td rowspan=1 colspan=1>3161(±70)</td></tr><tr><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>0.221</td><td rowspan=1 colspan=1>4.37</td><td rowspan=1 colspan=1>0.158</td><td rowspan=1 colspan=1>0.99</td><td rowspan=1 colspan=1>3300(±123)</td></tr><tr><td rowspan=1 colspan=1>【</td><td rowspan=1 colspan=1>了</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>0.192</td><td rowspan=1 colspan=1>4.33</td><td rowspan=1 colspan=1>0.155</td><td rowspan=1 colspan=1>0.97</td><td rowspan=1 colspan=1>3627(±146)</td></tr></table>",
+        "bbox": [
+            196,
+            310,
+            803,
+            457
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gauging the visual quality of the model’s outputs is notoriously difficult, but the Inception score recently proposed by (Salimans et al., 2016) has been found to correlate positively with humanevaluated sample quality. Using our CelebA attribute classification network in place of the Inception (Szegedy et al., 2016) model, we compare the Inception score of each model evaluated on 50,000 random samples. We posit that this metric is also indicative of interpolation quality, as a high visual quality score on a large sample population suggests that the model’s output quality remains high regardless of the state of the latent space. ",
+        "bbox": [
+            173,
+            532,
+            825,
+            631
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Results of this ablation study are presented in Table 2; samples and reconstructions from each configuration are available in the appendix, along with comparisons between a fully-trained IAN and related models. As with our discriminative experiments, we find that the progressive addition of modifications results in consistent performance improvements across our reconstruction metrics and the Inception score. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            707
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We note that the single largest gains come from the inclusion of MDC blocks, suggesting that the network’s receptive field is a critical aspect of network design for both generative and discriminative tasks, with an increased receptive field correlating positively with reconstruction accuracy and sample quality. ",
+        "bbox": [
+            174,
+            714,
+            825,
+            770
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The improvements from Orthogonal Regularization suggest that encouraging weights to lie close to the orthogonal manifold is beneficial for improving the sample and reconstruction quality of generative neural networks by preventing learned weights from collapsing to an undesirable manifold; this is consistent with our experience iterating through network designs, where we have found mode collapse to occur less frequently while using Orthogonal Regularization. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            847
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, the increase in sample quality and reconstruction accuracy through use of the ternary adversarial loss suggests that including the \"reconstructed\" target in the discriminator’s objective does lead to the discriminator learning a richer feature space. This comes along with our observations that training with the ternary loss, where we have observed that the generator and discriminator losses tend to be more balanced than when training with the standard binary loss. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/0996ae5dedf2d4e1c1bec3222b99e2025f145aaf48f00c2057edbe4e2330e124.jpg",
+        "table_caption": [
+            "Table 3: Error rates on Semi-Supervised SVHN with 1000 training examples. Figure 7: Performance on CelebA Classification task with varying Orthogonal Regularization. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Error rate</td></tr><tr><td>VAE (M1+ M2) (Kingma et al.,2014)</td><td>36.02%</td></tr><tr><td>SWWAE with dropout (Zhao et al.,2015)</td><td>23.56%</td></tr><tr><td>DCGAN + L2-SVM (Radford et al.,2015)</td><td>22.18%(±1.13%)</td></tr><tr><td>SDGM (Maalge et al., 2016)</td><td>16.61%(±0.24%)</td></tr><tr><td>ALI (L2-SVM) (Dumoulin et al., 2016)</td><td>19.14%(±0.50%)</td></tr><tr><td>IAN (ours,L2-SVM)</td><td>18.50%(±0.38%)</td></tr><tr><td>IAN (ours, Improved-GAN)</td><td>8.34%(±0.91%)</td></tr><tr><td>Improved-GAN (Salimans et al., 2016)</td><td>8.11%(±1.3%)</td></tr><tr><td>ALI (Improved-GAN)</td><td>7.3%</td></tr><tr><td colspan=\"2\">Table3</td></tr></table>",
+        "bbox": [
+            183,
+            101,
+            586,
+            256
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/675e2187393fc42a1103a2d900d34370f161fa5252f349e195730ccdb12ae8fc.jpg",
+        "image_caption": [
+            "Figure 7 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            599,
+            111,
+            808,
+            239
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.3 SEMI-SUPERVISED LEARNING WITH SVHN ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            329,
+            513,
+            344
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We quantitatively evaluate the inference abilities of our architecture by applying it to the semisupervised SVHN classification task using two different procedures. We first evaluate using the procedure of (Radford et al., 2015) by training an L2-SVM on the output of the FC layer of the encoder subnetwork, and report average test error and standard deviation across 100 different SVMs, each trained on 1000 random examples from the training set. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            428
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Next, we use the procedure of (Salimans et al., 2016), where the discriminator outputs a distribution over the $K$ object categories and an additional \"fake\" category, for a total of $K { + 1 }$ outputs. The discriminator is trained to predict the category when given labeled data, to assign the \"fake\" label when provided data from the generator, and to assign $\\bar { k } \\in \\{ 1 , . . . , K \\}$ when provided unlabeled real data. We modify feature-matching based Improved-GAN to include the encoder subnetwork and reconstruction losses detailed in Section 3, but do not include the ternary adversarial loss. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            518
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our performance, as shown in Table 3, is competitive with other networks evaluated in these fashions, achieving $1 8 . 5 \\%$ mean classification accuracy when using SVMs and $8 . 3 4 \\%$ accuracy when using the method of Improved-GAN. When using SVMs, our method tends to demonstrate improvement over previous methods, particularly over standard VAEs. We believe this is due to the encoder subnetwork being based on more descriptive features (i.e. those of the discriminator), and therefore better suited to discriminating between SVHN classes. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            609
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We find the lack of improvement when using the method of Improved-GAN unsurprising, as the IAN architecture does not change the goal of the discriminator; any changes in behavior are thus indirectly due to changes in the generator, whose loss is only slightly modified from feature-matching Improved-GAN. ",
+        "bbox": [
+            174,
+            616,
+            825,
+            672
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            699,
+            318,
+            715
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We introduced the Neural Photo Editor, a novel interface for exploring the learned latent space of generative models and for making specific semantic changes to natural images. Our interface makes use of the Introspective Adversarial Network, a hybridization of the VAE and GAN that outputs high fidelity samples and reconstructions, and achieves competitive performance in a semi-supervised classification task. The IAN makes use of Multiscale Dilated Convolution Blocks and Orthogonal Regularization, two improvements designed to improve model expressivity and feature quality for convolutional networks. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            832
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            326,
+            868
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This research was made possible by grants and support from Renishaw plc and the Edinburgh Centre For Robotics. The work presented herein is also partially funded under the European H2020 Programme BEACONING project, Grant Agreement nr. 687676. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nA.J. Champanard. Semantic style transfer and turning two-bit doodles into fine artwork. arXiv Preprint arXiv: 1603.01768, 2016.   \nL-C. Chen, G. Papandreou, I. Kokkinos, K. Murphy, , and A. L. Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. arXiv Preprint arXiv:1606.00915, 2016.   \nS. Dieleman, J. Schlüter, C. Raffel, E. Olson, S.K. Sønderby, D. Nouri, and E. Battenberg. Lasagne: First release., 2015. URL http://dx.doi.org/10.5281/zenodo.27878.   \nJ. Donahue, P. Krähenbühl, and T. Darrell. Adversarial feature learning. arXiv preprint arXiv:1605.09782, 2016.   \nA. Dosovitskiy and T. Brox. Generating images with perceptual similarity metrics based on deep networks. arXiv Preprint arXiv:1602.02644, 2016.   \nV. Dumoulin, I. Belghazi, B. Poole, A. Lamb, M. Arjovsky, O. Mastropietro, and A. Courville. Adversarially learned inference. arXiv Preprint arXiv: 1606.0070, 2016.   \nL.A. Gatys, A.S. Ecker, and M. Bethge. A neural algorithm of artistic style. arXiv Preprint arXiv: 1508.06576, 2015.   \nI. Goodfellow, J. Pouget-Abadie, Jean, M. Mehdi, X. Bing, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems, pp. 2672–2680, 2014.   \nG. Huang, Z. Liu, K.Q. Weinberger, and L. van der Maaten. Densely connected convolutional networks. arXiv Preprint arXiv:1608.06993, 2016.   \nS. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML 2015, 2015.   \nD.P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv Preprint arXiv: 1412.6980, 2014.   \nD.P. Kingma and M. Welling. Auto-encoding variational bayes. In ICLR 2014, 2014.   \nD.P. Kingma, S Mohamed, D.J. Rezende, and M. Welling. Semi-supervised learning with deep generative models. In Advances in Neural Information Processing Systems, pp. 3581–3589, 2014.   \nA. Krizhevsky and G. Hinton. Learning multiple layers of features from tiny images, 2009.   \nA. Lamb, V. Dumoulin, and A. Courville. Discriminative regularization for generative models. arXiv preprint arXiv:1602.03220, 2016.   \nA.B.L. Larsen, S.K. Sønderby, and O. Winther. Autoencoding beyond pixels using a learned similarity metric. arXiv preprint arXiv:1512.09300, 2015.   \nZ. Liu, P. Luo, X. Wang, and X. Tang. Deep learning face attributes in the wild. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3730–3738, 2015.   \nL. Maaløe, C.K. Sønderby, S.K. Sønderby, and O. Winther. Auxiliary deep generative models. arXiv preprint arXiv:1602.05473, 2016.   \nY. Netzer, T. Wang, A. Coates, A. Bissacco, B. Wu, and A.Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS workshop on deep learning and unsupervised feature learning, volume 2011, pp. 4. Granada, Spain, 2011.   \nA. Odena, C. Olah, and J. Shiens. Conditional image synthesis with auxiliary classifier gans. arXiv Preprint arXiv: 1610.09585, 2016.   \nA. Radford, L. Metz, and S. Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.   \nO. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.   \nT. Salimans, I. Goodfellow, W. Zaremba, V. Cheung, A. Radford, and X. Chen. Improved techniques for training gans. arXiv Preprint arXiv: 1606.03498, 2016.   \nS. Sankaranarayanan, R. Ranjan, C. D. Castillo, and R. Chellappa. An all-in-one convolutional neural network for face analysis. arXiv Preprint arXiv:1611.00851, 2016.   \nA.M. Saxe, J. L. McClelland, and S. Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. In ICLR 2014, 2014.   \nC. Szegedy, S. Ioffe, and V. Vanhoucke. Inception-v4, inception-resnet and the impact of residual connections on learning. arXiv Preprint arXiv: 1602.07261, 2016.   \nThe Theano Development Team. Theano: A python framework for fast computation of mathematical expressions. arXiv Preprint arXiv: 1605.02688, 2016.   \nT. White. Sampling generative networks. arXiv Preprint arXiv:1609.04468, 2016.   \nF. Yu and V. Koltun. Multi-scale context aggregation by dilated convolutions. In ICLR 2016, 2016.   \nJ. Zhao, M. Mathieu, R. Goroshin, and Y. Lecun. Stacked what-where auto-encoders. arXiv preprint arXiv:1506.02351, 2015.   \nJ.-Y. Zhu, P. Krähenbuhl, E. Shechtman, and A. A. Efros. Generative visual manipulation on the natural image manifold. In ECCV 2016, 2016. ",
+        "bbox": [
+            169,
+            90,
+            828,
+            926
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            102,
+            828,
+            459
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/667c4e636421add6a983628f34ed42736c7ceb7b0bf94ee8dcb8c25927fa48be.jpg",
+        "image_caption": [
+            "Figure 7: Comparing samples from different models. From top: VAE(Kingma & Welling, 2014), DCGAN (Goodfellow et al., 2014), VAE/GAN from (Larsen et al., 2015), ALI from(Dumoulin et al., 2016), IAN (ours). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            248,
+            142,
+            743,
+            510
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/d57168d78c04507291733989df912a8dad2a2198f75b4bbd34d39605590b8b11.jpg",
+        "image_caption": [
+            "Table 4: Reconstructions and samples from CelebA ablation Study. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            231,
+            805,
+            756
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/d3e733e57fe4cb2afb4fc0a653d775afc0c21482a77070654a9344b93a6ca501.jpg",
+        "image_caption": [
+            "Figure 8: Samples, reconstructions, and interpolations on CIFAR-10. Top three rows: samples, bottom three rows: reconstructions and interpolations. Our model achieves an Inception score of $6 . 8 8 ( \\pm 0 . 0 8 )$ , on par with the $6 . 8 6 ( \\pm 0 . 0 6 ) $ achieved by Improved-GAN with historical averaging. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            111,
+            812,
+            433
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/bb7d1bd177f78dbbe9f649235db84f51524cc73faa583131df7f1e712e6e0d60.jpg",
+        "image_caption": [
+            "Figure 9: Samples, reconstructions, and interpolations on Imagenet. Top three rows: samples, bottom three rows: reconstructions and interpolations. Our model achieves an Inception score of $8 . 5 6 ( \\pm 0 . 0 9 )$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            526,
+            813,
+            847
+        ],
+        "page_idx": 14
+    }
+]

parse/train/HyGh4sR9YQ/HyGh4sR9YQ.md

@@ -0,0 +1,307 @@
+# DEEP NEUROEVOLUTION: GENETIC ALGORITHMS ARE A COMPETITIVE ALTERNATIVE FOR TRAINING DEEP NEURAL NETWORKS FOR REINFORCEMENT LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Deep artificial neural networks (DNNs) are typically trained via gradient-based learning algorithms, namely backpropagation. Evolution strategies (ES) can rival backprop-based algorithms such as Q-learning and policy gradients on challenging deep reinforcement learning (RL) problems. However, ES can be considered a gradient-based algorithm because it performs stochastic gradient descent via an operation similar to a finite-difference approximation of the gradient. That raises the question of whether non-gradient-based evolutionary algorithms can work at DNN scales. Here we demonstrate they can: we evolve the weights of a DNN with a simple, gradient-free, population-based genetic algorithm (GA) and it performs well on hard deep RL problems, including Atari and humanoid locomotion. The Deep GA successfully evolves networks with over four million free parameters, the largest neural networks ever evolved with a traditional evolutionary algorithm. These results (1) expand our sense of the scale at which GAs can operate, (2) suggest intriguingly that in some cases following the gradient is not the best choice for optimizing performance, and (3) make immediately available the multitude of neuroevolution techniques that improve performance. We demonstrate the latter by showing that combining DNNs with novelty search, which encourages exploration on tasks with deceptive or sparse reward functions, can solve a high-dimensional problem on which reward-maximizing algorithms (e.g. DQN, A3C, ES, and the GA) fail. Additionally, the Deep GA is faster than ES, A3C, and DQN (it can train Atari in ${ \sim } 4$ hours on one workstation or ${ \sim } 1$ hour distributed on 720 cores), and enables a state-of-the-art, up to 10,000-fold compact encoding technique.
+
+# 1 INTRODUCTION
+
+A recent trend in machine learning and AI research is that old algorithms work remarkably well when combined with sufficient computing resources and data. That has been the story for (1) backpropagation applied to deep neural networks in supervised learning tasks such as computer vision Krizhevsky et al. (2012) and voice recognition Seide et al. (2011), (2) backpropagation for deep neural networks combined with traditional reinforcement learning algorithms, such as Q-learning Watkins and Dayan (1992); Mnih et al. (2015) or policy gradient (PG) methods Sehnke et al. (2010); Mnih et al. (2016), and (3) evolution strategies (ES) applied to reinforcement learning benchmarks Salimans et al. (2017). One common theme is that all of these methods are gradient-based, including ES, which involves a gradient approximation similar to finite differences Williams (1992); Wierstra et al. (2008); Salimans et al. (2017). This historical trend raises the question of whether a similar story will play out for gradient-free methods, such as population-based GAs.
+
+This paper investigates that question by testing the performance of a simple GA on hard deep reinforcement learning (RL) benchmarks, including Atari 2600 Bellemare et al. (2013); Brockman et al. (2016); Mnih et al. (2015) and Humanoid Locomotion in the MuJoCo simulator Todorov et al. (2012); Schulman et al. (2015; 2017); Brockman et al. (2016). We compare the performance of the GA with that of contemporary algorithms applied to deep RL (i.e. DQN Mnih et al. (2015), a
+
+Q-learning method, A3C Mnih et al. (2016), a policy gradient method, and ES). One might expect GAs to perform far worse than other methods because they are so simple and do not follow gradients. Surprisingly, we found that GAs turn out to be a competitive algorithm for RL – performing better on some domains and worse on others, and roughly as well overall as A3C, DQN, and ES – adding a new family of algorithms to the toolbox for deep RL problems. We also validate the effectiveness of learning with GAs by comparing their performance to that of random search (RS). While the GA always outperforms random search, interestingly we discovered that in some Atari games random search outperforms powerful deep RL algorithms (DQN on 3/13 games, A3C on 6/13, and ES on 3/13), suggesting that local optima, saddle points, noisy gradient estimates, or other factors are impeding progress on these problems for gradient-based methods. Although deep neural networks often do not struggle with local optima in supervised learning Pascanu et al. (2014), local optima remain an issue in RL because the reward signal may deceptively encourage the agent to perform actions that prevent it from discovering the globally optimal behavior.
+
+Like ES and the deep RL algorithms, the GA has unique benefits. GAs prove slightly faster than ES (discussed below). The GA and ES are thus both substantially faster in wall-clock speed than Q-learning and policy gradient methods. We explore two distinct GA implementations: (1) a singlemachine version with GPUs and CPUs, and (2) a distributed version on many CPUs across many machines. On a single modern workstation with 4 GPUs and 48 CPU cores, the GA can train Atari in ${ \sim } 4$ hours. Training to comparable performance takes ${ \sim } 7 { - } 1 0$ days for DQN and ${ \sim } 4$ days for A3C. This speedup enables individual researchers with single (albeit expensive) workstations to start using domains formerly reserved for well-funded labs only and iterate perhaps more rapidly than with any other RL algorithm. Given substantial distributed computation (here, 720 CPU cores across dozens of machines), the GA and ES can train Atari in ${ \sim } 1$ hour. Also beneficial, via a new technique we introduce, even multi-million-parameter networks trained by GAs can be encoded with very few (thousands of) bytes, yielding the state-of-the-art compact encoding method.
+
+Overall, the unexpectedly competitive performance of the GA (and random search) suggests that the structure of the search space in some of these domains is not amenable to gradient-based search. That realization opens up new research directions on when/how to exploit the regions where a gradientfree search might be more appropriate and motivates research into new kinds of hybrid algorithms.
+
+# 2 BACKGROUND
+
+At a high level, an RL problem challenges an agent to maximize some notion of cumulative reward (e.g. total, or discounted) without supervision as to how to accomplish that goal Sutton and Barto (1998). A host of traditional RL algorithms perform well on small, tabular state spaces Sutton and Barto (1998). However, scaling to high-dimensional problems (e.g. learning to act directly from pixels) was challenging until RL algorithms harnessed the representational power of deep neural networks (DNNs), thus catalyzing the field of deep reinforcement learning (deep RL) Mnih et al. (2015). Three broad families of deep learning algorithms have shown promise on RL problems so far: Q-learning methods such as DQN Mnih et al. (2015), policy gradient methods Sehnke et al. (2010) (e.g. A3C Mnih et al. (2016), TRPO Schulman et al. (2015), PPO Schulman et al. (2017)), and more recently evolution strategies (ES) Salimans et al. (2017).
+
+Deep Q-learning algorithms approximate the optimal Q function with DNNs, yielding policies that, for a given state, choose the action with the maximum Q-value Watkins and Dayan (1992); Mnih et al. (2015); Hessel et al. (2017). Policy gradient methods directly learn the parameters of a DNN policy that outputs the probability of taking each action in each state. A team from OpenAI recently experimented with a simplified version of Natural Evolution Strategies Wierstra et al. (2008), specifically one that learns the mean of a distribution of parameters, but not its variance. They found that this algorithm, which we will refer to simply as evolution strategies (ES), is competitive with DQN and A3C on difficult RL benchmark problems, with much faster training times (i.e. faster wall-clock time when many CPUs are available) due to better parallelization Salimans et al. (2017).
+
+All of these methods can be considered gradient-based methods, as they all calculate or approximate gradients in a DNN and optimize those parameters via stochastic gradient descent/ascent (though they do not require differentiating through the reward function, e.g. a simulator). DQN calculates the gradient of the loss of the DNN Q-value function approximator via backpropagation. Policy gradients sample behaviors stochastically from the current policy and then reinforce those that perform well via stochastic gradient ascent. ES does not calculate gradients analytically, but approximates the gradient of the reward function in the parameter space Salimans et al. (2017); Wierstra et al. (2008).
+
+Here we test whether a truly gradient-free method, a GA, can perform well on challenging deep RL tasks. We find GAs perform surprisingly well and thus can be considered a new addition to the set of algorithms for deep RL problems.
+
+# 3 METHODS
+
+# 3.1 GENETIC ALGORITHM
+
+We purposefully test with an extremely simple GA to set a baseline for how well evolutionary algorithms work for RL problems. We expect future work to reveal that adding the legion of enhancements that exist for GAs Fogel and Stayton (1994); Haupt and Haupt (2004); Clune et al. (2011); Mouret and Doncieux (2009); Lehman and Stanley (2011a); Stanley et al. (2009); Mouret and Clune (2015) will improve their performance on deep RL tasks.
+
+A genetic algorithm Holland (1992); Eiben et al. (2003) evolves a population $\mathcal { P }$ of $N$ individuals (here, neural network parameter vectors $\theta$ , often called genotypes). At every generation, each $\theta _ { i }$ is evaluated, producing a fitness score (aka reward) $F ( \theta _ { i } )$ . Our GA variant performs truncation selection, wherein the top $T$ individuals become the parents of the next generation. To produce the next generation, the following process is repeated $N - 1$ times: A parent is selected uniformly at random with replacement and is mutated by applying additive Gaussian noise to the parameter vector: $\theta ^ { \prime } = \theta + \bar { \sigma } \epsilon$ where $\epsilon \sim \mathcal { N } ( 0 , I )$ . The appropriate value of $\sigma$ was determined empirically for each experiment, as described in Supplementary Information (SI) Table 2. The $N ^ { \mathrm { t h } }$ individual is an unmodified copy of the best individual from the previous generation, a technique called elitism. To more reliably try to select the true elite in the presence of noisy evaluation, we evaluate each of the top 10 individuals per generation on 30 additional episodes (counting these frames as ones consumed during training); the one with the highest mean score is the designated elite. Historically, GAs often involve crossover (i.e. combining parameters from multiple parents to produce an offspring), but for simplicity we did not include it. The new population is then evaluated and the process repeats for $G$ generations or until some other stopping criterion is met. SI Algorithm 1 provides pseudocode for our version.
+
+Open source code and hyperparameter configurations for all of our experiments are available: anonymous. Hyperparameters are also listed in SI Table 2. Hyperparameters were fixed for all Atari games, chosen from a set of 36 hyperparameters tested on six games (Asterix, Enduro, Gravitar, Kangaroo, Seaquest, Venture).
+
+GA implementations traditionally store each individual as a parameter vector $\theta$ , but this approach scales poorly in memory and network transmission costs with large populations and large (deeper and wider) neural networks. We propose a novel method to store large parameter vectors compactly by representing each parameter vector as an initialization seed plus the list of random seeds that produced each of the mutations that led to each $\theta$ . This information is sufficient to reconstruct each $\theta$ . This innovation was critical for an efficient implementation of a distributed deep GA. SI Fig. 1 shows, and Eq. 1 describes, the method.
+
+$$
+\theta ^ { n } = \psi ( \theta ^ { n - 1 } , \tau _ { n } ) = \theta ^ { n - 1 } + \sigma \varepsilon ( \tau _ { n } )
+$$
+
+where $\theta ^ { n }$ is an offspring of $\theta ^ { n - 1 }$ , $\psi ( \theta ^ { n - 1 } , \tau _ { n } )$ is a deterministic mutation function, $\tau$ is a vector of mutation seeds that encodes $\theta ^ { n }$ , $\theta ^ { 0 } = \phi ( \tau _ { 0 } )$ , where $\phi$ is a deterministic initialization function, and $\varepsilon ( \tau _ { n } ) \sim \mathcal { N } ( 0 , I )$ is a deterministic Gaussian pseudo-random number generator with an input seed $\tau _ { n }$ that produces a vector of length $| \theta |$ . In our case, $\varepsilon ( \tau _ { n } )$ is a large precomputed table that is indexed by 28-bit seeds. SI Sec. 7.3 provides more details, including how the seeds could be smaller.
+
+This technique is advantageous because the size of the compressed representation increases linearly with the number of generations (often order thousands), and is independent of the size of the network (often order millions or more). It does, of course, require computation to reconstruct the DNN weight vector. Competitive Atari-playing agents evolve in as little as tens of generations, enabling a compressed representation of a $^ { 4 \mathbf { M } + }$ parameter neural network in just thousands of bytes (a 10,000- fold compression). The compression rate depends on the number of generations, but in practice is always substantial: all Atari final networks were compressible 8,000-50,000-fold. This represents the state of the art in encoding large networks compactly. However, it is not a general network compression technique because it cannot compress arbitrary networks, and instead only works for networks evolved with a GA.
+
+One motivation for choosing ES versus Q-learning and policy gradient methods is its faster wallclock time with distributed computation, owing to better parallelization Salimans et al. (2017). We found that the distributed CPU-only Deep GA not only preserves this benefit, but slightly improves upon it (SI Sec. 7.1 describes why GAs–distributed or local–are faster than ES). Importantly, GAs can also use GPUs to speed up the forward pass of DNNs (especially large ones), making it possible to train on a single workstation. With our GPU-enabled implementation, on one modern workstation we can train Atari in ${ \sim } 4$ hours what takes ${ \sim } 1$ hour with 720 distributed cores. Distributed GPU training would further speed up training for large population sizes.
+
+# 3.2 NOVELTY SEARCH
+
+One benefit of training deep neural networks with GAs is it enables us to immediately take advantage of algorithms previously developed in the neuroevolution community. As a demonstration, we experiment with novelty search (NS) Lehman and Stanley (2011b), which was designed for deceptive domains in which reward-based optimization mechanisms converge to local optima. NS avoids these local optima by ignoring the reward function during evolution and instead rewarding agents for performing behaviors that have never been performed before (i.e. that are novel). Surprisingly, it can often outperform algorithms that utilize the reward signal, a result demonstrated on maze navigation and simulated biped locomotion tasks Lehman and Stanley (2011b). Here we apply NS to see how it performs when combined with DNNs on a deceptive image-based RL problem (that we call the Image Hard Maze). We refer to the GA that optimizes for novelty as GA-NS.
+
+NS requires a behavior characteristic (BC) that describes the behavior of a policy $B C ( \pi )$ and a behavioral distance function between the BCs of any two policies: $\mathrm { l i s t } ( B C ( \pi _ { i } ) , B C ( \pi _ { j } ) )$ , both of which are domain-specific. After each generation, members of the population have a probability $p$ (here, 0.01) of having their BC stored in an archive. The novelty of a policy is defined as the average distance to the $k$ (here, 25) nearest neighbors (sorted by behavioral distance) in the population or archive. Novel individuals are thus determined based on their behavioral distance to current or previously seen individuals. The GA otherwise proceeds as normal, substituting novelty for fitness (reward). For reporting and plotting purposes only, we identify the individual with the highest reward per generation. The algorithm is presented in SI Algorithm 2.
+
+# 4 EXPERIMENTS
+
+Our experiments focus on the performance of the GA on the same challenging problems that have validated the effectiveness of state-of-the-art deep RL algorithms and ES Salimans et al. (2017). They include learning to play Atari directly from pixels Mnih et al. (2015); Schulman et al. (2017); Mnih et al. (2016); Bellemare et al. (2013) and a continuous control problem involving a simulated humanoid robot learning to walk Brockman et al. (2016); Schulman et al. (2017); Salimans et al. (2017); Todorov et al. (2012). We also tested on an Atari-scale maze domain that has a clear local optimum (Image Hard Maze) to study how well these algorithms avoid deception Lehman and Stanley (2011b).
+
+For Atari and Image Hard Maze experiments, we record the best agent found in each of multiple, independent, randomly initialized GA runs: 5 for Atari, 10 for the Image Hard Maze. Because Atari is stochastic, the final score for each run takes the highest-scoring elite across generations, and reports the mean score it achieves on 200 independent evaluations. The final score for the domain is then the median of final run scores. Humanoid Locomotion details are in SI. Sec 7.6.
+
+# 4.1 ATARI
+
+Training deep neural networks to play Atari – mapping directly from pixels to actions – was a celebrated feat that arguably launched the deep RL era and expanded our understanding of the difficulty of RL domains that machine learning could tackle Mnih et al. (2015). Here we test how the performance of DNNs evolved by a simple GA compare to DNNs trained by the major families of deep RL algorithms and ES. We model our experiments on those from the ES paper by Salimans et al. (2017) because it inspired our study. Due to limited computational resources, our initial and main study compares results on 13 Atari games. Some were chosen because they are games on which ES performs well (Frostbite, Gravitar, Kangaroo, Venture, Zaxxon) or poorly (Amidar, Enduro, Skiing, Seaquest) and the remaining games were chosen from the ALE Bellemare et al. (2013) set in alphabetical order (Assault, Asterix, Asteroids, Atlantis). We later expanded our study to the full set of 57 Atari games from recent milestone papers Hessel et al. (2017); Horgan et al. (2018) and our conclusions were qualitatively unchanged (SI Sec. 7.8). To facilitate comparisons with results reported in Salimans et al. (2017), we keep the number of game frames agents experience over the course of a GA run constant (at one billion frames). The frame limit results in a differing number of generations per independent GA run (SI Sec. Table 3), as policies of different quality in different runs may see more frames in some games (e.g. if the agent lives longer).
+
+During training, each agent is evaluated on a full episode (capped at 20k frames), which can include multiple lives, and fitness is the sum of episode rewards, i.e. the final Atari game score. The following are identical to DQN Mnih et al. (2015): (1) data preprocessing, (2) network architecture, and (3) the stochastic environment that starts each episode with up to 30 random, initial no-op operations. We use the larger DQN architecture from Mnih et al. (2015) consisting of 3 convolutional layers with 32, 64, and 64 channels followed by a hidden layer with 512 units. The convolutional layers use $8 \times 8$ , $4 \times 4$ , and $3 \times 3$ filters with strides of 4, 2, and 1, respectively. All hidden layers were followed by a rectifier nonlinearity (ReLU). The network contains over 4M parameters; interestingly, many in the past assumed that a simple GA would fail at such scales. All results are from our single-machine CPU $^ +$ GPU GA implementation.
+
+Fair comparisons between algorithms is difficult, as evaluation procedures are non-uniform and algorithms realize different trade-offs between computation, wall-clock speed, and sample efficiency. Another consideration is whether agents are evaluated on random starts (a random number of no-op actions), which is the regime they are trained on, or on starts randomly sampled from human play, which tests for generalization Nair et al. (2015). Because we do not have a database of human starts to sample from, our agents are evaluated with random starts. Where possible, we compare our results to those for other algorithms on random starts. That is true for DQN and ES, but not for A3C, where we had to include results on human starts.
+
+We also attempt to control for the number of frames seen during training, but because DQN is far slower to run, we present results from the literature that train on fewer frames (200M, which requires 7-10 days of computation vs. hours of computation needed for ES and the GA to train on 1B frames). There are many variants of DQN that we could compare to, including the Rainbow Hessel et al. (2017) algorithm that combines many different recent improvements to DQN Van Hasselt et al. (2016); Wang et al. (2015); Schaul et al. (2015); Sutton and Barto (1998); Bellemare et al. (2017); Fortunato et al. (2017). However, we choose to compare the GA to the original, vanilla DQN algorithm, partly because we also introduce a vanilla GA, without the many modifications and improvements that have been previously developed Haupt and Haupt (2004).
+
+In what will likely be a surprise to many, the simple GA is able to train deep neural networks to play many Atari games roughly as well as DQN, A3C, and ES (Table 1). Among the first set of 13 games we tried, DQN, ES and the GA produced the best score on 3 games, while A3C produced the best score on 4. On Skiing, the GA produced a score higher than any other algorithm published to date. On some games, the GA performance advantage over DQN, A3C, and ES is considerable (e.g. Frostbite, Venture, Skiing). Videos of policies evolved by the GA can be viewed here: anonymous. In a head-to-head comparisons, the GA performs better than ES, A3C, and DQN on 6 games each out of 13 (Tables 1 & 6).
+
+The GA also performs worse on many games, continuing a theme in deep RL where different families of algorithms perform differently across different domains Salimans et al. (2017). However, all such comparisons are preliminary because more computational resources are needed to gather sufficient sample sizes to see if the algorithms are significantly different per game; instead the key takeaway is that they all tend to perform roughly similarly in that each does well on different games.
+
+Because performance did not plateau in the GA runs, we test whether the GA improves further given additional computation. We thus run the GA six times longer (6B frames) and in all games, its score
+
+<table><tr><td></td><td>DQN</td><td>ES</td><td>A3C</td><td>RS 1B</td><td>GA 1B</td><td>GA 6B</td></tr><tr><td>Frames Time</td><td>200M ~7-10d</td><td>1B ~1h</td><td>1B ~4d</td><td>～ 1h or 4h</td><td>～ 1h or 4h</td><td>～ 6h or 24h</td></tr><tr><td>Forward Passes</td><td>450M</td><td>250M</td><td>250M</td><td>250M</td><td>250M</td><td>1.5B</td></tr><tr><td>Backward Passes</td><td>400M</td><td>0</td><td>250M</td><td>0</td><td>0</td><td>0</td></tr><tr><td>Operations</td><td>1.25B U</td><td>250MU</td><td>1B U</td><td>250MU</td><td>250MU</td><td>1.5B U</td></tr><tr><td>amidar</td><td>978</td><td>112</td><td>264</td><td>143</td><td>263</td><td>377</td></tr><tr><td>assault</td><td>4,280</td><td>1,674</td><td>5,475</td><td>649</td><td>714</td><td>814</td></tr><tr><td>asterix</td><td>4,359</td><td>1,440</td><td>22,140</td><td>1,197</td><td>1,850</td><td>2,255</td></tr><tr><td>asteroids</td><td>1,365</td><td>1,562</td><td>4,475</td><td>1,307</td><td>1,661</td><td>2,700</td></tr><tr><td>atlantis</td><td>279,987</td><td>1,267,410</td><td>911,091</td><td>26,371</td><td>76,273</td><td>129,167</td></tr><tr><td>enduro</td><td>729</td><td>95</td><td>-82</td><td>36</td><td>60</td><td>80</td></tr><tr><td>frostbite</td><td>797</td><td>370</td><td>191</td><td>1,164</td><td>4,536</td><td>6,220</td></tr><tr><td>gravitar</td><td>473</td><td>805</td><td>304</td><td>431</td><td>476</td><td>764</td></tr><tr><td>kangaroo</td><td>7,259</td><td>11,200</td><td>94</td><td>1,099</td><td>3,790</td><td>11,254</td></tr><tr><td>seaquest</td><td>5,861</td><td>1,390</td><td>2,355</td><td>503</td><td>798</td><td>850</td></tr><tr><td>skiing</td><td>-13,062</td><td>-15,443</td><td>-10,911</td><td>-7,679</td><td>-6,502</td><td>-5,541</td></tr><tr><td>venture</td><td>163</td><td>760</td><td>23</td><td>488</td><td>969</td><td>1,422</td></tr><tr><td>zaxxon</td><td>5,363</td><td>6,380</td><td>24,622</td><td>2,538</td><td>6,180</td><td>7,864</td></tr></table>
+
+Table 1: On Atari a simple genetic algorithm is competitive with Q-learning (DQN), policy gradients (A3C), and evolution strategies (ES). Shown are game scores (higher is better). Comparing performance between algorithms is inherently challenging (see main text), but we attempt to facilitate comparisons by showing estimates for the amount of computation (operations, the sum of forward and backward neural network passes), data efficiency (the number of game frames from training episodes), and how long in wall-clock time the algorithm takes to run. The ES, DQN, A3C, and GA (1B) perform best on 3, 3, 4, and 3 games, respectively. Thus, overall, each algorithm is best on a different subset of games, and all are in that sense competitive alternatives. The GA produced state-of-the-art results on Skiing. In a much larger set of games, these results qualitatively hold and, surprisingly, the GA can sometimes even outperform highly-sophisticated algorithms produced after years of intense research into improving DQN, such as Rainbow and Ape-X (SI Sec. 7.8). Interestingly, random search often finds policies superior to those of DQN, A3C, and ES (see text for discussion). Note the dramatic differences in the speeds of the algorithm, which are much faster for the GA and ES, and data efficiency, which favors DQN. The scores for DQN are from Hessel et al. (2017) while those for A3C and ES are from Salimans et al. (2017). For A3C, DQN, and ES, we cannot provide error bars because they were not reported in the original literature; GA and random search error bars are visualized in (SI Fig. 2). The wall-clock times are approximate because they depend on a variety of hard-to-control-for factors. We found the GA runs slightly faster than ES on average. GA 6B scores are bolded if best, but do not prevent bolding in other columns.
+
+improves (Table 1). With these post-6B-frame scores, the GA outperforms A3C, ES, and DQN on 7, 8, 7 of the 13 games in head-to-head comparisons, respectively (SI Table 6). In most games, the GA’s performance still has not converged at 6B frames (SI Fig. 2), leaving open the question of to how well the GA will ultimately perform when run even longer. To our knowledge, this $^ { 4 \mathbf { M } + }$ parameter neural network is the largest neural network ever evolved with a simple GA.
+
+In the expanded game set, all of the results described above qualitatively hold. On some games the GA also outperforms Rainbow Hessel et al. (2017) and Ape-X Horgan et al. (2018), two recent, powerful DQN enhancements produced after years of research by a large community into improving DQN (SI Sec. 7.8). The GA yields state-of the-art results on 6 games, including both sparse- and dense-reward games.
+
+One remarkable fact is how quickly the GA finds high-performing individuals. Because we employ a large population size (1K), each run lasts relatively few generations (min 348, max 1,834, SI Table 3). In many games, the GA finds a solution better than DQN in only one or tens of generations! Specifically, the median GA performance is higher than the final DQN performance in 1, 1, 3, 5, 11, and 29 generations for Skiing, Venture, Frostbite, Asteroids, Gravitar, and Zaxxon, respectively. Similar results hold for ES, where 1, 2, 3, 7, 12, and 25 GA generations were needed to outperform
+
+ES on Skiing, Frostbite, Amidar, Asterix, Asteroids, and Venture, respectively. The number of generations required to beat A3C were 1, 1, 1, 1, 1, 2, and 52 for Enduro, Frostbite, Kangaroo, Skiing, Venture, Gravitar, and Amidar, respectively.
+
+Each generation, the GA tends to make small-magnitude changes (controlled by $\sigma$ ) to the parameter vector (see Methods). That the GA outperforms DQN, A3C, and ES in so few generations – especially when it does so in the first generation (which is before a round of selection) – suggests that many high-quality policies exist near the origin (to be precise, in or near the region in which the random initialization function generates policies). That raises the question: is the GA doing anything more than random search?
+
+To answer this question, we evaluate many policies randomly generated by the GA’s initialization function $\phi$ and report the best score. We gave random search approximately the same amount of frames and computation as the GA and compared their performance (Table 1). In every game, the GA outperformed random search, and did so significantly on 9/13 games (Fig. 2, $p < 0 . 0 5$ , this and all future $p$ values are via a Wilcoxon rank-sum test). The improved performance suggests the GA is performing healthy optimization over generations.
+
+Surprisingly, given how celebrated and impressive DQN, ES and A3C are, out of 13 games random search actually outperforms DQN on 3 (Frostbite, Skiing, & Venture), ES on 3 (Amidar, Frostbite, & Skiing), and A3C on 6 (Enduro, Frostbite, Gravitar, Kangaroo, Skiing, & Venture). Interestingly, some of these policies produced by random search are not trivial, degenerate policies. Instead, they appear quite sophisticated. Consider the following example from the game Frostbite, which requires an agent to perform a long sequence of jumps up and down rows of icebergs moving in different directions (while avoiding enemies and optionally collecting food) to build an igloo brick by brick (SI Fig. 3). Only after the igloo is built can the agent enter the igloo to receive a large payoff. Over its first two lives, a policy found by random search completes a series of 17 actions, jumping down 4 rows of icebergs moving in different directions (while avoiding enemies) and back up again three times to construct an igloo. Then, only once the igloo is built, the agent immediately moves towards it and enters it, at which point it gets a large reward. It then repeats the entire process on a harder level, this time also gathering food and thus earning bonus points (video: anonymous). That policy resulted in a very high score of 3,620 in less than 1 hour of random search, vs. an average score of 797 produced by DQN after 7-10 days of optimization. One may think that random search found a lucky open loop sequence of actions overfit to that particular stochastic environment. Remarkably, we found that this policy actually generalizes to other initial conditions too, achieving a median score of 3,170 (with $9 5 \%$ bootstrapped median confidence intervals of $2 , 5 8 0 \AA - 3 , 1 7 0 )$ on 200 different test environments (each with up to 30 random initial no-ops, a standard testing procedure Hessel et al. (2017); Mnih et al. (2015)).
+
+These examples and the success of RS versus DQN, A3C, and ES suggest that many Atari games that seem hard based on the low performance of leading deep RL algorithms may not be as hard as we think, and instead that these algorithms for some reason are performing poorly on tasks that are actually quite easy. These results further suggest that sometimes the best search strategy is not to follow the gradient, but instead to conduct a dense search in a local neighborhood and select the best point found, a subject we return to in the discussion (Sec. 5).
+
+# 4.2 IMAGE HARD MAZE
+
+We also conducted an experiment to demonstrate a benefit of GAs working at DNN scales, which is that algorithms that were developed to improve GAs can be immediately taken off the shelf to improve DNN training. The example algorithm we chose is novelty search (NS), a popular evolutionary method for RL exploration Lehman and Stanley (2011b). We found that the GA plus NS can solve a high-dimensional robot control problem on which reward-maximizing algorithms (e.g. DQN, A3C, ES, and the GA) fail (SI Sec. 7.5).
+
+# 4.3 HUMANOID LOCOMOTION
+
+The GA was also able to solve the challenging continuous control benchmark of Humanoid Locomotion Brockman et al. (2016), which has validated modern, powerful algorithms such as A3C, TRPO, and ES. While the GA did produce robots that could walk well, it took ${ \sim } 1 5$ times longer to
+
+perform slightly worse than ES (SI Sec. 7.6), which is surprising because GAs have previously performed well on robot locomotion tasks Clune et al. (2011); Huizinga et al. (2016). Future research is required to understand why.
+
+# 5 DISCUSSION
+
+The surprising success of the GA and RS in domains thought to require at least some degree of gradient estimation suggests some heretofore under-appreciated aspects of high-dimensional search spaces. They imply that densely sampling in a region around the origin is sufficient in some cases to find far better solutions than those found by state-of-the-art, gradient-based methods even with far more computation or wall-clock time, suggesting that gradients do not point to these solutions, or that other optimization issues interfere with finding them, such as saddle points or noisy gradient estimates. The GA results further suggest that sampling in the region around good solutions is often sufficient to find even better solutions, and that a sequence of such discoveries is possible in many challenging domains. That result in turn implies that the distribution of solutions of increasing quality is unexpectedly dense, and that you do not need to follow a gradient to find them.
+
+Another, non-mutually exclusive hypothesis, is that GAs (and ES) have improved performance due to temporally extended exploration Osband et al. (2016), meaning they explore consistently because all actions in an episode are a function of the same set of mutated parameters, which improves exploration Plappert et al. (2017). This helps exploration for two reasons: (1) an agent takes the same action (or has the same distribution over actions) each time it visits the same state, which makes it easier to learn whether the policy in that state is advantageous, and (2) the agent is also more likely to have correlated actions across states (e.g. always go up) because mutations to its internal representations can affect the actions taken in many states similarly.
+
+Perhaps more interesting is the result that sometimes it is actually worse to follow the gradient than sample locally in the parameter space for better solutions. This scenario probably does not hold in all domains, or even in all the regions of a domain where it sometimes holds, but that it holds at all expands our conceptual understanding of the viability of different kinds of search operators. A reason GA might outperform gradient-based methods is if local optima are present, as it can jump over them in the parameter space, whereas a gradient method cannot (without additional optimization tricks such as momentum, although we note that ES utilized the modern ADAM optimizer in these experiments Kingma and Ba (2014), which includes momentum). One unknown question is whether GA-style local, gradient-free search is better early on in the search process, but switching to a gradient-based search later allows further progress that would be impossible, or prohibitively computationally expensive, for a GA to make. Another unknown question is the promise of simultaneously hybridizing GA methods with modern algorithms for deep RL, such as Q-learning, policy gradients, or evolution strategies.
+
+We still know very little about the ultimate promise of GAs versus competing algorithms for training deep neural networks on reinforcement learning problems. Additionally, here we used an extremely simple GA, but many techniques have been invented to improve GA performance Eiben et al. (2003); Haupt and Haupt (2004), including crossover Holland (1992); Deb and Myburgh (2016), indirect encoding Stanley (2007); Stanley et al. (2009); Clune et al. (2011), and encouraging quality diversity Mouret and Clune (2015); Pugh et al. (2016), just to name a few. Moreover, many techniques have been invented that dramatically improve the training of DNNs with backpropagation, such as residual networks He et al. (2015), SELU or RELU activation functions Krizhevsky et al. (2012); Klambauer et al. (2017), LSTMs or GRUs Hochreiter and Schmidhuber (1997); Cho et al. (2014), regularization Hoerl and Kennard (1970), dropout Srivastava et al. (2014), and annealing learning rate schedules Robbins and Monro (1951). We hypothesize that many of these techniques will also improve neuroevolution for large DNNs.
+
+Some of these enhancements may improve the GA performance on Humanoid Locomotion. For example, indirect encoding, which allows genomic parameters to affect multiple weights in the final neural network (in a way similar to convolution’s tied weights, but with far more flexibility), has been shown to dramatically improve performance and data efficiency when evolving robot gaits Clune et al. (2011). Those results were found with the HyperNEAT algorithm Stanley et al. (2009), which has an indirect encoding that abstracts the power of developmental biology Stanley (2007), and is a particularly promising direction for Humanoid Locomotion and Atari we are investigating.
+
+It will further be interesting to learn on which domains Deep GA tends to perform well or poorly and understand why. Also, GAs could help in other non-differentiable domains, such as architecture search Liu et al. (2017); Miikkulainen et al. (2017) and for training limited precision (e.g. binary) neural networks.
+
+# 6 CONCLUSION
+
+Our work introduces a Deep GA that competitively trains deep neural networks for challenging RL tasks, and an encoding technique that enables efficient distributed training and a state-of-the-art compact network encoding. We found that the GA is fast, enabling training Atari in ${ \sim } 4 \mathrm { h }$ on a single workstation or ${ \sim } 1 \mathrm { h }$ distributed on 720 CPUs. We documented that GAs are surprisingly competitive with popular algorithms for deep reinforcement learning problems, such as DQN, A3C, and ES, especially in the challenging Atari domain. We also showed that interesting algorithms developed in the neuroevolution community can now immediately be tested with deep neural networks, by showing that a Deep GA-powered novelty search can solve a deceptive Atari-scale game. It will be interesting to see future research investigate the potential and limits of GAs, especially when combined with other techniques known to improve GA performance. More generally, our results continue the story – started by backprop and extended with ES – that old, simple algorithms plus modern amounts of computation can perform amazingly well. That raises the question of what other classic algorithms should be revisited.
+
+# REFERENCES
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, pages 1097–1105, 2012.   
+Frank Seide, Gang Li, and Dong Yu. Conversational speech transcription using context-dependent deep neural networks. In Interspeech 2011. International Speech Communication Association, August 2011.   
+Christopher JCH Watkins and Peter Dayan. Q-learning. Machine learning, 8(3-4):279–292, 1992.   
+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–533, 2015.   
+Frank Sehnke, Christian Osendorfer, Thomas Ruckstieß, Alex Graves, Jan Peters, and J ¨ urgen ¨ Schmidhuber. Parameter-exploring policy gradients. Neural Networks, 23(4):551–559, 2010.   
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In ICML, pages 1928–1937, 2016.   
+Tim Salimans, Jonathan Ho, Xi Chen, and Ilya Sutskever. Evolution strategies as a scalable alternative to reinforcement learning. arXiv preprint arXiv:1703.03864, 2017.   
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992.   
+Daan Wierstra, Tom Schaul, Jan Peters, and Juergen Schmidhuber. Natural evolution strategies. In Evolutionary Computation, 2008. CEC 2008.(IEEE World Congress on Computational Intelligence). IEEE Congress on, pages 3381–3387. IEEE, 2008.   
+Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. J. Artif. Intell. Res.(JAIR), 47:253–279, 2013.   
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. OpenAI gym, 2016.   
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pages 5026–5033. IEEE, 2012.   
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In ICML, pages 1889–1897, 2015.   
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.   
+Razvan Pascanu, Yann N Dauphin, Surya Ganguli, and Yoshua Bengio. On the saddle point problem for non-convex optimization. arXiv preprint arXiv:1405.4604, 2014.   
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT press Cambridge, 1998.   
+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. arXiv preprint arXiv:1710.02298, 2017.   
+David B Fogel and Lauren C Stayton. On the effectiveness of crossover in simulated evolutionary optimization. BioSystems, 32(3):171–182, 1994.   
+Randy L Haupt and Sue Ellen Haupt. Practical genetic algorithms. John Wiley & Sons, 2004.   
+Jeff Clune, Kenneth O. Stanley, Robert T. Pennock, and Charles Ofria. On the performance of indirect encoding across the continuum of regularity. IEEE Transactions on Evolutionary Computation, 2011.   
+Jean-Baptiste Mouret and Stephane Doncieux. Overcoming the bootstrap problem in evolutionary robotics using behavioral diversity. In Proceedings of the IEEE Congress on Evolutionary Computation (CEC-2009), pages 1161–1168. IEEE, 2009.   
+Joel Lehman and Kenneth O. Stanley. Evolving a diversity of virtual creatures through novelty search and local competition. In GECCO, pages 211–218, Dublin, Ireland, 12-16 July 2011a. ACM. ISBN 978-1-4503-0557-0. doi: 10.1145/2001576.2001606.   
+Kenneth O. Stanley, David B. D’Ambrosio, and Jason Gauci. A hypercube-based indirect encoding for evolving large-scale neural networks. Artificial Life, 15(2):185–212, 2009.   
+Jean-Baptiste Mouret and Jeff Clune. Illuminating search spaces by mapping elites. ArXiv e-prints, abs/1504.04909, 2015. URL anonymous.   
+John H Holland. Genetic algorithms. Scientific american, 267(1):66–73, 1992.   
+Agoston E Eiben, James E Smith, et al. Introduction to evolutionary computing, volume 53. Springer, 2003.   
+Joel Lehman and Kenneth O. Stanley. Abandoning objectives: Evolution through the search for novelty alone. Evolutionary Computation, 19(2):189–223, 2011b.   
+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.   
+Arun Nair, Praveen Srinivasan, Sam Blackwell, Cagdas Alcicek, Rory Fearon, Alessandro De Maria, Vedavyas Panneershelvam, Mustafa Suleyman, Charles Beattie, Stig Petersen, et al. Massively parallel methods for deep reinforcement learning. arXiv preprint arXiv:1507.04296, 2015.   
+Hado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. In AAAI, pages 2094–2100, 2016.   
+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.   
+Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized experience replay. arXiv preprint arXiv:1511.05952, 2015.   
+Marc G Bellemare, Will Dabney, and Remi Munos. A distributional perspective on reinforcement ´ learning. arXiv preprint arXiv:1707.06887, 2017.   
+Meire Fortunato, Mohammad Gheshlaghi Azar, Bilal Piot, Jacob Menick, Ian Osband, Alex Graves, Vlad Mnih, Remi Munos, Demis Hassabis, Olivier Pietquin, et al. Noisy networks for exploration. arXiv preprint arXiv:1706.10295, 2017.   
+Joost Huizinga, Jean-Baptiste Mouret, and Jeff Clune. Does aligning phenotypic and genotypic modularity improve the evolution of neural networks? In GECCO, pages 125–132. ACM, 2016.   
+Ian Osband, Charles Blundell, Alexander Pritzel, and Benjamin Van Roy. Deep exploration via bootstrapped dqn. In NIPS, pages 4026–4034, 2016.   
+Matthias Plappert, Rein Houthooft, Prafulla Dhariwal, Szymon Sidor, Richard Y Chen, Xi Chen, Tamim Asfour, Pieter Abbeel, and Marcin Andrychowicz. Parameter space noise for exploration. arXiv preprint arXiv:1706.01905, 2017.   
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+Kalyanmoy Deb and Christie Myburgh. Breaking the billion-variable barrier in real-world optimization using a customized evolutionary algorithm. In GECCO, pages 653–660. ACM, 2016.   
+Kenneth O. Stanley. Compositional pattern producing networks: A novel abstraction of development. Genetic Programming and Evolvable Machines Special Issue on Developmental Systems, 8(2):131–162, 2007.   
+Justin K Pugh, Lisa B. Soros, and Kenneth O. Stanley. Quality diversity: A new frontier for evolutionary computation. 3(40), 2016. ISSN 2296-9144. URL anonymous.   
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015.   
+Gunter Klambauer, Thomas Unterthiner, Andreas Mayr, and Sepp Hochreiter. Self-normalizing ¨ neural networks. arXiv preprint arXiv:1706.02515, 2017.   
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.   
+Kyunghyun Cho, Bart Van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties ¨ of neural machine translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014.   
+Arthur E Hoerl and Robert W Kennard. Ridge regression: Biased estimation for nonorthogonal problems. Technometrics, 12(1):55–67, 1970.   
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014.   
+Herbert Robbins and Sutton Monro. A stochastic approximation method. The annals of mathematical statistics, pages 400–407, 1951.   
+Hanxiao Liu, Karen Simonyan, Oriol Vinyals, Chrisantha Fernando, and Koray Kavukcuoglu. Hierarchical representations for efficient architecture search. arXiv preprint arXiv:1711.00436, 2017.   
+Risto Miikkulainen, Jason Liang, Elliot Meyerson, Aditya Rawal, Dan Fink, Olivier Francon, Bala Raju, Arshak Navruzyan, Nigel Duffy, and Babak Hodjat. Evolving deep neural networks. arXiv preprint arXiv:1703.00548, 2017.   
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In NIPS, pages 2234–2242, 2016.   
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. ICML, pages 448–456. JMLR.org, 2015.   
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In ICAI, pages 249–256, 2010.   
+Joel Lehman, Jay Chen, Jeff Clune, and Kenneth O. Stanley. ES is more than just a traditional finite-difference approximator. arXiv preprint arXiv:1712.06568, 2017.   
+Edoardo Conti, Vashisht Madhavan, Felipe Petroski Such, Joel Lehman, Kenneth O. Stanley, and Jeff Clune. Improving exploration in evolution strategies for deep reinforcement learning via a population of novelty-seeking agents. arXiv preprint arXiv:1712.06560, 2017.   
+Yuhuai Wu, Elman Mansimov, Roger B Grosse, Shun Liao, and Jimmy Ba. Scalable trust-region method for deep reinforcement learning using kronecker-factored approximation. In NIPS, pages 5285–5294, 2017.   
+A. Cully, J. Clune, D. Tarapore, and J.-B. Mouret. Robots that can adapt like animals. Nature, 521: 503–507, 2015. doi: 10.1038/nature14422.   
+T. Salimans, J. Ho, X. Chen, S. Sidor, and I. Sutskever. Evolution Strategies as a Scalable Alternative to Reinforcement Learning. ArXiv e-prints, 1703.03864, March 2017.
+
+# 7 SUPPLEMENTARY INFORMATION
+
+# 7.1 WHY THE GA IS FASTER THAN ES
+
+The GA is faster than ES for two main reasons: (1) for every generation, ES must calculate how to update its neural network parameter vector $\theta$ . It does so via a weighted average across many (10,000 in Salimans et al. (2017)) pseudo-offspring (random $\theta$ perturbations) weighted by their fitness. This averaging operation is slow for large neural networks and large numbers of pseudooffspring (the latter is required for healthy optimization), and is not required for the Deep GA. (2) ES requires virtual batch normalization to generate diverse policies amongst the pseudo-offspring, which is necessary for accurate finite difference approximation Salimans et al. (2016). Virtual batch normalization requires additional forward passes for a reference batch–a random set of observations chosen at the start of training–to compute layer normalization statistics that are then used in the same manner as batch normalization Ioffe and Szegedy (2015). We found that the random GA parameter perturbations generate sufficiently diverse policies without virtual batch normalization and thus avoid these additional forward passes through the network.
+
+# Algorithm 1 Simple Genetic Algorithm
+
+<table><tr><td>Input: mutation function , population size N, number of selected individuals T, policy initial- ization routineΦ, fitness function F. for g=1, 2...,G generations do fori= 1,..,N-1 in next generation&#x27;s population do if g=1 then Pg=1 = (N(0,I)) {initialize random DNN} else k =uniformRandom(1,T) {select parent} P = ψ(Pg-1) {mutate parent}</td></tr></table>
+
+# 7.2 HYPERPARAMETERS
+
+We use Xavier initialization Glorot and Bengio (2010) as our policy initialization function $\phi$ where all bias weights are set to zero, and connection weights are drawn from a standard normal distribution with variance $1 / N _ { i n }$ , where $N _ { i n }$ is the number of incoming connections to a neuron.
+
+# 7.3 ADDITIONAL INFORMATION ABOUT THE DEEP GA COMPACT ENCODING METHOD
+
+The compact encoding technique is based on the principle that the seeds need only be long enough to generate a unique mutation vector per offspring per parent. If any given parent $\theta ^ { n - 1 }$ produces at most $x$ offspring, then $\tau _ { n }$ in Eq. 1 can be as small as a $l o g _ { 2 } ( x )$ -bit number. $\tau _ { 0 }$ is a special case that needs one unique seed for each of the $\textit { N } \theta$ vectors in generation 0, and can thus be encoded with $l o g _ { 2 } ( N )$ bits. The reason the seed bit-length can be vastly smaller than the search space size is because not every point in the search space is a possible offspring of $\theta ^ { n }$ , and we only need to be able generate offspring randomly (we do not need to be able to reach any point in the search space
+
+# Algorithm 2 Novelty Search (GA-NS)
+
+Input: mutation function $\psi$ , population size $N$ , number of selected individuals $T$ , policy initialization routine $\phi$ , empty archive $\mathcal { A }$ , archive insertion probability $p$ , a novelty function $\eta$ , a behavior characteristic function $B C$ .
+
+for $g = 1 , 2 . . . , G$ generations do for $i = 2 , . . . , N$ in next generation’s population do if $g = 1$ then $\mathcal { P } _ { i } ^ { g = 1 } = \phi ( \mathcal { N } ( 0 , I ) )$ {initialize random DNN} else $k =$ uniformRandom $( 1 , T )$ {select parent} $\mathcal { P } _ { i } ^ { g } = \psi ( \mathcal { P } _ { k } ^ { g - 1 } )$ {mutate parent} end if $B C _ { i } ^ { g } = B C ( \mathcal { P } _ { i } ^ { g } )$ end for Copy $\mathcal { P } _ { 1 } ^ { g }  \mathcal { P } _ { 1 } ^ { g - 1 }$ ; $B C _ { 1 } ^ { g }  B C _ { 1 } ^ { g - 1 }$ for $i = 1 , . . . , N$ in next generation’s population do Evaluate $F _ { i } = \eta ( B C _ { i } ^ { \check { g } } , ( A \cup B C ^ { \hat { g } } ) \overset { \cdot } { - } \{ B C _ { i } ^ { g } \} )$ if $i > 1$ then Add $B C _ { i } ^ { g }$ to $\mathcal { A }$ with probability $p$ end if end for Sort $\mathcal { P } _ { i } ^ { g }$ with descending order by $F _ { i }$   
+end for   
+Return: Elite
+
+<table><tr><td>Hyperparameter</td><td>Humanoid Locomotion</td><td>Image Hard Maze</td><td>Atari</td></tr><tr><td>Population Size (N)</td><td>12,500+1</td><td>20,000+1</td><td>1,000+1</td></tr><tr><td>Mutation Power (σ)</td><td>0.00224</td><td>0.005</td><td>0.002</td></tr><tr><td>Truncation Size (T)</td><td>625</td><td>61</td><td>20</td></tr><tr><td>Numberof Trials</td><td>5</td><td>1</td><td>1</td></tr><tr><td>Archive Probability</td><td></td><td>0.01</td><td></td></tr></table>
+
+Table 2: Hyperparameters. Population sizes are incremented to account for elites $( + 1 )$ . Many of the unusual numbers were found via preliminary hyperparameter searches in other domains.
+
+in one random step). However, because we perform $n$ random mutations to produce $\theta ^ { n }$ , the process can reach many points in the search space.
+
+However, to truly be able to reach every point in the search space we need our set of mutation vectors to span the search space, meaning we need the seed to be at least $l o g _ { 2 } ( | \theta | )$ bits. To do so we can use a function $\mathcal { H } ( \theta , \tau )$ that maps a given $( \theta , \tau _ { n } )$ -pair to a new seed and applies it as such:
+
+$$
+\psi ( \theta ^ { n - 1 } , \tau _ { n } ) = \theta ^ { n - 1 } + \varepsilon ( \mathcal { H } ( \theta ^ { n - 1 } , \tau _ { n } ) )
+$$
+
+Note that in this case there are two notions of seeds. The encoding is a series of small $\tau$ seeds, but each new seed $\tau$ is generated from the parent $\theta$ and the previous seed.
+
+# 7.4 ADDITIONAL EXPERIMENTAL DETAILS FOR THE IMAGE HARD MAZE
+
+For temporal context, the current frame and previous three frames are all input at each timestep, following Mnih et al. (2015). The outputs remain the same as in the original Hard Maze problem formulation in Lehman and Stanley (2011b). Unlike the Atari domain, the Image Hard Maze environment is deterministic and does not need multiple evaluations of the same policy.
+
+Following Lehman and Stanley (2011b), the BC is the $( x , y )$ position of the robot at the end of the episode (400 timesteps), and the behavioral distance function is the squared Euclidean distance between these final $( x , y )$ positions. The simulator ignores forward or backward motion that would result in the robot penetrating walls, preventing a robot from sliding along a wall, although rotational motor commands still have their usual effect in such situations.
+
+Table 3: The number of generations at which the GA reached 6B frames.   
+
+<table><tr><td>Game</td><td>Minimum Generations</td><td>Median Generations</td><td>Maximum Generations</td></tr><tr><td>amidar</td><td>1325</td><td>1364</td><td>1541</td></tr><tr><td>assault</td><td>501</td><td>707</td><td>1056</td></tr><tr><td>asterix</td><td>494</td><td>522</td><td>667</td></tr><tr><td>asteroids</td><td>1096</td><td>1209</td><td>1261</td></tr><tr><td>atlantis</td><td>507</td><td>560</td><td>580</td></tr><tr><td>enduro</td><td>348</td><td>348</td><td>348</td></tr><tr><td>frostbite</td><td>889</td><td>1016</td><td>1154</td></tr><tr><td>gravitar</td><td>1706</td><td>1755</td><td>1834</td></tr><tr><td>kangaroo</td><td>688</td><td>787</td><td>862</td></tr><tr><td>seaquest</td><td>660</td><td>678</td><td>714</td></tr><tr><td>skiing</td><td>933</td><td>1237</td><td>1281</td></tr><tr><td>venture</td><td>527</td><td>606</td><td>680</td></tr><tr><td>zaxxon</td><td>765</td><td>810</td><td>823</td></tr></table>
+
+![](images/a56d95e0275e5c1b47fdd67edb3b345a940983fb21d02c733d99249be35790ff.jpg)  
+Figure 1: Visual representation of the Deep GA encoding method. From a randomly initialized parameter vector $\theta ^ { 0 ^ { \circ } }$ (produced by an initialization function $\phi$ seeded by $\tau _ { 0 }$ ), the mutation function $\psi$ (seeded by $\tau _ { 1 }$ ) applies a mutation that results in $\theta ^ { 1 }$ . The final parameter vector $\theta ^ { g }$ is the result of a series of such mutations. Recreating $\theta ^ { g }$ can be done by applying the mutation steps in the same order. Thus, knowing the series of seeds $\tau _ { 0 } . . . \tau _ { g }$ that produced this series of mutations is enough information to reconstruct $\theta ^ { g }$ (the initialization and mutation functions are deterministic). Since each $\tau$ is small (here, 28 bits long), and the number of generations is low (order hundreds or thousands), a large neural network parameter vector can be stored compactly.
+
+# 7.5 IMAGE HARD MAZE
+
+This experiment seeks to demonstrate a benefit of GAs working at DNN scales, which is that algorithms that were developed to improve GAs can be immediately taken off the shelf to improve DNN training. The example algorithm is novelty search (NS), which is a popular evolutionary method for exploration in RL Lehman and Stanley (2011b).
+
+NS was originally motivated by the Hard Maze domain Lehman and Stanley (2011b), which is a staple in the neuroevolution community. It demonstrates the problem of local optima (aka deception) in reinforcement learning. In it, a robot receives more reward the closer it gets to the goal as the crow flies. The problem is deceptive because greedily getting closer to the goal leads an agent to permanently get stuck in one of the map’s deceptive traps (Fig. 5, Left). Optimization algorithms that do not conduct sufficient exploration suffer this fate. NS solves this problem because it ignores the reward and encourages agents to visit new places Lehman and Stanley (2011b).
+
+![](images/dbbbc8bd3317c2d600134b8d9fbcd0b843f20e36b4c8d8b85777f2a839b39bd4.jpg)  
+Figure 2: GA and random search performance across generations on Atari 2600 games. The performance of the GA and random search compared to DQN, A3C, and ES depends on the game. We plot final scores (as dashed lines) for DQN, A3C, and ES because we do not have their performance values across training and because they trained on different numbers of game frames (SI Table 1). For GA and RS, we report the median and $9 5 \%$ bootstrapped confidence intervals of the median across 5 experiments of the current elite per run, where the score for each elite is a mean of 30 independent episodes.
+
+The original version of this problem involves only a few inputs (radar sensors to sense walls) and two continuous outputs for speed (forward or backward) and rotation, making it solvable by small neural networks (tens of connections). Because here we want to demonstrate the benefits of NS at the scale of deep neural networks, we introduce a new version of the domain called Image Hard Maze. Like many Atari games, it shows a bird’s-eye view of the world to the agent in the form of an $8 4 \times 8 4$ pixel image (Fig. 5, Left). This change makes the problem easier in some ways (e.g. now it is fully observable), but harder in others because it is much higher-dimensional: the neural network must learn to process this pixel input and take actions. SI Sec. 7.4 has additional experimental details.
+
+We confirm that the results that held for small neural networks on the original, radar-based version of this task also hold for the high-dimensional, visual version of this task with deep neural networks. With a $^ { 4 \mathbf { M } + }$ parameter network processing pixels, the GA-based novelty search (GA-NS) is able to solve the task by finding the goal (Fig. 5). The GA optimizes for reward only and, as expected, gets stuck in the local optima of Trap 2 (SI Fig. 4) and thus fails to solve the problem (Fig. 5), significantly underperforming GA-NS $( p \ < 0 . 0 0 1 )$ . Our results confirm that we are able to use exploration methods such as novelty search to solve this sort of deception, even in high-dimensional problems such as those involving learning directly from pixels. This is the largest neural network optimized by novelty search to date by three orders of magnitude. In a paper published concurrently with ours, Conti et al. (2017) demonstrate a similar finding, by hybridizing novelty search with ES to create NS-ES, and show that it too can help deep neural networks avoid deception in challenging RL benchmark domains.
+
+![](images/72ceb5e75affe0ceed3ce26d7760a85ab830a29d14c13709e8104189146d346f.jpg)  
+Figure 3: Example of high-performing individual on Frostbite found through random search. See main text for a description of the behavior of this policy. Its final score is 3,620 in this episode, which is far higher than the scores produced by DQN, A3C and ES, although not as high as the score found by the GA (Table 1).
+
+As expected, ES also fails to solve the task because it focuses solely on maximizing reward (Fig. 5 & SI Fig. 4). We also test Q-learning (DQN) and policy gradients on this problem. We did not have source code for A3C, but were able to obtain source code for A2C, which has similar performance Wu et al. (2017): the only difference is that it is synchronous instead of asynchronous. For these experiments we modified the rewards of the domain to step-by-step rewards (the negative change in distance to goal since the last time-step), but for plotting purposes, we record the final distance to the goal. Having per-step rewards is standard for these algorithms and provides more information, but does not remove the deception. Because DQN requires discrete outputs, for it we discretize each of the two continuous outputs into to five equally sized bins. To enable all possible output combinations, it learns $5 ^ { 2 } = 2 5$ Q-values.
+
+Also as expected, DQN and A2C fail to solve this problem (Fig. 5, SI Fig. 4). Their default exploration mechanisms are not enough to find the global optimum given the deceptive reward function in this domain. DQN is drawn into the expected Trap 2. For unclear reasons, even though A2C visits Trap 2 often early in training, it converges on getting stuck in a different part of the maze. Of course, exploration techniques could be added to these controls to potentially make them perform as well as GA-NS. Here we only sought to show that the Deep GA allows algorithms developed for small-scale neural networks can be harnessed on hard, high-dimensional problems that require DNNs.
+
+In future work, it will be interesting to combine NS with a Deep GA on more domains, including Atari and robotics domains. More importantly, our demonstration suggests that other algorithms that enhance GAs can now be combined with DNNs. Perhaps most promising are those that combine a notion of diversity (e.g. novelty) and quality (i.e. being high performing), seeking to collect a set of high-performing, yet interestingly different policies Mouret and Clune (2015); Lehman and Stanley (2011a); Cully et al. (2015); Pugh et al. (2016). The results also motivate future research into combining deep RL algorithms (e.g. DQN, A3C) with novelty search and quality diversity algorithms.
+
+# 7.6 HUMANOID LOCOMOTION
+
+We tested the GA on a challenging continuous control problem, specifically humanoid locomotion. We test with the MuJoCo Humanoid-v1 environment in OpenAI Gym Todorov et al. (2012); Brockman et al. (2016), which involves a simulated humanoid robot learning to walk. Solving this problem has validated modern, powerful algorithms such as A3C Mnih et al. (2016), TRPO Schulman et al. (2015), and ES Salimans et al. (2017).
+
+This problem involves mapping a vector of 376 scalars that describe the state of the humanoid (e.g. its position, velocity, angle) to 17 joint torques. The robot receives a scalar reward that is a combination of four components each timestep. It gets positive reward for standing and its velocity in the positive $x$ direction, and negative reward the more energy it expends and for how hard it impacts the ground. These four terms are summed over every timestep in an episode to calculate the total reward.
+
+To stabilize training, we normalize each dimension of the input by subtracting its mean and dividing by its standard deviation, which are computed from executing 10,000 random policies in the environment. We also applied annealing to the mutation power $\sigma$ , decreasing it to 0.001 after 1,000 generations, which resulted in a small performance boost at the end of training. The full set of hyperparameters are listed in SI Table 2.
+
+For these experiments we ran 5 independent, randomly initialized, runs and report the median of those runs. During the elite selection routine we did not reevaluate offspring 30 times like on the Atari experiments. That is because we ran these experiments before the Atari experiments, and we improved our evaluation methods after these experiments were completed. We did not have the computational resources to re-run these experiments with the changed protocol, but we do not believe this change would qualitatively alter our results. We also used the normalized columns initialization routine of Salimans et al. (2017) instead of Xavier initialization, but we found them to perform qualitatively similarly. When determining the fitness of each agent we evaluate the mean over 5 independent episodes. After each generation, for plotting purposes only, we evaluate the elite 30 times.
+
+The architecture has two 256-unit hidden layers with tanh activation functions. This architecture is the one in the configuration file included in the source code released by Salimans et al. (2017). The architecture described in their paper is similar, but smaller, having 64 neurons per layer Salimans et al. (2017). Although relatively shallow by deep learning standards, and much smaller than the Atari DNNs, this architecture still contains ${ \sim } 1 6 7 \mathrm { k }$ parameters, which is orders of magnitude greater than the largest neural networks evolved for robotics tasks that we are aware of, which contained 1,560 Huizinga et al. (2016) and before that 800 parameters Clune et al. (2011). Many assumed evolution would fail at larger scales (e.g. networks with hundreds of thousands or millions of weights, as in this paper).
+
+Previous work has called the Humanoid-v1 problem solved with a score of ${ \sim } 6 { , } 0 0 0$ Salimans et al. (2017). The GA achieves a median above that level after $\sim 1 { , } 5 0 0$ generations. However, it requires far more computation than ES to do so (ES requires ${ \sim } 1 0 0$ generations for median performance to surpass the 6,000 threshold). It is not clear why the GA requires so much more computation, especially given how quickly the GA found high-performing policies in the Atari domain. It is also surprising that the GA does not excel at this domain, given that GAs have performed well in the past on robot control tasks Clune et al. (2011). While the GA needs far more computation in this domain, it is interesting nevertheless that it does eventually solve it by producing an agent that can walk and score over 6,000. Considering its very fast discovery of high-performing solutions in Atari, clearly the GA’s advantage versus other methods depends on the domain, and understanding this dependence is an important target for future research.
+
+# 7.7 THE MEANING OF “FRAMES”
+
+Many papers, including ours, report the number of “frames” used during training. However, it is a bit unclear in the literature what is meant exactly by this term. We hope to introduce some terminology that can lend clarity to this confusing issue, which will improve reproducibility and our ability to compare algorithms fairly. Imagine if the Atari-emulator emitted 4B frames during training. We suggest calling these “game frames.” One could sub-sample every 4th frame (indeed, due to “frame skip”, most Atari papers do exactly this, and repeat the previous action for each skipped frame), resulting in 1B frames. We suggest calling these 1B frames “training frames”, as these are the frames the algorithm is trained on. In our paper we report the game frames used by each algorithm. Via personal communication with scientists at OpenAI and DeepMind, we confirmed that we are accurately reporting the number of frames (and that they are game frames, not training frames) used by DQN, A3C, and ES in Mnih et al. (2015), Mnih et al. (2016), and Salimans et al. (2017), respectively.
+
+Table 4: Head-to-head comparison between algorithms on the 13 Atari games. Each value represents how many games for which the algorithm listed at the top of a column produces a higher score than the algorithm listed to the left of that row (e.g. GA 6B beats DQN on 7 games).   
+
+<table><tr><td></td><td>DQN</td><td>ES</td><td>A3C</td><td>RS 1B</td><td>GA 1B</td><td>GA 6B</td></tr><tr><td>DQN</td><td></td><td>6</td><td>6</td><td>3</td><td>6</td><td>7</td></tr><tr><td>ES</td><td>7</td><td></td><td>7</td><td>3</td><td>6</td><td>8</td></tr><tr><td>A3C</td><td>7</td><td>6</td><td></td><td>6</td><td>6</td><td>7</td></tr><tr><td>RS1B</td><td>10</td><td>10</td><td>7</td><td></td><td>13</td><td>13</td></tr><tr><td>GA 1B</td><td>7</td><td>7</td><td>7</td><td>0</td><td></td><td>13</td></tr><tr><td>GA 6B</td><td>6</td><td>5</td><td>6</td><td>0</td><td>0</td><td></td></tr></table>
+
+There is one additional clarification. In all of the papers just mentioned and for the GA in this paper, the input to the network for Atari is the current framet and three previous frames. These three previous frames are from the training frame set, meaning that if $t$ counts each game frame then the input to the network is the following: game framet, frame $\mathrm { : _ { t - 4 } }$ , framet-8, and framet-12.
+
+# 7.8 EXPERIMENTS ON AN EXPANDED SET OF ATARI GAMES AND COMPARISONS AGAINST MODERN, POWERFUL DQN VARIANTS (RAINBOW AND APE-X)
+
+To test whether our results hold on a larger set of Atari games, we extended our experiments to the full 57-game set of Atari games used in two recent, famous papers that described enhancements to DQN, each of which improved the state of the art when published: Rainbow Hessel et al. (2017) and an algorithm that came out after our paper was published on arXiv, Ape-X Horgan et al. (2018). Two of the games did not run due to a bug in OpenAI’s Gym Brockman et al. (2016), leaving us with 55 total games. This set is a superset of the games from Mnih et al. (2015). We also added performance comparisons to two strong, recent DQN variants. For these experiments, the score within each run was a median over many (200) evaluations of the policy, instead of the mean (as done for our original 13 games), which we switched to because it is more robust to outliers: doing so lowers the scores somewhat because extreme outliers tend to be very high scores. The results can be seen in Table 5 and head-to-head tallies are in Table 6.
+
+On this much larger set of games, the overall qualitative conclusions of our paper remain unchanged: the simple GA is roughly even with simple RL algorithms such as A3C and DQN, and ES, in that all of these algorithms can learn to play many Atari games well, and each is best on a subset of the games. The GA, which most assumed would not work at all at optimizing large, deep, multimillion parameter neural networks, especially in comparison to DQN and A3C, achieves superior performance to DQN and A3C on $43 \%$ (22 of 51, tying on 1) and $49 \%$ (27 of 55) games, respectively. Additionally, the GA achieves state of the art results on 6 games (bowling, centipede, private eye, skiing, solaris). The GA also also exhibits super-human performance on $43 \%$ of games (and is the only algorithm we are aware of with super-human performance on bowling). Each game is idiosyncratic, and could be considered a separate domain. Because the GA is roughly as good as some of the most famous Deep RL algorithms (DQN, A3C, and ES), and far better on some games, it is a valuable additional tool to have in our toolbox. When compared against Rainbow Hessel et al. (2017), which combines many of the best innovations built on top of DQN over years by a large research community, the GA still performs better on some games (it wins 11 of 52, ties on 2, and loses on 39: Table 6). The same is true when comparing against the Ape-X algorithm Horgan et al. (2018), which is a very recent, powerful version of prioritized DQN Schaul et al. (2015) (prioritized DQN is already an important improvement over the simple DQN) with a large number of distributed data-gathering agents each running epsilon-greedy exploration with different epsilons: the large amount of data generated and the different epsilons help with exploration and learning. Ape-X still underperforms the GA on 7 games. As discussed at more length in the main text, the Deep GA thus provides an interesting alternative algorithm to have added to the toolbox for deep RL problems: It may be practically helpful on any given domain, raises interesting new research questions into why it succeeds where other algorithms fail (and vice versa), and because we tested such a simple GA it is still unknown how its performance will compare to other algorithms once enhancements known to improve GA performance Fogel and Stayton (1994); Haupt and Haupt (2004); Clune et al. (2011); Mouret and Doncieux (2009); Lehman and Stanley (2011a); Stanley et al. (2009); Mouret and Clune (2015) are added to it.
+
+![](images/4d051f661d113ec8a50c9e06b73639939df85d888c5b426feb3de650d75d2d1b.jpg)  
+Figure 4: How different algorithms explore the deceptive Image Hard Maze over time. Traditional reward-maximization algorithms do not exhibit sufficient exploration to avoid the local optimum (of going up into Trap 2, as shown in Fig. 5). In contrast, a GA optimizing for novelty only (GA-NS) explores the entire environment and ultimately finds the goal. For the evolutionary algorithms (GA-NS, GA, ES), blue crosses represent the population (pseudo-offspring for ES), red crosses represent the top $T$ GA offspring, orange dots represent the final positions of GA elites and the current mean ES policy, and the black crosses are entries in the GA-NS archive. All 3 evolutionary algorithms had the same number of evaluations, but ES and the GA have many overlapping points because they revisit locations due to poor exploration, giving the illusion of fewer evaluations. For DQN and A2C, we plot the end-of-episode position of the agent for each of the 20K episodes prior to the checkpoint listed above the plot. It is surprising that ES significantly underperforms the GA $( p < 0 . 0 0 1 )$ . In 8 of 10 runs it gets stuck near Trap 1, not because of deception, but instead seemingly because it cannot reliably learn to pass through a small bottleneck corridor. This phenomenon has never been observed with population-based GAs on the Hard Maze, suggesting the ES (at least with these hyperparameters) is qualitatively different than GAs in this regard Lehman et al. (2017). We believe this difference occurs because ES optimizes for the average reward of the population sampled from a probability distribution. Even if the maximum fitness of agents sampled from that distribution is higher further along a corridor, ES will not move in that direction if the population average is lower (e.g. if other policies sampled from the distribution crash into the walls, or experience other low-reward fates) Lehman et al. (2017). Note, however, that even when ES moved through this bottleneck (2 out of 10 runs), because it is solely reward-driven, it got stuck in Trap 2.
+
+![](images/c1cd96e1474a082bcda7164c1782446b82bf9ac395dbf2a21a02b3452811bc64.jpg)  
+Figure 5: Image Hard Maze Domain and Results. Left: A small wheeled robot must navigate to the goal with this bird’s-eye view as pixel inputs. The robot starts in the bottom left corner facing right. Right: novelty search can train deep neural networks to avoid local optima that stymie other algorithms. The GA, which solely optimizes for reward and has no incentive to explore, gets stuck on the local optimum of Trap 2. The GA optimizing for novelty (GA-NS) is encouraged to ignore reward and explore the whole map, enabling it to eventually find the goal. ES performs even worse than the GA, as discussed in the main text. DQN and A2C also fail to solve this task. For ES, the performance of the mean $\theta$ policy each iteration is plotted. For GA and GA-NS, the performance of the highest-scoring individual per generation is plotted. Because DQN and A2C do not have the same number of evaluations per iteration as the evolutionary algorithms, we plot their final median reward as dashed lines. SI Fig. 4 shows the behavior of these algorithms during training.
+
+Table 5: Extended Atari results. For SOTA counts, we include ties as a point in that column (e.g. Rainbow, ES, and the GA get a point for Pitfall). Games for which scores are not reported in other papers are left blank and do not factor into head-to-head tallies. 22   
+
+<table><tr><td></td><td>Human</td><td>DQN</td><td>Rainbow</td><td>Ape-X</td><td>A3C</td><td>ES</td><td>GA 6B</td></tr><tr><td>alien</td><td>6,875.0</td><td>1,620.0</td><td>9,491.7</td><td>40,804.9</td><td>518.4</td><td></td><td>1,990.0</td></tr><tr><td>amidar</td><td>1,676.0</td><td>978.0</td><td>5,131.2</td><td>8,659.2</td><td>263.9</td><td>112.0</td><td>370.0</td></tr><tr><td>assault</td><td>1,496.0</td><td>4,280.0</td><td>14,198.5</td><td>24,559.4</td><td>5,474.9</td><td>1,673.9</td><td>898.0</td></tr><tr><td>asterix</td><td>8,503.0</td><td>4,359.0</td><td>428,200.3</td><td>313,305.0</td><td>22,140.5</td><td>1,440.0</td><td>1,800.0</td></tr><tr><td>asteroids</td><td>13,157.0</td><td>1,364.5</td><td>2,712.8</td><td>155,495.1</td><td>4,474.5</td><td>1,562.0</td><td>1,940.0</td></tr><tr><td>atlantis</td><td>29,028.0</td><td>279,987.0</td><td>826,659.5</td><td>944,497.5</td><td>911,091.0</td><td>1,267,410.0</td><td>57,300.0</td></tr><tr><td>bank_heist</td><td>734.4</td><td>455.0</td><td>1,358.0</td><td>1,716.4</td><td>970.1</td><td>225.0</td><td>270.0</td></tr><tr><td>battle_zone</td><td>37,800.0</td><td>29,900.0</td><td>62,010.0</td><td>98,895.0</td><td>12,950.0</td><td>16,600.0</td><td>25,000.0</td></tr><tr><td>beam_rider</td><td>5,775.0</td><td>8,627.5</td><td>16,850.2</td><td>63,305.2</td><td>22,707.9</td><td>744.0</td><td>756.0</td></tr><tr><td>berzerk</td><td></td><td>585.6</td><td>2,545.6</td><td>57,196.7</td><td>817.9</td><td>686.0</td><td>1,440.0</td></tr><tr><td>bowling</td><td>154.8</td><td>50.4</td><td>30.0</td><td>17.6</td><td>35.1</td><td>30.0</td><td>197.0</td></tr><tr><td>boxing</td><td>4.3</td><td>88.0</td><td>99.6</td><td>100.0</td><td>59.8</td><td>49.8</td><td>64.0</td></tr><tr><td>breakout</td><td>31.8</td><td>385.5</td><td>417.5</td><td>800.9</td><td>681.9</td><td>9.5</td><td>10.0</td></tr><tr><td>centipede</td><td>11,963.0</td><td>4,657.7</td><td>8,167.3</td><td>12,974.0</td><td>3,755.8</td><td>7,783.9</td><td>14,122.0</td></tr><tr><td>chopper_command</td><td>9,882.0</td><td>6,126.0</td><td>16,654.0</td><td>721,851.0</td><td>7,021.0</td><td>3,710.0</td><td>3,500.0</td></tr><tr><td>crazy_climber</td><td>35,411.0</td><td>110,763.0</td><td>168,788.5</td><td>320,426.0</td><td>112,646.0</td><td>26,430.0</td><td>38,000.0</td></tr><tr><td>demon_attack</td><td>3,401.0</td><td>12,149.4</td><td>111,185.2</td><td>133,086.4</td><td>113,308.4</td><td>1,166.5</td><td>970.0</td></tr><tr><td>double_dunk</td><td>-15.5</td><td>-6.6</td><td>-0.3</td><td>23.5</td><td>-0.1</td><td>0.2</td><td>0.0</td></tr><tr><td>enduro</td><td>309.6</td><td>729.0</td><td>2,125.9</td><td>2,177.4</td><td>-82.5</td><td>95.0</td><td>51.0</td></tr><tr><td>fishing_derby</td><td>5.5</td><td>-4.9</td><td>31.3</td><td>44.4</td><td>18.8</td><td>49.0</td><td>-33.0</td></tr><tr><td>freeway</td><td>29.6</td><td>30.8</td><td>34.0</td><td>33.7</td><td>0.1</td><td>31.0</td><td>26.0</td></tr><tr><td>frostbite</td><td>4,335.0</td><td>797.4</td><td>9,590.5</td><td>9,328.6</td><td>190.5</td><td>370.0</td><td>4,460.0</td></tr><tr><td>gopher</td><td>2,321.0</td><td>8,777.4</td><td>70,354.6</td><td>120,500.9</td><td>10,022.8</td><td>582.0</td><td>1,200.0</td></tr><tr><td>gravitar</td><td>2,672.0</td><td>473.0</td><td>1,419.3</td><td>1,598.5</td><td>303.5</td><td>805.0</td><td>700.0</td></tr><tr><td>hero</td><td>25,763.0</td><td>20,437.8</td><td>55,887.4</td><td>31,655.9</td><td>32,464.1</td><td></td><td>18,220.0</td></tr><tr><td>ice_hockey</td><td>0.9</td><td>-1.9</td><td>1.1</td><td>33.0</td><td>-2.8</td><td>4.1</td><td>2.0</td></tr><tr><td>jamesbond</td><td>406.7</td><td></td><td></td><td>21,322.5</td><td>541.0</td><td></td><td>650.0</td></tr><tr><td>kangaroo</td><td>3,035.0</td><td>7,259.0</td><td>14,637.5</td><td>1,416.0</td><td>94.0</td><td>11,200.0</td><td>11,200.0</td></tr><tr><td>krull</td><td>2,395.0</td><td>8,422.3</td><td>8,741.5</td><td>11,741.4</td><td>5,560.0</td><td>8,647.2</td><td>10,889.0</td></tr><tr><td>kung_fu_master</td><td>22,736.0</td><td>26,059.0</td><td>52,181.0</td><td>97,829.5</td><td>28,819.0</td><td></td><td>62,000.0</td></tr><tr><td>montezuma_revenge</td><td>4,367.0</td><td>0.0</td><td>384.0</td><td>2,500.0</td><td>67.0</td><td>0.0</td><td>0.0</td></tr><tr><td>ms-pacman</td><td>15,693.0</td><td>3,085.6</td><td>5,380.4</td><td>11,255.2</td><td>653.7</td><td></td><td>3,410.0</td></tr><tr><td>name_this_game</td><td>4,076.0</td><td>8,207.8</td><td>13,136.0</td><td>25,783.3</td><td>10,476.1</td><td>4,503.0</td><td>7,210.0</td></tr><tr><td>phoenix</td><td></td><td>8,485.2</td><td>108,528.6</td><td>224,491.1</td><td>52,894.1</td><td>4,041.0</td><td>3,810.0</td></tr><tr><td>pitfall</td><td></td><td>-286.1</td><td>0.0</td><td>-0.6</td><td>-78.5</td><td>0.0</td><td>0.0</td></tr><tr><td>pong</td><td>9.3</td><td>19.5</td><td>20.3</td><td>20.9</td><td>5.6</td><td>21.0</td><td>-20.0</td></tr><tr><td>private_eye</td><td>69,571.0</td><td>146.7</td><td>4,234.0</td><td>49.8</td><td>206.9</td><td>100.0</td><td>15,200.0</td></tr><tr><td>qbert</td><td>13,455.0</td><td>13,117.3</td><td>33,817.5</td><td>302,391.3</td><td>15,148.8</td><td>147.5</td><td>5,125.0</td></tr><tr><td>riverraid</td><td>13,513.0</td><td></td><td></td><td>63,864.4</td><td>12,201.8</td><td>5,009.0</td><td>3,410.0</td></tr><tr><td>road_runner</td><td>7,845.0</td><td>39,544.0</td><td>62,041.0</td><td>222,234.5</td><td>34,216.0</td><td>16,590.0</td><td>15,900.0</td></tr><tr><td>robotank</td><td>11.9</td><td>63.9</td><td>61.4</td><td>73.8</td><td>32.8</td><td>11.9</td><td>16.0</td></tr><tr><td>seaquest</td><td>20,182.0</td><td>5,860.6</td><td>15,898.9</td><td>392,952.3</td><td>2,355.4</td><td>1,390.0</td><td>1,020.0</td></tr><tr><td>skiing</td><td></td><td>-13,062.3</td><td>-12,957.8</td><td>-10,789.9</td><td>-10,911.1</td><td>-15,442.5</td><td>-5,564.0</td></tr><tr><td>solaris</td><td></td><td>3,482.8</td><td>3,560.3</td><td>2,892.9</td><td>1,956.0</td><td>2,090.0</td><td>7,200.0</td></tr><tr><td>space_invaders</td><td>1,652.0</td><td>1,692.3</td><td>18,789.0</td><td>54,681.0</td><td>15,730.5</td><td>678.5</td><td>840.0</td></tr><tr><td>star_gunner</td><td>10,250.0</td><td>54,282.0</td><td>127,029.0</td><td>434,342.5</td><td>138,218.0</td><td>1,470.0</td><td>800.0</td></tr><tr><td>tennis</td><td>-8.9</td><td>12.2</td><td>0.0</td><td>23.9</td><td>-6.3</td><td>4.5</td><td>0.0</td></tr><tr><td>time_pilot</td><td>5,925.0</td><td>4,870.0</td><td>12,926.0</td><td>87,085.0</td><td>12,679.0</td><td>4,970.0</td><td>16,800.0 174.0</td></tr><tr><td>tutankham up_n_down</td><td>167.6</td><td>68.1</td><td>241.0</td><td>272.6</td><td>156.3</td><td>130.3</td></table>
+
+Table 6: Head-to-head comparison between algorithms on Atari games. Values represent the number of wins, losses, and ties between algorithms (e.g. vs. DQN, the GA wins on 22 games, loses on 29, and ties on 1. As discussed in the main text, apples-to-apples comparisons are difficult to make, as different algorithms exhibit different tradeoffs in computation, wall-clock speed, and data efficiency.   
+
+<table><tr><td></td><td>Human</td><td>DQN</td><td>Rainbow</td><td>Ape-X</td><td>A3C</td><td>ES</td><td>GA 6B</td></tr><tr><td>Human DQN</td><td></td><td>22,24, 0</td><td>37,9,0 48,4,0</td><td>43,6,0</td><td>28,21,0</td><td>15,28,1 18,29,1</td><td>21,28,0 22,29,1</td></tr><tr><td>Rainbow</td><td></td><td></td><td></td><td>48,4,0 43,9,0</td><td>30,22,0 11,41, 0</td><td>7,39,2</td><td>11,39,2</td></tr><tr><td>Ape-X</td><td></td><td></td><td></td><td></td><td></td><td>7,43,0</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>3,52,0</td><td></td><td>7,48,0</td></tr><tr><td>A3C</td><td></td><td></td><td></td><td></td><td></td><td>18,32, 0</td><td>27,28,0</td></tr><tr><td>ES</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>GA 6B</td><td></td><td></td><td></td><td></td><td></td><td></td><td>28,19,3</td></tr></table>

parse/train/rylT0AVtwH/rylT0AVtwH.md

@@ -0,0 +1,418 @@
+# LEARNING FROM PARTIALLY-OBSERVED MULTIMODAL DATA WITH VARIATIONAL AUTOENCODERS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Learning from only partially-observed data for imputation has been an active research area. Despite promising progress on unimodal data imputation (e.g., image in-painting), models designed for multimodal data imputation are far from satisfactory. In this paper, we propose variational selective autoencoders (VSAE) for this task. Different from previous works, our proposed VSAE learns only from partially-observed data. VSAE is capable of learning the joint distribution of observed and unobserved modalities as well as the imputation mask, resulting in a unified model for various down-stream tasks including data generation and imputation. Evaluation on both synthetic high-dimensional and challenging lowdimensional multi-modality datasets shows significant improvement over the stateof-the-art data imputation models.
+
+# 1 INTRODUCTION
+
+Learning from data is an integral part of machine learning and artificial intelligence. Modern deep learning techniques rely heavily on extracting information form large scale datasets. While such frameworks have been shown to be effective on various down-stream tasks such as classification, regression, representation learning, and prediction, it is typically crucial to have access to clean and complete training data. Complete data in this case can be either labeled data (for classification), or time-series data with no missing values (for regression), or simply image with no missing pixels (for generation). As such, if a model can only access partially-observed data, the performance will likely be much worse than those trained with fully-observed data, if not completely failing. In practical scenarios, however, it is usually costly to acquire clean and complete data due to the limited human resources and time. Having a model designed to learn and extract information from partially-observed data will not only largely increase the application spectrum of deep learning based models, but also provide benefit to new down-stream tasks, for example, data imputation.
+
+Data imputation with deep generative models has been an active research area (Yoon et al., 2018; Ivanov et al., 2019; Nazabal et al., 2018). Despite promising progress, there are still challenges in learning effective models. First, some prior works focus on learning from fully-observed data while performing imputation on partially-observed data during test phase (Suzuki et al., 2016; Ivanov et al., 2019). Second, they usually have strong assumptions on missingness mechanism (see A.1) such as data is missing completely at random (MCAR) (Yoon et al., 2018). Third, mostly unimodal imputation such as image in-painting has been explored for high-dimensional data (Ivanov et al., 2019; Mattei & Frellsen, 2019). Unimodal data refers to data with only one modality such as image, video, or text. Modeling any combination of data modalities is not well-established yet, which apparently limits the potential of such models, since raw data in real-life is usually acquired in a multimodal manner (Ngiam et al., 2011) with more than one source of data gathered to represent a practical scenario. In practice, one or more of the modalities maybe be missing, leading to a challenging multimodal data imputation task.
+
+In this work, we propose Variational Selective Autoencoder (VSAE) for multimodal data generation and imputation. Our proposed VSAE tries to address the challenges above by learning from partiallyobserved training data. By constructing an encoder for each modality independently, the latent representation selectively takes only the observed modalities as input, while a set of decoders maps the latent codes to not only full data (including both observed and unobserved modalities), but also a mask representing the missingness scheme. Thus, it can model the joint distribution of the data and the mask together and avoid limiting assumptions such as MCAR, and is optimized efficiently with a single variational objective. In our experimental validation, we evaluate our proposed VSAE on both synthetic high-dimensional multimodal data and challenging low-dimensional tabular data, and show that VSAE can outperform state-of-the-art baseline models for data imputation task. The contributions are summarized as follows:
+
+(1) A novel framework VSAE to learn from partially-observed multimodal data. (2) The proposed VSAE is capable of learning the joint distribution of observed and unobserved modalities as well as the imputation mask, resulting in a unified model for various down-stream tasks including data generation and imputation with relaxed assumptions on missigness mechanism. (3) Evaluation on both synthetic high-dimensional and challenging low-dimensional multimodal datasets shows improvement over the state-of-the-art data imputation models.
+
+# 2 RELATED WORK
+
+Our work is related to literature on data imputation and multi-modal representation learning. In this section, we briefly review recent models proposed in these two domains.
+
+Data Imputation. Classical imputation methods such as MICE (Buuren & Groothuis-Oudshoorn, 2010) and MissForest (Stekhoven & Bühlmann, 2011) learn discriminative models to impute missing features from observed ones. With recent advances in deep learning, several deep imputation models have been proposed based on autoencoders (Vincent et al., 2008; Gondara & Wang, 2017; Ivanov et al., 2019), generative adversarial nets (GANs) (Yoon et al., 2018; Li et al., 2019), and autoregressive models (Bachman & Precup, 2015). GAN-based imputation method GAIN proposed by Yoon et al. (2018) assumes that data is missing completely at random. Moreover, this method does not scale to high-dimensional multimodal data. Several VAE based methods (Ivanov et al., 2019; Nazabal et al., 2018; Mattei & Frellsen, 2019) have been proposed in recent years. Ivanov et al. (2019) formulated VAE with arbitrary conditioning (VAEAC) which allows generation of missing data conditioned on any combination of observed data. This algorithm needs complete data during training and cannot learn from partially-observed data only. Nazabal et al. (2018) and Mattei & Frellsen (2019) modified VAE formulation to model the likelihood of the observed data only. However, they require training of a separate generative network for each dimension thereby increasing computational requirements. In contrast, our method aims to model joint distribution of observed and unobserved data along with the missing pattern (imputation mask). This enables our model to perform both data generation and imputation even under relaxed assumptions on missingness mechanism (see Appendix A.1).
+
+Learning from Multimodal Data. A class of prior works such as conditional VAE (Sohn et al., 2015) and conditional multimodal VAE (Pandey & Dukkipati, 2017) focus on learning the conditional likelihood of the modalities. However, these models requires complete data during training and cannot handle arbitrary conditioning. Alternatively, several generative models aim to model joint distribution of all modalities (Ngiam et al., 2011; Srivastava & Salakhutdinov, 2012; Sohn et al., 2014; Suzuki et al., 2016). However, multimodal VAE based methods such as joint multimodal VAE (Suzuki et al., 2016) and multimodal factorization model (MFM) (Tsai et al., 2019) require complete data during training. On the other hand, Wu & Goodman (2018) proposed another multimodal VAE (namely MVAE) can be trained with incomplete data. This model leverages a shared latent space for all modalities and obtains an approximate joint posterior for the shared space assuming each modalities to be factorized. However, if training data is complete, this model cannot learn the individual inference networks and consequently does not learn to handle missing data during test. Building over multimodal VAE approaches, our model aims to address the shortcomings above within a flexible framework. In particular, our model can learn multimodal representations from partially observed training data and perform data imputation from arbitrary subset of modalities during test. By employing a factorized multimodal representations in the latent space it resembles disentangled models which can train factors specialized for learning from different parts of data (Tsai et al., 2019).
+
+# 3 METHOD
+
+In this section, we introduce a novel VAE-based framework named Variational Selective Autoencoder (VSAE) to learn from partially-observed multimodal data. We first formalize our problem and then provide a detailed description of our model.
+
+![](images/9a34080af58e84b254d9964b9cab193900805c427f78d7d6aa779cab76ec9a20.jpg)  
+Figure 1: Overall architecture. The unimodal proposal network and multimodal proposal network are employed by selection. Modalities are denoted by different colors. Unobserved modalities are shaded. (i.e. blue is observed while red/yellow are unobserved.) The selected variables are indicated by the arrows. Standard normal prior is not plotted for simplicity. All components are trained simultaneously in an end-to-end manner.
+
+# 3.1 PROBLEM STATEMENT
+
+Let $\mathbf { x } = [ \mathbf { x } _ { 1 } , \mathbf { x } _ { 2 } . . . , \mathbf { x } _ { M } ]$ be the complete data with $M$ modalities, where $\mathbf { x } _ { i }$ denotes the feature representation for the $i$ -th modality. The size of each $\mathbf { x } _ { i }$ varies and can be very high-dimensional (e.g. multimedia data) or low-dimensional (e.g. tabular data). We define an $M$ -dimensional binary mask variable $\mathbf { m } \in \{ 0 , 1 \} ^ { M }$ to represent the observed and unobserved modalities: $m _ { i } = 1$ if the $i$ -th modality is observed and 0 if unobserved. Thus we have the set of observed modalities $\mathbb { O } = \{ i | m _ { i } = 1 \}$ , and the set of unobserved modalities $\mathbb { U } = \{ i | m _ { i } = 0 \}$ . $\mathbb { O }$ and $\mathbb { U }$ are complementary subsets of all modalities. Accordingly, we denote the representation for the observed and unobserved modalities with $\mathbf { x _ { o } } = [ \mathbf { x } _ { i } | m _ { i } = 1 ]$ and $\mathbf { x _ { u } } = [ \mathbf { x } _ { i } | m _ { i } = 0 ]$ , respectively. In this paper, we assume the data $\mathbf { x }$ and the mask $\mathbf { m }$ are dependent, and aim to model the joint distribution of them together.
+
+As a result of such joint modeling, VSAE has higher capacity and can be used for both data imputation and data/mask generation. We encoder the multimodal data to a latent space factorized with respect to the modalities. To handle training and test with partially-observed data, the variational latent variable of each modality is modeled selectively to choose between a unimodal encoder if the corresponding modality is observed, or a multimodal encoder if the modality is unobserved. In addition, all the modalities and mask are reconstructed by decoding the aggregated latent codes through decoders.
+
+# 3.2 BACKGROUND: VARIATIONAL AUTOENCODER
+
+VAE (Kingma & Welling, 2013) is a probabilistic latent variable model to generate a random variable $\mathbf { x }$ from a latent variable $\mathbf { z }$ with a prior distribution $p ( \mathbf { z } )$ according to the marginalized distribution $\begin{array} { r } { p ( \mathbf { x } ) = \mathbb { E } _ { \mathbf { z } \sim p ( \mathbf { z } ) } p ( \mathbf { x } | \mathbf { z } ) = \int p ( \mathbf { x } | \mathbf { z } ) p ( \mathbf { z } ) d \mathbf { z } } \end{array}$ . However, this is computationally intractable, so the likelihood $\log p ( \mathbf { x } )$ is approximated by variational lower bound (ELBO) $\mathcal { L } _ { \theta , \phi } ( \mathbf { x } )$ :
+
+$$
+\begin{array} { r } { \log p ( \mathbf { x } ) \geq \mathcal { L } _ { \theta , \phi } ( \mathbf { x } ) = \mathbb { E } _ { \mathbf { z } \sim q _ { \phi } ( \mathbf { z } \mid \mathbf { x } ) } [ \log p _ { \theta } ( \mathbf { x } \mid \mathbf { z } ) ] - D _ { \mathrm { K L } } [ q _ { \phi } ( \mathbf { z } \mid \mathbf { x } ) | | p ( \mathbf { z } ) ] . } \end{array}
+$$
+
+In this equation, $q _ { \phi } ( \mathbf { z } | \mathbf { x } )$ is a proposal distribution to approximate intractable true posterior $p ( \mathbf { z } | \mathbf { x } )$ and parameterized by an inference network (a.k.a encoder). $p _ { \pmb { \theta } } ( \mathbf { x } | \mathbf { z } )$ is the conditional likelihood parameterized by another generative network (a.k.a decoder). $D _ { \mathrm { K L } }$ is the Kullback-Leibler (KL) divergence between the prior and the proposal distribution and functions as a regularizer term, $D _ { \mathrm { K L } } [ \bar { q } _ { \phi } ( \mathbf { z } | \mathbf { x } ) | | p ( \mathbf { z } ) ] = \mathbb { E } _ { \mathbf { z } \sim q _ { \phi } ( \mathbf { z } | \mathbf { x } ) } [ \log q _ { \phi } ( \mathbf { z } | \mathbf { x } ) - \log p ( \mathbf { z } ) ] .$ . To train this model $\mathcal { L } _ { \theta , \phi } ( \mathbf { x } )$ is optimized over all training data with respect to the parameters $\pmb { \theta }$ and $\phi$ . For more details see Appendix A.2.
+
+# 3.3 PROPOSED MODEL: VARIATIONAL SELECTIVE AUTOENCODER
+
+Our goal is to model the joint distribution $\begin{array} { r } { p ( \mathbf { x } , \mathbf { m } ) = \int p ( \mathbf { x } , \mathbf { m } | \mathbf { z } ) p ( \mathbf { z } ) d \mathbf { z } } \end{array}$ where $\mathbf { x } = [ \mathbf { x _ { o } } , \mathbf { x _ { u } } ]$ . Following VAE formulation, we construct a proposal distribution $q ( \mathbf { z } | \mathbf { x } , \mathbf { m } )$ to approximate the intractable true posterior. See the architecture in Figure 1, we denote the parameters of encoder by $\{ \phi , \psi \}$ , and decoders of data and mask by $\theta$ and $\epsilon$ respectively. A lower bound of $\log p ( \mathbf { x } , \mathbf { m } )$ can be derived as:
+
+$$
+\begin{array} { r l } & { { \mathcal { L } } _ { \phi , \psi , \theta , \epsilon } ( \mathbf { x } , \mathbf { m } ) = \mathbb { E } _ { \mathbf { z } \sim q _ { \phi , \psi } ( \mathbf { z } | \mathbf { x } , \mathbf { m } ) } [ \log p _ { \theta , \epsilon } ( \mathbf { x } , \mathbf { m } | \mathbf { z } ) ] - D _ { \mathrm { K L } } [ q _ { \phi , \psi } ( \mathbf { z } | \mathbf { x } , \mathbf { m } ) | | p ( \mathbf { z } ) ] } \\ & { \qquad = \mathbb { E } _ { \mathbf { z } \sim q _ { \phi , \psi } ( \mathbf { z } | \mathbf { x } , \mathbf { m } ) } [ \log p _ { \theta } ( \mathbf { x } | \mathbf { m } , \mathbf { z } ) + \log p _ { \epsilon } ( \mathbf { m } | \mathbf { z } ) - \log q _ { \phi , \psi } ( \mathbf { z } | \mathbf { x } , \mathbf { m } ) + \log p ( \mathbf { z } ) ] . } \end{array}
+$$
+
+We assume the variational latent variables can be factorized with respect to the modalities ${ \textbf { z } } =$ $[ { \bf z } _ { 1 } , { \bf z } _ { 2 } , . . . , { \bf z } _ { M } ]$ , which is a standard assumption for multimodal data (Tsai et al., 2019):
+
+$$
+p ( \mathbf { z } ) = \prod _ { i = 1 } ^ { M } p ( \mathbf { z } _ { i } ) , \qquad q ( \mathbf { z } | \mathbf { x } , \mathbf { m } ) = \prod _ { i = 1 } ^ { M } q ( \mathbf { z } _ { i } | \mathbf { x } , \mathbf { m } ) .
+$$
+
+Given this, we define the proposal distribution parameterized by $\phi$ and $\psi$ for each modality as
+
+$$
+q _ { \phi , \psi } ( \mathbf { z } _ { i } | \mathbf { x } , \mathbf { m } ) = \left\{ \begin{array} { l l } { q _ { \phi } ( \mathbf { z } _ { i } | \mathbf { x } _ { i } ) } & { \mathrm { i f } \ m _ { i } = 1 } \\ { q _ { \psi } ( \mathbf { z } _ { i } | \mathbf { x _ { o } } , \mathbf { m } ) } & { \mathrm { i f } \ m _ { i } = 0 } \end{array} \right.
+$$
+
+This is based on the intuitive assumption that the latent space of each modality is independent of other modalities given its data is observed. But, if the data is missing for some modality, its latent space is constructed from the other observed modalities. We call this selective proposal distribution.
+
+In the decoder, the probability distribution also factorizes over the modalities assuming that the reconstructions are conditionally independent given the complete set of latent variables of all modalities:
+
+$$
+\log p _ { \theta } ( \mathbf { x } | \mathbf { m } , \mathbf { z } ) = \log p _ { \theta } ( \mathbf { x _ { o } } , \mathbf { x _ { u } } | \mathbf { m } , \mathbf { z } ) = \sum _ { i \in \mathbb { O } } \log p _ { \theta } ( \mathbf { x } _ { i } | \mathbf { m } , \mathbf { z } ) + \sum _ { j \in \mathbb { U } } \log p _ { \theta } ( \mathbf { x } _ { j } | \mathbf { m } , \mathbf { z } )
+$$
+
+To summarize, the ELBO in Equation 2 can be rewritten as
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } _ { \phi , \psi , \theta , \epsilon } ( \mathbf { x _ { o } } , \mathbf { x _ { u } } , \mathbf { m } ) = \mathbb { E } _ { \mathbf { z } } \left[ \sum _ { i \in \mathbb { O } } \log p \varrho ( \mathbf { x } _ { i } | \mathbf { m } , \mathbf { z } ) + \sum _ { j \in \mathbb { U } } \log p \varrho ( \mathbf { x } _ { j } | \mathbf { m } , \mathbf { z } ) \right] + \mathbb { E } _ { \mathbf { z } } \big [ \log p _ { \epsilon } ( \mathbf { m } | \mathbf { z } ) \big ] } \\ { \displaystyle \qquad - \sum _ { i = 1 } ^ { M } \mathbb { E } _ { \mathbf { z } _ { i } } \big [ \log q _ { \phi , \psi } ( \mathbf { z } _ { i } | \mathbf { x } , \mathbf { m } ) - \log p ( \mathbf { z } _ { i } ) \big ] , } \end{array}
+$$
+
+where $\mathbf { z } _ { i } \sim q _ { \phi , \psi } ( \mathbf { z } _ { i } | \mathbf { x } , \mathbf { m } )$ according to the selective proposal distribution given in Equation 4.
+
+For training the model, the ELBO should be maximized over training data. However under partiallyobserved setting, $\mathbf { x _ { u } }$ is missing and unavailable even during training. Thus, we define the objective function for training by taking expectation over $\mathbf { x _ { u } }$
+
+$$
+\mathcal { L } _ { \phi , \psi , \theta , \epsilon } ^ { \prime } ( \mathbf { x _ { o } } , \mathbf { m } ) = \mathbb { E } _ { \mathbf { x _ { u } } } [ \mathcal { L } _ { \phi , \psi , \theta , \epsilon } ( \mathbf { x _ { o } } , \mathbf { x _ { u } } , \mathbf { m } ) ]
+$$
+
+Only one term in Equation 6 is dependent on $\mathbf { x _ { u } }$ , so the final objective function is obtained as
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } _ { \phi , \psi , \theta , \epsilon } ^ { \prime } ( \mathbf { x _ { o } } , \mathbf { m } ) = \mathbb { E } _ { \mathbf { z } } \left[ \sum _ { i \in \mathbb { O } } \log p \varrho ( \mathbf { x } _ { i } | \mathbf { m } , \mathbf { z } ) + \sum _ { j \in \mathbb { U } } \mathbb { E } _ { \mathbf { x } _ { j } } \big [ \log p \varrho ( \mathbf { x } _ { j } | \mathbf { m } , \mathbf { z } ) \big ] \right] + \mathbb { E } _ { \mathbf { z } } \big [ \log p _ { \epsilon } ( \mathbf { m } | \mathbf { z } ) \big ] } \\ { \displaystyle \qquad - \sum _ { i = 1 } ^ { M } \mathbb { E } _ { \mathbf { z } _ { i } } \big [ \log q _ { \phi , \psi } ( \mathbf { z } _ { i } | \mathbf { x } , \mathbf { m } ) - \log p ( \mathbf { z } _ { i } ) \big ] , \ : \mathrm { w h e r e ~ } \mathbf { z } _ { i } \sim q _ { \phi , \psi } ( \mathbf { z } _ { i } | \mathbf { x } , \mathbf { m } ) \qquad ( \forall \ : \mathbf { z } _ { i } \propto \mathbb { I } _ { \mathbf { z } } ) , } \end{array}
+$$
+
+In the proposed algorithm, we approximate $\mathbb { E } _ { \mathbf { x } _ { j } } [ \log p _ { \pmb { \theta } } ( \mathbf { x } _ { j } | \mathbf { m } , \mathbf { z } ) ] , j \in \mathbb { U }$ using reconstructed unobserved data sampling from the prior network. Our experiments show that even a single sample is sufficient to learn the model effectively. In fact, the prior network can be used as a self supervision mechanism to find the most likely samples which dominate the other samples when taking the expectation. In Equation 8, $p _ { \pmb { \theta } } ( \mathbf { x } _ { i } | \mathbf { m } , \mathbf { z } )$ is the decoding term of corresponding modality $\mathbf { x } _ { i }$ and the type of distribution depends on the data. The mask decoding term $p _ { \pmb { \theta } } ( \mathbf { m } | \mathbf { z } )$ is factorized Bernoulli distribution modeling the binary mask variable. The prior is standard normal distribution $\begin{array} { r } { p ( \mathbf { z } ) = \prod _ { i = 1 } ^ { M } p ( \mathbf { z } _ { i } ) = \prod _ { i = 1 } ^ { M } \mathcal { \bar { N } } ( \mathbf { z } _ { i } ; \mathbf { 0 } , \mathbf { I } ) } \end{array}$ which is fully-factorized.
+
+# 3.4 NETWORK MODULES
+
+We construct each module of our model using neural networks and optimize the parameters via backpropagation techniques. Following the terms in standard VAE, VSAE is composed of encoders and decoders. The architecture is shown in Figure 1. The whole architecture can be viewed as an integration of two auto-encoding structures: the top-branch data-wise encoders/decoders and the bottom-branch mask-wise encoders/decoder. The selective proposal distribution chooses between the unimodal and multimodal encoders, depending on whether the data is observed or not. The outputs of all encoders are sampled and aggregated to provide input to all the decoders. In the rest of this section we explain different modules. See Appendix B for further implementation details.
+
+Selective Factorized Encoders Standard proposal distribution of VAEs depends on the whole data and can not handle incomplete input. To overcome this, we introduce our selective proposal distribution, which is factorized w.r.t the modalities. As defined in Equation 4, the unimodal proposal distribution $q _ { \phi } ( \mathbf { z } _ { i } | \mathbf { x } _ { i } )$ is inferred only from each individual observed modality (modeled by a set of separate encoders parameterized by $\phi$ ). If the modality is unobserved, the multimodal proposal distribution $q _ { \psi } ( \mathbf { z } _ { i } | \mathbf { x _ { o } } , \mathbf { m } )$ (a single encoder parameterized by $\psi$ ) is used to infer corresponding latent variables from other observed modalities and mask. Hence, the learned model can impute the missing information by combining unimodal proposal distribution of observed modalities and multimodal proposal distribution of the unobserved modalities. The condition on the mask could make the model aware of the missing pattern and help attend to observed modalities. We model all the proposal distributions as normal distributions by setting the outputs of all encoders as mean and covariance of a normal distribution. The reparameterization in standard VAE is used for end-to-end training.
+
+Decoding through Latent Variable Aggregator $\mathcal { F }$ Selected and sampled from proper proposal distributions for all modalities, the variational latent codes can be fed to the downstream decoders even when the observation is incomplete. To do this, the information from different modalities are combined by aggregating their stochastic latent codes before they are decoded using a decoder: $p _ { \epsilon } ( \mathbf { m } | \mathbf { z } ) = p _ { \epsilon } ( \mathbf { m } | \mathcal { F } ( \mathbf { z } ) ) , p _ { \theta } ( \mathbf { x } _ { i } | \mathbf { z } , \mathbf { m } ) = p _ { \theta } ( \mathbf { x } _ { i } | \mathcal { F } ( \mathbf { z } ) , \mathbf { m } ) )$ . Here, we choose the aggregator $\mathcal { F } ( \cdot ) =$ concat(·), i.e., concatenating the latent codes. One may also use other aggregation functions such as max/mean pooling or matrix fusion (Veit et al., 2018) to combine latent codes from all modalities. The decoders take the shared aggregated latent codes as input to generate data and mask.
+
+Mask Vector Encoding and Decoding The mask variable m is encoded into the latent space through the multimodal proposal network. The latent space is shared by the mask and data decoders. The mask decoder $\epsilon$ is parameterized using an MLP in our implementation. We assume each dimension of the mask variable is an independent Bernoulli distribution.
+
+Training With reparameterization trick (Kingma & Welling, 2013), we can jointly optimize the objective derived in Equation 8 with respect to these parameters defined above on training set:
+
+$$
+\operatorname* { m a x } _ { \phi , \theta , \psi , \epsilon } \mathbb { E } _ { \mathbf { x _ { o } } , \mathbf { m } } [ \mathcal { L } _ { \phi , \theta , \psi , \epsilon } ^ { \prime } ( \mathbf { x _ { o } } , \mathbf { m } ) ]
+$$
+
+Since Equation 9 only requires the mask and observed data during training, this modified ELBO $\mathcal { L } _ { \phi , \theta , \psi , \epsilon } ^ { \prime } ( \mathbf { x _ { o } } , \mathbf { m } )$ can be optimized without the presence of unobserved modalities. The KLdivergence term is calculated analytically for each factorized term. The conditional log-likelihood term is computed by negating reconstruction loss function. (See Section 4 and Appendix B.2.)
+
+Inference The learned model can be used for both data imputation and generation. For imputation, the observed modalities $\mathbf { x _ { o } }$ and mask m are fed through the encoders to infer the selective proposal distributions. Then the sampled latent codes are decoded to estimate the unobserved modalities $\mathbf { x _ { u } }$ All the modules in Figure 1 are used for imputation. For generation, since no data is available at all, the latent codes are sampled from the prior and go through the decoders to generate the data and the mask. In this way, only modules after the aggregator are used without any inference modules.
+
+<table><tr><td rowspan="2"></td><td colspan="2">Categorical(PFC)</td><td colspan="2">Numerical(NRMSE)</td></tr><tr><td>Phishing</td><td>Mushroom</td><td>Yeast</td><td>Glass</td></tr><tr><td>AE</td><td>0.348 ± 0.002</td><td>0.556 ±0.009</td><td>0.737± 0.036</td><td>1.651 ± 0.049</td></tr><tr><td>VAE</td><td>0.293 ±0.003</td><td>0.470 ± 0.017</td><td>0.468 ± 0.003</td><td>1.409 ± 0.011</td></tr><tr><td>CVAE w/ mask</td><td>0.241 ±0.003</td><td>0.445 ± 0.004</td><td>0.470± 0.001</td><td>1.498 ± 0.001</td></tr><tr><td>MVAE</td><td>0.308 ± 0.015</td><td>0.586 ± 0.019</td><td>0.475 ± 0.014</td><td>1.572 ± 0.035</td></tr><tr><td>VSAE (ours)</td><td>0.237 ± 0.001</td><td>0.396 ± 0.008</td><td>0.455 ± 0.003</td><td>1.312 ± 0.021</td></tr><tr><td>CVAE w/ data</td><td>0.301±0.005</td><td>0.485 ± 0.034</td><td>0.449 ± 0.001</td><td>1.380 ± 0.045</td></tr><tr><td>VAEAC</td><td>0.240±0.006</td><td>0.403 ±0.006</td><td>0.447 ± 0.0016</td><td>1.432 ± 0.027</td></tr></table>
+
+Table 1: Feature Imputation on UCI datasets. Missing ratio is 0.5. Categorical and numerical datasets are respectively evaluated by PFC and NRMSE. Last two rows are trained with fully-observed data, potentially serving as an upper bound for imputation models. We show mean and standard deviation over 3 independent runs. For both lower is better.
+
+![](images/c9391314e3073ce2a4592c4be3b82f1994f81f4784a936451b27aa14333b7666.jpg)  
+Figure 2: Feature Imputations on UCI datasets. Missing ratios ( $\mathbf { \sigma } _ { \mathbf { X } }$ -axis) are 0.3, 0.5, 0.7. Categorical (top row) and numerical (bottom row) datasets are evaluated by PFC and NRMSE respectively (lower is better for both). We show mean and standard deviation over 3 independent runs.
+
+# 4 EXPERIMENT
+
+To demonstrate the effectiveness of our model, we evaluate our model on low-dimensional tabular data imputation and high-dimensional multi-modal data imputation tasks, with extensive comparisons with state-of-the-art deep latent variable models.
+
+Baselines. Prior work on deep latent variable models for data imputation can be categorized into two main classes: (1) models having access to fully-observed data during training, and (2) models only having access to partially observed data during training. In class (1), we report the results of VAEAC (Ivanov et al., 2019) and conditional VAE (Sohn et al., 2015); while in class (2), we report results of deterministic Autoencoder (AE), VAE (Kingma & Welling, 2013), conditional VAE (Sohn et al., 2015) (conditioned on mask) and MVAE (Wu & Goodman, 2018). Our model VSAE falls in this category since it learns the joint distribution of $p ( \mathbf { x _ { o } } , \mathbf { x _ { u } } , \mathbf { m } )$ given only observed information. Note that class (1) models can empirically represent the upper bound representative capability of imputation models, as they have access to fully-observed data during training. To establish fair comparison, all models in the experiments are implemented with the same backbone structure. Additional information on experimental details can be found in Appendix. B.
+
+# 4.1 DATA IMPUTATION
+
+Low-dimensional Tabular Data Imputation. We choose UCI repository datasets to demonstrate the effectiveness of our model on tabular data. It contains different tabular datasets with either numerical or categorical variables. In our experiments, we randomly sample from independent Bernoulli distributions with pre-defined missing ratio to simulate the masking mechanism. Minmax normalization is then applied to pre-process the numerical data and replace the unobserved dimensions by standard normal noise. We split training/test set by $8 0 \% / 2 0 \%$ and $2 0 \%$ of training set as validation set to choose the best model. Mean Square Error, Cross Entropy and Binary Cross Entropy are used as reconstruction loss for numerical, categorical and mask variables, respectively. We report the standard measures: NRMSE (i.e. RMSE normalized by the standard deviation of the feature and averaged over all features) for numerical datasets and PFC (i.e. proportion of falsely classified attributes of each feature and averaged over all features) for categorical datasets.
+
+Table 2: Imputation on Bimodal datasets.. Missing ratio is 0.5. Last two rows are trained with fully-observed data. We show mean and standard deviation over 3 independent runs (lower is better). $\Delta < 0 . 0 0 1$ .   
+
+<table><tr><td rowspan="2"></td><td colspan="3">MNIST+MNIST(MSE)</td><td colspan="3">MNIST+SVHN(MSE)</td></tr><tr><td>MNIST/784</td><td>MNIST/784</td><td>combined</td><td>MNIST/784</td><td>SVHN/3072</td><td>combined</td></tr><tr><td>AE</td><td>0.1077±△</td><td>0.1070±△</td><td>0.2147±△</td><td>0.0867±△</td><td>0.1475±△</td><td>0.2342±△</td></tr><tr><td>VAE</td><td>0.0734±△</td><td>0.0682±△</td><td>0.1396±△</td><td>0.0714±△</td><td>0.0559 ±0.003</td><td>0.1273±△</td></tr><tr><td>CVAE w/ mask</td><td>0.0733±△</td><td>0.0679±△</td><td>0.1412±△</td><td>0.0692±△</td><td>0.0558±△</td><td>0.1251±△</td></tr><tr><td>MVAE</td><td>0.0760±△</td><td>0.0802±△</td><td>0.1562±△</td><td>0.0707±△</td><td>0.602±△</td><td>0.1309±△</td></tr><tr><td>VSAE (ours)</td><td>0.0712±△</td><td>0.0663±△</td><td>0.1376±△</td><td>0.0682±△</td><td>0.0516±△</td><td>0.1198±△</td></tr><tr><td>CVAE w/data</td><td>0.0694±△</td><td>0.0646±△</td><td>0.1340±△</td><td>0.0716±△</td><td>0.0550±△</td><td>0.1266±△</td></tr><tr><td>VAEAC</td><td>0.0693±△</td><td>0.0645±△</td><td>0.1338±△</td><td>0.0682±△</td><td>0.0523±△</td><td>0.1206±△</td></tr></table>
+
+Results and Analysis. Table 1 shows that VSAE outperforms other methods on both numerical and categorical data. The first five rows are trained in partially-observed setting, while the last two trained with fully-observed data. We observe that models trained with partially-observed data can outperform those models trained with fully-observed data on some datasets. We argue this is due to two potential reasons: (1) the mask provides a natural way of dropout on the data space, thereby, helping the model to generalize; (2) if the data is noisy or has outliers (which is common in low-dimensional data), learning from partially-observed data can improve performance by ignoring these data. However, although our model does not product state-of-the-art results in fully-observed data imputation settings, these models potentially can serve as upper bound if the data is clean.
+
+Figure 2 illustrates that our model generally has lower error with lower variance for all missing ratios. With higher missing ratio (more data is unobserved), our model achieves more stable imputation performance on most of the datasets. On the contrary, there is a performance drop along with higher variance in the case of baselines. We believe this is because of the proposal distribution selection in VSAE. As the missing ratio increases, the input to unimodal encoders stays same while other encoders have to learn to focus on the useful information in data.
+
+High-dimensional Multimodal Data. We synthesize two bimodal datasets using MNIST and SVHN datasets. MNIST contains 28-by-28 gray images (0-9 digits); SVHN contains 32-by-32 RGB images (0-9 digits). We synthesize our datasets by pairing two different digits in MNIST (named MNIST $^ +$ MNIST) and one digit in MNIST with a same digit in SVHN (named MNIST $+$ SVHN). See Appendix C for more experimental results on multimodal FashionMNIST, MNIST and CMU-MOSI.
+
+Results and Analysis. VSAE has better performance for imputation task on all modalities with lower variance (refer to Table 2). Figure 3 presents the qualitative results of imputations on MNIST $^ +$ MNIST. With masks sampled with different missing ratios, the combined errors on MNIST $+ ]$ MNIST (i.e. sum of MSE in each modality averaged over its dimensions) of our model are $0 . 1 3 7 1 \pm 0 . 0 0 0 1$ , $0 . 1 3 7 6 \pm 0 . 0 0 0 2$ and $0 . 1 3 7 9 \pm 0 . 0 0 0 1$ under missing ratio of 0.3, 0.5 and 0.7 (Additional results are in Appendix C.2). This indicates that VSAE is robust under different missing ratios, whereas other baselines are sensitive to the missing ratio. We believe this is because of the underlying mechanism of proper proposal distribution selection. The separate structure of unimodal/multimodal encoders helps VSAE to attend to the observed data. It limits the input of unimodal encoders to observed single modality. Thus it is more robust to the missingness. In contrast, baseline methods have only one single proposal distribution inferred from the whole input. VSAE can easily ignore unobserved noisy modalities and attends on observed useful modalities, while baselines rely on neural networks to learn useful information from the whole data (which is dominated by missing information in case of high missing ratio). For partially-observed training setting, unobserved data is not available even during training. However, the unobserved modality in one data sample could be the observed modality in another data sample. Thus, the multimodal encoders are able to construct the mapping from observable to unobservable information over the whole training set. Multimodal encoders also include the mask vector as input. This allows the multimodal encoders to be aware of the shape of the missingness and forces it to focus on the useful information in the observed modalities.
+
+![](images/b1a5a86058d0bf3cb0c6ff94d6651f84a41203b8ae2d63639672ab5b87411ef6.jpg)  
+Figure 3: Imputation on MNIST $^ +$ MNIST. Top row visualizes observed modality, middle row unobserved modality, and bottom row shows the imputation of unobserved modality from VSAE.
+
+![](images/db7633d65315ac6b4de86c83c4652d1bd52e63d5e2aca1bb259b42543df95a3b.jpg)  
+Figure 4: Generation on MNIST $+$ MNIST. Generated Samples w/o conditional information. As shown, the correspondence between modalities (predefined pairs) are preserved while stochastic multimodal generation.
+
+# 4.2 IMPUTATION ON NON-MCAR MASKING MECHANISMS
+
+Sampling mask on predefined missing ratio is MCAR. VSAE can model mask distribution w/o constraints on the masking mechanisms. We also evaluate our model on MAR and NMAR. Mattei & Frellsen (2019) synthesize MAR in a defined rule and we follow them to synthesize both MAR and NMAR (refer to Appendix C.4 for details). Our model can outperform state-ofthe-art non-MCAR model MIWAE (Mattei & Frellsen, 2019).
+
+Table 3: Imputation. NRMSE on Yeast. Lower is better. $\Delta < 0 . 0 1$ .   
+
+<table><tr><td></td><td>MIWAE</td><td>VSAE</td></tr><tr><td>MCAR</td><td>0.467±△</td><td>0.455±△</td></tr><tr><td>MAR</td><td>0.493 ± 0.03</td><td>0.472 ±0.02</td></tr><tr><td>NMAR</td><td>0.513 ± 0.04</td><td>0.456±△</td></tr></table>
+
+# 4.3 DATA AND MASK GENERATION
+
+Unlike conventional methods modeling $p ( \mathbf { x _ { u } } | \mathbf { x _ { o } } )$ , our method is to model the joint probability $p ( \mathbf { x _ { o } } , \mathbf { x _ { u } } , \mathbf { m } )$ . Thus our model can impute missing features and also generate data and mask from scratch. Figure 4 shows the model learns the correlation between different modalities to pair the digits as predefined in the dataset without giving any labels in partially-observed setting.
+
+Our proposed VSAE can also learn to generate mask. The objective ELBO has a mask conditional log-likelihood term. This allows the latent space to have information from mask variables and be able to reconstruct (or generate if sample the prior) the mask vector. In UCI repository experiments, the mask variable follows Bernoulli distribution. After training, we sample from the prior to generate the mask. We calculate the proportion of the unobserved dimensions in generated mask vectors (averaged over 100 samples of the output). Averaged on all datasets, this proportion is $0 . 3 1 2 3 { \scriptstyle \pm 0 . 0 2 6 }$ , $0 . 4 9 6 4 \pm 0 . 0 0 5$ , $0 . 6 9 2 7 \pm 0 . 0 1 3$ for missing ratio of 0.3, 0.5, 0.7. It indicates that our model can learn the mask distribution. We also observe that conditions on the reconstructed mask vector in the data decoders improve the performance. We believe this is because the mask vector can inform the data decoder about the missingness in the data space since the latent space is shared by both all modalities thereby allowing it to generate data from the selective proposal distribution.
+
+# 5 CONCLUSION
+
+In this paper, we propose a VAE framework to learn from partially-observed data. Learning from partially-observed data is important but previous deep latent variable models cannot work well on this problem. The proposed model differentiates the observed and unobserved information by selecting a proper proposal distribution. The experimental results show the model can consistently outperform other baselines on low-dimensional tabular data and high-dimensional multimodal data. The model can also generate data with mask directly from prior without any conditions.
+
+# REFERENCES
+
+Philip Bachman and Doina Precup. Data generation as sequential decision making. In Advances in Neural Information Processing Systems, pp. 3249–3257, 2015.
+
+Yuri Burda, Roger Grosse, and Ruslan Salakhutdinov. Importance weighted autoencoders. International Conference on Learning Representations, 2016.
+
+S van Buuren and Karin Groothuis-Oudshoorn. mice: Multivariate imputation by chained equations in r. Journal of statistical software, pp. 1–68, 2010.
+
+Marc-André Carbonneau, Veronika Cheplygina, Eric Granger, and Ghyslain Gagnon. Multiple instance learning: A survey of problem characteristics and applications. Pattern Recognition, 2018.
+
+Lluis Castrejon, Yusuf Aytar, Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Learning aligned cross-modal representations from weakly aligned data. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2016.
+
+Hong-Min Chu, Chih-Kuan Yeh, and Yu-Chiang Frank Wang. Deep generative models for weaklysupervised multi-label classification. In The European Conference on Computer Vision (ECCV), September 2018.
+
+Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, François Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. The Journal of Machine Learning Research, 2016.
+
+Lovedeep Gondara and Ke Wang. Multiple imputation using deep denoising autoencoders. arXiv preprint arXiv:1705.02737, 2017.
+
+Jiawei He, Yu Gong, Joseph Marino, Greg Mori, and Andreas Lehrmann. Variational autoencoders with jointly optimized latent dependency structure. In International Conference on Learning Representations, 2019.
+
+Oleg Ivanov, Michael Figurnov, and Dmitry Vetrov. Variational autoencoder with arbitrary conditioning. In International Conference on Machine Learning, 2019.
+
+Vikas Jain, Nirbhay Modhe, and Piyush Rai. Scalable generative models for multi-label learning with missing labels. In Proceedings of the 34th International Conference on Machine Learning, Proceedings of Machine Learning Research. PMLR, 2017.
+
+Taeksoo Kim, Moonsu Cha, Hyunsoo Kim, Jung Kwon Lee, and Jiwon Kim. Learning to discover cross-domain relations with generative adversarial networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1857–1865. JMLR. org, 2017.
+
+Diederik P. Kingma and Max Welling. Auto-encoding variational bayes. CoRR, abs/1312.6114, 2013.
+
+Diederik P. Kingma, Danilo Jimenez Rezende, Shakir Mohamed, and Max Welling. Semi-supervised learning with deep generative models. CoRR, abs/1406.5298, 2014.
+
+Steven Cheng-Xian Li, Bo Jiang, and Benjamin Marlin. Misgan: Learning from incomplete data with generative adversarial networks. In International Conference on Learning Representations, 2019.
+
+Roderick J A Little and Donald B Rubin. Statistical Analysis with Missing Data. John Wiley & Sons, Inc., New York, NY, USA, 1986. ISBN 0-471-80254-9.
+
+Pierre-Alexandre Mattei and Jes Frellsen. Miwae: Deep generative modelling and imputation of incomplete data sets. In International Conference on Machine Learning, pp. 4413–4423, 2019.
+
+Ishan Misra, Abhinav Shrivastava, Abhinav Gupta, and Martial Hebert. Cross-stitch networks for multi-task learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3994–4003, 2016.
+
+Louis-Philippe Morency, Rada Mihalcea, and Payal Doshi. Towards multimodal sentiment analysis: Harvesting opinions from the web. In Proceedings of the 13th international conference on multimodal interfaces, pp. 169–176. ACM, 2011.
+
+Alfredo Nazabal, Pablo M Olmos, Zoubin Ghahramani, and Isabel Valera. Handling incomplete heterogeneous data using vaes. arXiv preprint arXiv:1807.03653, 2018.
+
+Jiquan Ngiam, Aditya Khosla, Mingyu Kim, Juhan Nam, Honglak Lee, and Andrew Y. Ng. Multimodal deep learning. In International Conference on Machine Learning, ICML’11, pp. 689–696, USA, 2011. Omnipress. ISBN 978-1-4503-0619-5.
+
+Gaurav Pandey and Ambedkar Dukkipati. Variational methods for conditional multimodal deep learning. In 2017 International Joint Conference on Neural Networks (IJCNN), pp. 308–315. IEEE, 2017.
+
+Amaia Salvador, Nicholas Hynes, Yusuf Aytar, Javier Marin, Ferda Ofli, Ingmar Weber, and Antonio Torralba. Learning cross-modal embeddings for cooking recipes and food images. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.
+
+Casper Kaae Sø nderby, Tapani Raiko, Lars Maalø e, Søren Kaae Sø nderby, and Ole Winther. Ladder variational autoencoders. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 3738–3746. Curran Associates, Inc., 2016.
+
+Kihyuk Sohn, Wenling Shang, and Honglak Lee. Improved multimodal deep learning with variation of information. In Advances in neural information processing systems, pp. 2141–2149, 2014.
+
+Kihyuk Sohn, Honglak Lee, and Xinchen Yan. Learning structured output representation using deep conditional generative models. In Advances in Neural Information Processing Systems 28, pp. 3483–3491. 2015.
+
+Yuhang Song, Chao Yang, Zhe Lin, Xiaofeng Liu, Qin Huang, Hao Li, and C.-C. Jay Kuo. Contextualbased image inpainting: Infer, match, and translate. In The European Conference on Computer Vision (ECCV), September 2018.
+
+Nitish Srivastava and Ruslan R Salakhutdinov. Multimodal learning with deep boltzmann machines. In Advances in neural information processing systems, pp. 2222–2230, 2012.
+
+Daniel J Stekhoven and Peter Bühlmann. Missforest—non-parametric missing value imputation for mixed-type data. Bioinformatics, 28(1):112–118, 2011.
+
+Masahiro Suzuki, Kotaro Nakayama, and Yutaka Matsuo. Joint multimodal learning with deep generative models. arXiv preprint arXiv:1611.01891, 2016.
+
+Yao-Hung Hubert Tsai, Paul Pu Liang, Amir Zadeh, Louis-Philippe Morency, and Ruslan Salakhutdinov. Learning factorized multimodal representations. In International Conference on Learning Representations, 2019.
+
+Andreas Veit, Maximilian Nickel, Serge Belongie, and Laurens van der Maaten. Separating selfexpression and visual content in hashtag supervision. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018.
+
+Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In international conference on Machine learning, pp. 1096–1103. ACM, 2008.
+
+Mike Wu and Noah Goodman. Multimodal generative models for scalable weakly-supervised learning. In Proceedings of the 32nd International Conference on Neural Information Processing Systems, NIPS’18, 2018.
+
+M. Wöllmer, F. Weninger, T. Knaup, B. Schuller, C. Sun, K. Sagae, and L. Morency. Youtube movie reviews: Sentiment analysis in an audio-visual context. IEEE Intelligent Systems, 2013.
+
+Jinsung Yoon, James Jordon, and Mihaela Van Der Schaar. Gain: Missing data imputation using generative adversarial nets. In International Conference on Machine Learning, 2018.
+
+Amir Zadeh, Rowan Zellers, Eli Pincus, and Louis-Philippe Morency. Multimodal sentiment intensity analysis in videos: Facial gestures and verbal messages. IEEE Intelligent Systems, 31(6), 2016.
+
+Amir Zadeh, Minghai Chen, Soujanya Poria, Erik Cambria, and Louis-Philippe Morency. Tensor fusion network for multimodal sentiment analysis. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 1103–1114. Association for Computational Linguistics, 2017. doi: 10.18653/v1/D17-1115.
+
+Amir Zadeh, Yao-Chong Lim, Paul Pu Liang, and Louis-Philippe Morency. Variational auto-decoder: Neural generative modeling from partial data. arXiv preprint arXiv:1903.00840, 2019.
+
+Ying Zhang and Huchuan Lu. Deep cross-modal projection learning for image-text matching. In The European Conference on Computer Vision (ECCV), September 2018.
+
+Yu Zhang, Ying Wei, and Qiang Yang. Learning to multitask. In Advances in Neural Information Processing Systems, pp. 5771–5782, 2018.
+
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In Proceedings of the IEEE international conference on computer vision, 2017.
+
+# A BACKGROUND
+
+# A.1 IMPUTATION PROCESS AND MISSINGNESS MECHANISMS
+
+Following (Little & Rubin, 1986), the imputation process is to learn a generative distribution for unobserved missing data. To be consistent with notations in Section ??, let $\mathbf { x } = [ \mathbf { x } _ { 1 } , \mathbf { x } _ { 2 } , . . . , \mathbf { x } _ { M } ]$ be the complete data of all modalities where $\mathbf { x } _ { i }$ denote the feature representation for the $i$ -th modality. We also define $\mathbf { m } \in \{ 0 , 1 \} ^ { M }$ as the binary mask vector, where $m _ { i } = 1$ indicates if the $i$ -th modality is observed, and $m _ { i } = 0$ indicates if it is unobsrved:
+
+$$
+\begin{array} { r l } & { \mathbf { x } \sim p _ { \mathrm { d a t a } } ( \mathbf { x } ) , } \\ & { \mathbf { m } \sim p ( \mathbf { m } | \mathbf { x } ) . } \end{array}
+$$
+
+Given this, the observed data $\mathbf { x _ { o } }$ and unobserved data $\mathbf { x _ { u } }$ are represented accordingly:
+
+$$
+\begin{array} { r } { \mathbf { x _ { o } } = [ \mathbf { x } _ { i } | m _ { i } = 1 ] , } \\ { \mathbf { x _ { u } } = [ \mathbf { x } _ { i } | m _ { i } = 0 ] . } \end{array}
+$$
+
+In the standard maximum likelihood setting, the unknown parameters are estimated by maximizing the following marginal likelihood, integrating over the unknown missing data values:
+
+$$
+p ( \mathbf { x _ { o } } , \mathbf { m } ) = \int p ( \mathbf { x _ { o } } , \mathbf { x _ { u } } , \mathbf { m } ) d \mathbf { x _ { u } } = \int p ( \mathbf { x _ { o } } , \mathbf { x _ { u } } ) p ( \mathbf { m } | \mathbf { x _ { o } } , \mathbf { x _ { u } } ) d \mathbf { x _ { u } }
+$$
+
+Little & Rubin (1986) characterizes the missingness mechanism $p ( \mathbf { m } | \mathbf { x _ { o } } , \mathbf { x _ { u } } )$ in terms of independence relations between the complete data $\mathbf { x } = [ \mathbf { x _ { o } } , \mathbf { x _ { u } } ]$ and the mask m:
+
+• Missing completely at random (MCAR): $p ( \mathbf { m } | \mathbf { x _ { o } } , \mathbf { x _ { u } } ) = p ( \mathbf { m } ) .$ , • Missing at random (MAR): $p ( \mathbf { m } | \mathbf { x _ { o } } , \mathbf { x _ { u } } ) = p ( \mathbf { m } | \mathbf { x _ { o } } )$ , • Not missing at random (NMAR): $p ( \mathbf { m } | \mathbf { x _ { o } } , \mathbf { x _ { u } } ) = p ( \mathbf { m } | \mathbf { x _ { u } } )$ or p(m|xo, xu).
+
+Most previous data imputation methods works under MCAR or MAR assumptions since $p ( \mathbf { x _ { o } } , \mathbf { m } )$ can be factorized into $p ( \mathbf { x _ { o } } ) p ( \mathbf { m } | \mathbf { x _ { o } } )$ or $p ( \mathbf { x _ { o } } ) p ( \mathbf { m } )$ . With such decoupling, we do not need missing information to marginalize the likelihood, and it provides a simple but approximate framework to learn from partially-observed data.
+
+# A.2 VARIATIONAL AUTOENCODER
+
+Variational Autoencoder (VAE) (Kingma & Welling, 2013) is a probabilistic generative model, where data is constructed from a latent variable $\mathbf { z }$ with a prior distribution $p ( \mathbf { z } )$ . It is composed of an inference network and a generation network to encode and decode data. To model the likelihood of data, the true intractable posterior $p ( \mathbf { z } | \mathbf { x } )$ is approximated by a proposal distribution $q _ { \phi } ( \mathbf { z } | \mathbf { x } )$ , and the whole model is trained until ideally the decoded reconstructions from the latent codes sampled from the approximate posterior match the training data. In the generation module, $p _ { \pmb { \theta } } ( \tilde { \mathbf { x } } | \mathbf { z } )$ , a decoder realized by a deep neural network parameterized by $\pmb { \theta }$ , maps a latent variable $\mathbf { z }$ to the reconstruction $\tilde { \mathbf { x } }$ of observation $\mathbf { x }$ . In the inference module, an encoder parameterized by $\phi$ produces the sufficient statistics of the approximation posterior $q _ { \phi } ( \mathbf { z } | \mathbf { x } )$ (a known density family where sampling can be readily done). In vanilla VAE setting, by simplifying approximate posterior as a parameterized diagonal normal distribution and prior as a standard diagonal normal distribution $\mathcal { N } ( \mathbf { 0 } , \bar { \mathbf { I } } )$ , the training criterion is to maximize the following evidence lower bound (ELBO) w.r.t. $\pmb \theta$ and $\phi$ .
+
+$$
+\log p ( \mathbf { x } ) \geq \mathcal { L } _ { \theta , \phi } ( \mathbf { x } ) = \mathbb { E } _ { q _ { \phi } ( \mathbf { z } | \mathbf { x } ) } [ \log p _ { \theta } ( \mathbf { x } | \mathbf { z } ) ] - D _ { \mathrm { K L } } [ q _ { \phi } ( \mathbf { z } | \mathbf { x } ) | | p ( \mathbf { z } ) ]
+$$
+
+where $D _ { \mathrm { K L } }$ denotes the Kullback-Leibler (KL) divergence. Usually the prior $p ( \mathbf { z } )$ and the approximate $q _ { \phi } ( \mathbf { z } | \mathbf { x } )$ are chosen to be in simple form, such as a Gaussian distribution with diagonal covariance, which allows for an analytic calculation of the KL divergence. While VAE approximates $p ( \mathbf { x } )$ , conditional VAE (Sohn et al., 2015) approximates the conditional distribution $p ( \mathbf { x } | \mathbf { y } )$ . By simply introducing a conditional input, CVAE is trained to maximize the following ELBO:
+
+$$
+\log p ( \mathbf { x } | \mathbf { y } ) \geq \mathcal { L } _ { \theta , \phi , \psi } ( \mathbf { x } , \mathbf { y } ) = \mathbb { E } _ { q _ { \phi } ( \mathbf { z } | \mathbf { x } , \mathbf { y } ) } [ \log p _ { \theta } ( \mathbf { x } | \mathbf { z } , \mathbf { y } ) ] - D _ { \mathrm { K L } } [ q _ { \phi } ( \mathbf { z } | \mathbf { x } , \mathbf { y } ) | | p _ { \psi } ( \mathbf { z } | \mathbf { y } ) ]
+$$
+
+# B IMPLEMENTATION DETAILS
+
+# B.1 ARCHITECTURE
+
+In all models, all the layers are modeled by MLP without any skip connections or resnet modules. Basically, the unimodal encoders take single modality data vector as input to infer the unimodal proposal distribution; the multimodal encoders take the observed data vectors and mask vector as as input to infer the multimodal proposal distributions. The input vector to multimodal encoders should have same length for the neural network. Here we just concatenate all modality vectors and replace the unobserved modality vectors with some noise. In UCI repository experiment, we replace the unobserved modality vectors as standard normal noise. In Bimodal experiment, we simply replace the pixels of unobserved modality as zero. Note that all the baselines has encoders/decoders with same or larger number of parameters than our method. We implement our model using PyTorch.
+
+Unimodal Encoders In UCI repository experiment, the unimodal encoders for numerical data are modeled by 3-layer 64-dim MLPs and the unimodal encoders for categorical data are modeled by 3-layer 64-dim MLPs, all followed by Batch Normalization and Leaky ReLU nonlinear activations. In MNIST $^ +$ MNIST bimodal experiment, the unimodal encoders are modeled by 3-layer 128-dim MLPs followed by Leaky ReLU nonlinear activations; In MNIST $+ \varsigma$ SVHN bimodal experiment, the unimodal encoders are modeled by 3-layer 512-dim MLPs followed by Leaky ReLU nonlinear activations. We set the latent dimension as 20-dim for every modality in UCI repository experiments and 256-dim for every modality in Bimodal experiments.   
+UCI data unimodal encoder: Linear( $1 , 6 4 ) $ BatchNorm1 $1 ( 6 4 ) $ LeakyReLU Linear(64, 64)→ LeakyReLU Linear(64, 64) LeakyReLU Linear(64, 20);   
+MNIST $^ +$ MNIST synthetic unimodal encoder: Linear(data-dimension, $1 2 8 ) $ LeakyReLU Linear $( 1 2 8 , 1 2 8 ) $ LeakyReLU Linear(128, $1 2 8 ) $ LeakyReLU Linear(128, 256);   
+MNIST $^ +$ SVHN synthetic unimodal encoder: Linear(data-dimension, $5 1 2 ) $ LeakyReLU Linear $( 5 1 2 , 5 1 2 ) $ LeakyReLU Linear(512, 512) LeakyReLU Linear(512, 256);
+
+Multimodal Encoders In general, any model capable of multimodal fusion (Zadeh et al., 2017; Morency et al., 2011) can be used here to map the observed data $\mathbf { x _ { o } }$ and the mask m to the latent variables $\mathbf { z }$ . However, in this paper we simply use an architecture similar to unimodal encoders. The difference is that the input to unimodal encoders are lower dimensional vectors of an individual modalities. But, the input to the multimodal encoders is the complete data vector with unobserved modalities replaced with noise or zeros. As the input to the multimodal encoders is the same for all modalities (i.e., $q ( \mathbf { z } _ { i } | \mathbf { x _ { o } } , \mathbf { m } ) \ \forall i )$ , we model the multimodal encoders as one single encoder to take advantage of the parallel matrix calculation speed. Thus the multimodal encoder for every experiment has the same structure as its unmidal encoder but with full-dimensional input.
+
+Aggregator In our models, we simply use vector concatenation as the way of aggregating.
+
+Mask Decoder UCI mask decoder: Linear $2 0 ^ { * }$ data-dimension, $6 4 ) $ BatchNorm1d(64) LeakyReLU Linear(64, 64) LeakyReLU Linear(64, 64) LeakyReLU Linear(64, maskdimension) Sigmoid; MNIST $+$ MNIST synthetic mask decoder: Linear(512, 16) BatchNorm1d(16) LeakyReLU Linear $^ { 1 6 , 1 6 )  }$ LeakyReLU Linear(16, 16) LeakyReL $U {  } \mathrm { L i n e a r } ( 1 6$ , 2) Sigmoid; MNIST $^ +$ SVHN synthetic mask encoder: Linear(512, 16) BatchNorm1d(16) LeakyReLU Linear $^ { 1 6 , 1 6 )  }$ LeakyReLU Linear $^ { 1 6 , 1 6 )  }$ LeakyReLU Linear(16,2) Sigmoid;
+
+Data Decoder As the output is factorized over modalities and for every decoder the input is shared as the latent codes sampled from the selective proposal distribution. We implement all the decoders of the data modalities as one single decoder for parallel speed. UCI data decoder: Linear( $2 0 ^ { * }$ data-dimension, $1 2 8 )  .$ BatchNorm1d(128) LeakyReLU Linear $( 1 2 8 ) $ Linear(128, $1 2 8 ) $ Linear(128, data-dimension);   
+MNIST $^ +$ MNIST synthetic data decoder: Linear(512, $1 2 8 ) $ BatchNorm1d(128) LeakyReLU Linear $( 1 2 8 , 1 2 8 ) $ Linear(128, 128) Linear(128, 784) Sigmoid;   
+MNIST $+ S \mathsf { V H N }$ synthetic mask encoder: Linear(512, 512) BatchNorm1d(512) LeakyReLU Linear $( 5 1 2 , 5 1 2 ) $ Linear(512,512) Linear(512,784/3072) Sigmoid;
+
+# B.2 TRAINING
+
+We use Adam optimizer for all models. For UCI numerical experiment, learning rate is 1e-3 and use validation set to find a best model in 1000 epochs. For UCI categorical experiment, learning rate is 1e-2 and use validation set to find a best model in 1000 epochs. For bimodal experiments, learning rate is 1e-4 and use validation set to find a best model in 1000 epochs. All modules in our models are trained jointly.
+
+In our model, we calculate the conditional log-likelihood of unobserved modality by generating corresponding modalities from prior. We initially train the model for some (empirically we choose 20) epochs without calculating the conditional log-likelihood of $\mathbf { x _ { u } }$ . And then first feed the partiallyobserved data to the model and generate the unobserved modality $\tilde { \mathbf { x } } _ { \mathbf { u } }$ without calculating any loss; then feed the same batch for another pass, calculate the conditional log-likelihood using real $\mathbf { x _ { o } }$ and generated $\mathbf { x _ { u } }$ as ground truth.
+
+# B.3 BASELINES
+
+In our experiments, all the baselines use the same backbone architecture as our model, and the some of the layers are widened to make the total number of parameters same as our proposed model. All baselines for each experiment are trained with same Adam optimizer with same learning rate. All the deep latent variable model baselines have same size of latent variables.
+
+In the setting of AE/VAE, the input is the whole data representation with all the modalties without any mask information; In CVAE w/ mask, the encoder and decoder are both conditioned on the mask vector, while in CVAE w/ data, the observed modalities are fed to encoder and the decoder is conditioned on the observed modalities. VAEAC (Ivanov et al., 2019) is slightly modified to remove all the skip-connections to provide a fair comparison (we do not claim we outperform VAEAC with fully-observed training) and MVAE (Wu & Goodman, 2018) is same as the proposed model architecture.
+
+# C ADDITIONAL EXPERIMENTAL RESULTS
+
+# C.1 UCI REPOSITORY DATASETS
+
+Table 4: Imputation on Categorical datasets. Missing ratio is 0.5. Last two rows are trained with fully-observed data. Evaluated by PFC, lower is better.   
+
+<table><tr><td></td><td>Phishing</td><td>Zoo</td><td>Mushroom</td></tr><tr><td>AE</td><td>0.348 ± 0.002</td><td>0.295 ± 0.022</td><td>0.556 ± 0.009</td></tr><tr><td>VAE</td><td>0.293 ± 0.003</td><td>0.304 ± 0.009</td><td>0.470 ± 0.017</td></tr><tr><td>CVAE w/ mask</td><td>0.241 ± 0.003</td><td>0.270 ± 0.023</td><td>0.445 ± 0.004</td></tr><tr><td>MVAE</td><td>0.308 ± 0.015</td><td>0.233 ± 0.013</td><td>0.586 ± 0.019</td></tr><tr><td>VSAE</td><td>0.237 ± 0.001</td><td>0.213 ± 0.004</td><td>0.396 ± 0.008</td></tr><tr><td>CVAE w/ data</td><td>0.301 ± 0.005</td><td>0.323 ± 0.032</td><td>0.485 ± 0.034</td></tr><tr><td>VAEAC</td><td>0.240 ± 0.006</td><td>0.168 ± 0.006</td><td>0.403 ± 0.006</td></tr></table>
+
+Table 5: Imputation on Numerical datasets. Missing ratio is 0.5. Last two rows are trained with fully-observed data. Evaluated by NRMSE, lower is better.   
+
+<table><tr><td></td><td>Yeast</td><td>White Wine</td><td>Glass</td></tr><tr><td>AE</td><td>0.737 ± 0.036</td><td>0.3772 ± 0.0008</td><td>1.651 ± 0.049</td></tr><tr><td>VAE</td><td>0.468 ± 0.003</td><td>0.3714 ± 0.0001</td><td>1.409 ± 0.011</td></tr><tr><td>CVAE w/ mask</td><td>0.470 ± 0.001</td><td>0.3716 ± 0.0001</td><td>1.498 ± 0.0013</td></tr><tr><td>MVAE</td><td>0.475 ± 0.014</td><td>0.3722 ± 0.0009</td><td>1.572 ± 0.035</td></tr><tr><td>VSAE</td><td>0.455 ± 0.003</td><td>0.3711 ± 0.0002</td><td>1.312 ± 0.021</td></tr><tr><td>CVAE w/ data</td><td>0.449 ± 0.0001</td><td>0.3567 ± 0.0016</td><td>1.380 ± 0.045</td></tr><tr><td>VAEAC</td><td>0.447 ± 0.0016</td><td>0.3647 ± 0.0039</td><td>1.432 ± 0.027</td></tr></table>
+
+# C.2 MNIST $^ +$ MNIST BIMODAL DATASET
+
+# C.2.1 SETUP
+
+MNIST $^ +$ MNIST bimodal dataset. We randomly pair two digits in MNIST as [0, 9], [1, 8], [2, 7], [3, 6], [4, 5]. The training/test/validation sets respectively contain 23257/4832/5814 samples.
+
+# C.2.2 ADDITIONAL RESULTS
+
+<table><tr><td></td><td>0.3</td><td>0.5</td><td>0.7</td></tr><tr><td>AE</td><td>0.2124 ± 0.0012</td><td>0.2147 ± 0.0008</td><td>0.2180 ± 0.0008</td></tr><tr><td>VAE</td><td>0.1396 ± 0.0002</td><td>0.1416 ± 0.0001</td><td>0.1435 ± 0.0006</td></tr><tr><td>CVAE w/ mask</td><td>0.1393 ± 0.0002</td><td>0.1412 ± 0.0006</td><td>0.1425 ± 0.0012</td></tr><tr><td>MVAE</td><td>0.1547 ± 0.0012</td><td>0.1562 ± 0.0003</td><td>0.1579 ± 0.0006</td></tr><tr><td>VSAE</td><td>0.1371 ± 0.0001</td><td>0.1376 ± 0.0002</td><td>0.1379 ± 0.0001</td></tr><tr><td>CVAE w/ data</td><td>0.1336 ± 0.0003</td><td>0.1340 ± 0.0003</td><td>0.1343 ± 0.0002</td></tr><tr><td>VAEAC</td><td>0.1333 ± 0.0004</td><td>0.1338 ± 0.0003</td><td>0.1344 ± 0.0001</td></tr></table>
+
+Table 6: Imputation on MNIST $^ +$ MNIST. Missing ratio is 0.3, 0.5 and 0.7. Last two rows are trained with fully-observed data. Evaluated by combined errors of two modalities, lower is better.
+
+![](images/f668d3e5c6598efaa993cb8c029addb23baaf3bce7730f25304f012bf8297c93.jpg)  
+Figure 5: Imputation on MNIST+MNIST. Top row visualizes observed modality, middle row unobserved modality, and bottom row shows the imputation of unobserved modality from VSAE.
+
+![](images/38ee3e39fd34f42378c477cb5862f6be2af662e8435082e2d26e9a0d3780cdf2.jpg)  
+Figure 6: Generation on MNIST $^ +$ MNIST. Generated Samples w/o conditional information. As shown, the correspondence between modalities (pre-defined pairs) are preserved while generation.
+
+![](images/b8b2d090d3fa21f5150f3dfa5eba480dc53f68987727e6e062cc984fc7ab8977.jpg)  
+Figure 7: Multiple independent sampling in selected latent space. The leftmost digits are observed images in ground truth, and the right 8 digits are imputations of corresponding unobserved digits.
+
+# C.3 MNIST $^ +$ SVHN BIMODAL DATASET
+
+# C.3.1 SETUP
+
+MNIST $^ +$ SVHN bimodal dataset: We pair one digit in MNIST with the random same digit in SVHN. The training/test/validation sets respectively contain 44854/10000/11214 samples. For both datasets, we synthesize mask vectors over each modality by sampling from Bernoulli distribution. All mask are fixed after synthesis process. All original data points are only used once.
+
+# C.3.2 ADDITIONAL RESULTS
+
+Table 7: Imputation on MNIST $^ +$ SVHN. Missing ratio is 0.5. Last two rows are trained with fully-observed data. Evaluated by combined errors of two modalities, lower is better.   
+
+<table><tr><td></td><td>MNIST-MSE/784</td><td>SVHN-MSE/3072</td><td>Combined Bimodal Error</td></tr><tr><td>AE</td><td>0.0867 ± 0.0001</td><td>0.1475 ± 0.0006</td><td>0.2342 ± 0.0007</td></tr><tr><td>VAE</td><td>0.0714 ± 0.0001</td><td>0.0559 ± 0.0027</td><td>0.1273 ± 0.0003</td></tr><tr><td>CVAE w/ mask</td><td>0.0692 ± 0.0001</td><td>0.0558 ± 0.0003</td><td>0.1251 ± 0.0005</td></tr><tr><td>MVAE</td><td>0.0707 ± 0.0003</td><td>0.602 ± 0.0001</td><td>0.1309 ± 0.0005</td></tr><tr><td>VSAE</td><td>0.0682 ± 0.0001</td><td>0.0516 ± 0.0001</td><td>0.1198 ± 0.0001</td></tr><tr><td>CVAE w/ data</td><td>0.0716 ± 0.0002</td><td>0.0550 ± 0.0007</td><td>0.1266 ± 0.0005</td></tr><tr><td>VAEAC</td><td>0.0682 ± 0.0001</td><td>0.0523 ± 0.0001</td><td>0.1206 ± 0.0001</td></tr></table>
+
+Table 8: Imputation on MNIST $^ +$ SVHN. Missing ratio is 0.3, 0.5 and 0.7. Last two rows are trained with fully-observed data. Evaluated by combined errors of two modalities, lower is better.   
+
+<table><tr><td></td><td>0.3</td><td>0.5</td><td>0.7</td></tr><tr><td>AE</td><td>0.1941 ± 0.0006</td><td>0.2342 ± 0.0007</td><td>0.2678 ± 0.0012</td></tr><tr><td>VAE</td><td>0.1264 ± 0.0001</td><td>0.1273 ± 0.0003</td><td>0.1322 ± 0.0005</td></tr><tr><td>CVAE w/ mask</td><td>0.1255 ± 0.0002</td><td>0.1251 ± 0.0005</td><td>0.1295 ± 0.0006</td></tr><tr><td>MVAE</td><td>0.1275 ± 0.0029</td><td>0.1309 ± 0.0005</td><td>0.1313 ± 0.0013</td></tr><tr><td>VSAE</td><td>0.1217 ± 0.0002</td><td>0.1198 ± 0.0001</td><td>0.1202 ±0.0002</td></tr><tr><td>CVAE w/ data</td><td>0.1288 ± 0.0011</td><td>0.1266 ± 0.0005</td><td>0.1248 ± 0.0003</td></tr><tr><td>VAEAC</td><td>0.1218 ± 0.0002</td><td>0.1206 ± 0.0001</td><td>0.1211 ± 0.0001</td></tr></table>
+
+# C.4 IMPUTATION ON NON-MCAR MASKING MECHANISMS
+
+VSAE can jointly model data and mask distribution without any assumption on mask distribution. See A.1 for masking mechanism definitions. Mattei & Frellsen (2019) synthesized the mask from a MAR manner. We similarly follow them to synthesize MAR/NMAR masking mechanism on UCI numerical dataset and compare to state-of-the-art non-MCAR model MIWAE (Mattei & Frellsen, 2019).
+
+Missing At Random (MAR). The mask distribution depends on the observed data. We choose first $2 5 \%$ modalties as default observed data and generate the mask according to the probability that
+
+$$
+\pi ( { \bf m } ) = \mathrm { s i g m o i d } ( \frac { 1 } { M } \sum _ { k = 1 } ^ { K } { \bf x } _ { k } )
+$$
+
+$M$ is the number of the features and $K$ is the number of default observed features.
+
+Not Missing At Random (NMAR). The mask distribution depends on both observed and unobserved data. We generate the element-wise mask according to the probabilty that
+
+$\pi ( m _ { i } ) = \mathrm { s i g m o i d } ( { \bf x } _ { i } )$ $m _ { i }$ is $i$ -th element in mask vector $\mathbf { m }$ of size $M$ .
+
+<table><tr><td></td><td>MCAR</td><td>MAR</td><td>NMAR</td></tr><tr><td>MIWAE(Mattei &amp; Frellsen, 2019)</td><td>0.467± 0.0067</td><td>0.493 ± 0.029</td><td>0.513 ± 0.035</td></tr><tr><td>VSAE(ours)</td><td>0.455 ± 0.0003</td><td>0.472 ± 0.024</td><td>0.455 ± 0.0001</td></tr></table>
+
+Table 9: Imputation on MAR/NMAR masking. Missing ratio is based on the values of data following the defined rules above. We show mean and standard deviation over 3 independent runs (lower is better) on Yeast dataset.
+
+# C.5 MULTIMODAL EXPERIMENT
+
+In this section, we include additional experiments on multimodal datasets to demonstrate the general effectiveness of our model. We choose the datasets following MVAE (Wu & Goodman, 2018) and MFM Tsai et al. (2019).
+
+Table 10: Imputation on Image+Text datasets.. Missing ratio is 0.5. Image and text modality are evaluated by MSE and PFC respectively. Last two rows are trained with fully-observed data. We show mean and standard deviation over 3 independent runs (lower is better). $\Delta < 0 . 0 1$ .   
+
+<table><tr><td rowspan="2"></td><td colspan="2">FashionMNIST</td><td colspan="2">MNIST</td></tr><tr><td>image (MSE)</td><td>text (PFC)</td><td>image (MSE)</td><td>text (PFC)</td></tr><tr><td>AE</td><td>86.63 ± 1.09</td><td>0.366±△</td><td>54.90 ± 0.01</td><td>0.406±△</td></tr><tr><td>VAE</td><td>69.38 ± 0.10</td><td>0.411±△</td><td>53.82 ± 0.12</td><td>0.406 ± 0.01</td></tr><tr><td>CVAE w/ mask</td><td>69.53 ± 0.65</td><td>0.412±△</td><td>53.82±△</td><td>0.419±△</td></tr><tr><td>MVAE</td><td>109.95 ± 20.78</td><td>0.374 ± 0.07</td><td>178.40 ± 14.29</td><td>0.448±△</td></tr><tr><td>VSAE (ours)</td><td>68.49 ±0.19</td><td>0.356±△</td><td>53.42 ± 0.05</td><td>0.397 ± 0.01</td></tr><tr><td>CVAE w/ data</td><td>54.15 ± 0.03</td><td>0.259±△</td><td>47.38±△</td><td>0.237±△</td></tr><tr><td>VAEAC</td><td>61.59 ± 0.03</td><td>0.283±△</td><td>51.49 ± 0.06</td><td>0.250±△</td></tr></table>
+
+We choose CMU-MOSI (Zadeh et al., 2016) and ICT-MMMO (Wöllmer et al., 2013) following Tsai et al. (2019). The author released the features of each modality, and all the numbers are calculated on the feature level. CMU-MOSI (Zadeh et al., 2016) is a collection of 2199 monologue opinion video clips annotated with sentiment. ICT-MMMO (Wöllmer et al., 2013) consists of 340 online social review videos annotated for sentiment. We train all the models using Adam optimizer with learning rate of 1e-3.   
+
+<table><tr><td></td><td>Textual-MSE</td><td>Acoustic-MSE</td><td>Visual-MSE</td></tr><tr><td>AE</td><td>0.035 ± 0.003</td><td>0.224 ± 0.025</td><td>0.019 ± 0.003</td></tr><tr><td>VAE</td><td>0.034±△</td><td>0.202±△</td><td>0.1273±△</td></tr><tr><td>CVAE w/ mask</td><td>0.43±△</td><td>0.257 ± 0.002</td><td>0.020±△</td></tr><tr><td>MVAE</td><td>0.44±△</td><td>0.213 ± 0.001</td><td>0.025±△</td></tr><tr><td>VSAE</td><td>0.033±△</td><td>0.200±△</td><td>0.017±△</td></tr><tr><td>CVAE w/ data</td><td>0.036±△</td><td>0.186±△</td><td>0.018±△</td></tr><tr><td>VAEAC</td><td>0.042±△</td><td>0.257±△</td><td>0.019±△</td></tr></table>
+
+Table 11: Imputation on CMU-MOSI. Missing ratio is 0.5. Last two rows are trained with fullyobserved data. Evaluated by MSE of each modality. We show mean and standard deviation over 3 independent runs (lower is better). $\Delta < 0 . 0 0 0 5$   
+Table 12: Imputation on ICT-MMMO. Missing ratio is 0.5. Last two rows are trained with fullyobserved data. Evaluated by MSE of each modality. We show mean and standard deviation over 3 independent runs (lower is better).   
+
+<table><tr><td></td><td>Acoustic-MSE</td><td>Visual-MSE</td><td>Textual-MSE</td></tr><tr><td>AE</td><td>188.19 ± 2.083</td><td>3.695 ± 0.004</td><td>7.688 ± 0.243</td></tr><tr><td>VAE</td><td>63.26 ± 0.757</td><td>3.676 ± 0.103</td><td>6.153 ± 0.232</td></tr><tr><td>CVAE w/ mask</td><td>61.56 ± 6.584</td><td>3.614 ± 0.015</td><td>6.203 ± 0.423</td></tr><tr><td>MVAE</td><td>174.95 ± 117.64</td><td>3.569 ± 0.014</td><td>8.501 ± 3.561</td></tr><tr><td>VSAE</td><td>59.17 ± 4.120</td><td>3.569 ± 0.011</td><td>5.108 ±0.003</td></tr><tr><td>CVAE w/ data</td><td>59.22 ± 11.59</td><td>3.367 ± 0.046</td><td>6.398 ± 0.275</td></tr><tr><td>VAEAC</td><td>78.43 ± 8.774</td><td>3.111 ± 0.300</td><td>18.65 ± 0.452</td></tr></table>

parse/train/rywHCPkAW/rywHCPkAW.md

@@ -0,0 +1,407 @@
+# NOISY NETWORKS FOR EXPLORATION
+
+Meire Fortunato∗ Mohammad Gheshlaghi Azar∗ Bilal Piot ∗
+
+Jacob Menick Matteo Hessel Ian Osband Alex Graves Vlad Mnih
+
+Remi Munos Demis Hassabis Olivier Pietquin Charles Blundell Shane Legg
+
+DeepMind {meirefortunato,mazar,piot,   
+jmenick,mtthss,iosband,gravesa,vmnih,   
+munos,dhcontact,pietquin,cblundell,legg}@google.com
+
+# ABSTRACT
+
+We introduce NoisyNet, a deep reinforcement learning agent with parametric noise added to its weights, and show that the induced stochasticity of the agent’s policy can be used to aid efficient exploration. The parameters of the noise are learned with gradient descent along with the remaining network weights. NoisyNet is straightforward to implement and adds little computational overhead. We find that replacing the conventional exploration heuristics for A3C, DQN and Dueling agents (entropy reward and $\epsilon$ -greedy respectively) with NoisyNet yields substantially higher scores for a wide range of Atari games, in some cases advancing the agent from sub to super-human performance.
+
+# 1 INTRODUCTION
+
+Despite the wealth of research into efficient methods for exploration in Reinforcement Learning (RL) (Kearns & Singh, 2002; Jaksch et al., 2010), most exploration heuristics rely on random perturbations of the agent’s policy, such as $\epsilon$ -greedy (Sutton & Barto, 1998) or entropy regularisation (Williams, 1992), to induce novel behaviours. However such local ‘dithering’ perturbations are unlikely to lead to the large-scale behavioural patterns needed for efficient exploration in many environments (Osband et al., 2017).
+
+Optimism in the face of uncertainty is a common exploration heuristic in reinforcement learning. Various forms of this heuristic often come with theoretical guarantees on agent performance (Azar et al., 2017; Lattimore et al., 2013; Jaksch et al., 2010; Auer & Ortner, 2007; Kearns & Singh, 2002). However, these methods are often limited to small state-action spaces or to linear function approximations and are not easily applied with more complicated function approximators such as neural networks (except from work by (Geist & Pietquin, 2010a;b) but it doesn’t come with convergence guarantees). A more structured approach to exploration is to augment the environment’s reward signal with an additional intrinsic motivation term (Singh et al., 2004) that explicitly rewards novel discoveries. Many such terms have been proposed, including learning progress (Oudeyer & Kaplan, 2007), compression progress (Schmidhuber, 2010), variational information maximisation (Houthooft et al., 2016) and prediction gain (Bellemare et al., 2016). One problem is that these methods separate the mechanism of generalisation from that of exploration; the metric for intrinsic reward, and–importantly–its weighting relative to the environment reward, must be chosen by the experimenter, rather than learned from interaction with the environment. Without due care, the optimal policy can be altered or even completely obscured by the intrinsic rewards; furthermore, dithering perturbations are usually needed as well as intrinsic reward to ensure robust exploration (Ostrovski et al., 2017). Exploration in the policy space itself, for example, with evolutionary or black box algorithms (Moriarty et al., 1999; Fix & Geist, 2012; Salimans et al., 2017), usually requires many prolonged interactions with the environment. Although these algorithms are quite generic and can apply to any type of parametric policies (including neural networks), they are usually not data efficient and require a simulator to allow many policy evaluations.
+
+We propose a simple alternative approach, called NoisyNet, where learned perturbations of the network weights are used to drive exploration. The key insight is that a single change to the weight vector can induce a consistent, and potentially very complex, state-dependent change in policy over multiple time steps – unlike dithering approaches where decorrelated (and, in the case of -greedy, state-independent) noise is added to the policy at every step. The perturbations are sampled from a noise distribution. The variance of the perturbation is a parameter that can be considered as the energy of the injected noise. These variance parameters are learned using gradients from the reinforcement learning loss function, along side the other parameters of the agent. The approach differs from parameter compression schemes such as variational inference (Hinton & Van Camp, 1993; Bishop, 1995; Graves, 2011; Blundell et al., 2015; Gal & Ghahramani, 2016) and flat minima search (Hochreiter & Schmidhuber, 1997) since we do not maintain an explicit distribution over weights during training but simply inject noise in the parameters and tune its intensity automatically. Consequently, it also differs from Thompson sampling (Thompson, 1933; Lipton et al., 2016) as the distribution on the parameters of our agents does not necessarily converge to an approximation of a posterior distribution.
+
+At a high level our algorithm is a randomised value function, where the functional form is a neural network. Randomised value functions provide a provably efficient means of exploration (Osband et al., 2014). Previous attempts to extend this approach to deep neural networks required many duplicates of sections of the network (Osband et al., 2016). By contrast in our NoisyNet approach while the number of parameters in the linear layers of the network is doubled, as the weights are a simple affine transform of the noise, the computational complexity is typically still dominated by the weight by activation multiplications, rather than the cost of generating the weights. Additionally, it also applies to policy gradient methods such as A3C out of the box (Mnih et al., 2016). Most recently (and independently of our work) Plappert et al. (2017) presented a similar technique where constant Gaussian noise is added to the parameters of the network. Our method thus differs by the ability of the network to adapt the noise injection with time and it is not restricted to Gaussian noise distributions. We need to emphasise that the idea of injecting noise to improve the optimisation process has been thoroughly studied in the literature of supervised learning and optimisation under different names (e.g., Neural diffusion process (Mobahi, 2016) and graduated optimisation (Hazan et al., 2016)). These methods often rely on a noise of vanishing size that is non-trainable, as opposed to NoisyNet which tunes the amount of noise by gradient descent.
+
+NoisyNet can also be adapted to any deep RL algorithm and we demonstrate this versatility by providing NoisyNet versions of DQN (Mnih et al., 2015), Dueling (Wang et al., 2016) and A3C (Mnih et al., 2016) algorithms. Experiments on 57 Atari games show that NoisyNet-DQN and NoisyNetDueling achieve striking gains when compared to the baseline algorithms without significant extra computational cost, and with less hyper parameters to tune. Also the noisy version of A3C provides some improvement over the baseline.
+
+# 2 BACKGROUND
+
+This section provides mathematical background for Markov Decision Processes (MDPs) and deep RL with Q-learning, dueling and actor-critic methods.
+
+2.1 MARKOV DECISION PROCESSES AND REINFORCEMENT LEARNING
+
+MDPs model stochastic, discrete-time and finite action space control problems (Bellman & Kalaba, 1965; Bertsekas, 1995; Puterman, 1994). An MDP is a tuple $M = ( \mathcal { X } , \mathcal { A } , R , P , \gamma )$ where $\mathcal { X }$ is the state space, $\mathcal { A }$ the action space, $R$ the reward function, $\gamma \in ] 0 , 1 [$ [ the discount factor and $P$ a stochastic kernel modelling the one-step Markovian dynamics $( P ( \boldsymbol { y } | \boldsymbol { x } , a )$ is the probability of transitioning to state $y$ by choosing action $a$ in state $x$ ). A stochastic policy $\pi$ maps each state to a distribution over actions $\pi ( \cdot | x )$ and gives the probability $\pi ( a | x )$ of choosing action $a$ in state $x$ . The quality of a policy $\pi$ is assessed by the action-value function $Q ^ { \pi }$ defined as:
+
+$$
+Q ^ { \pi } ( x , a ) = \mathbb { E } ^ { \pi } \left[ \sum _ { t = 0 } ^ { + \infty } \gamma ^ { t } R ( x _ { t } , a _ { t } ) \right] ,
+$$
+
+where $\mathbb { E } ^ { \pi }$ is the expectation over the distribution of the admissible trajectories $( x _ { 0 } , a _ { 0 } , x _ { 1 } , a _ { 1 } , \dots )$ obtained by executing the policy $\pi$ starting from $x _ { 0 } = x$ and $a _ { 0 } = a$ . Therefore, the quantity $Q ^ { \pi } ( x , a )$ represents the expected $\gamma$ -discounted cumulative reward collected by executing the policy $\pi$ starting from $x$ and $a$ . A policy is optimal if no other policy yields a higher return. The action-value function of the optimal policy is $Q ^ { \star } ( x , a ) = \arg \operatorname* { m a x } _ { \pi } Q ^ { \pi } ( x , a )$ .
+
+The value function $V ^ { \pi }$ for a policy is defined as $V ^ { \pi } ( x ) = \mathbb { E } _ { a \sim \pi ( \cdot | x ) } [ Q ^ { \pi } ( x , a ) ]$ , and represents the expected $\gamma$ -discounted return collected by executing the policy $\pi$ starting from state $x$ .
+
+# 2.2 DEEP REINFORCEMENT LEARNING
+
+Deep Reinforcement Learning uses deep neural networks as function approximators for RL methods. Deep Q-Networks (DQN) (Mnih et al., 2015), Dueling architecture (Wang et al., 2016), Asynchronous Advantage Actor-Critic (A3C) (Mnih et al., 2016), Trust Region Policy Optimisation (Schulman et al., 2015), Deep Deterministic Policy Gradient (Lillicrap et al., 2015) and distributional RL (C51) (Bellemare et al., 2017) are examples of such algorithms. They frame the RL problem as the minimisation of a loss function $L ( \theta )$ , where $\theta$ represents the parameters of the network. In our experiments we shall consider the DQN, Dueling and A3C algorithms.
+
+DQN (Mnih et al., 2015) uses a neural network as an approximator for the action-value function of the optimal policy $Q ^ { \star } ( x , a )$ . DQN’s estimate of the optimal action-value function, $Q ( x , a )$ , is found by minimising the following loss with respect to the neural network parameters $\theta$ :
+
+$$
+L ( \theta ) = \mathbb { E } _ { ( x , a , r , y ) \sim D } \left[ \left( r + \gamma \operatorname* { m a x } _ { b \in A } Q ( y , b ; \theta ^ { - } ) - Q ( x , a ; \theta ) \right) ^ { 2 } \right] ,
+$$
+
+where $D$ is a distribution over transitions $e = ( x , a , r = R ( x , a ) , y \sim P ( \cdot | x , a ) )$ drawn from a replay buffer of previously observed transitions. Here $\theta ^ { - }$ represents the parameters of a fixed and separate target network which is updated $\theta ^ { - }  \theta$ ) regularly to stabilise the learning. An $\epsilon$ -greedy policy is used to pick actions greedily according to the action-value function $Q$ or, with probability $\epsilon$ , a random action is taken.
+
+The Dueling DQN (Wang et al., 2016) is an extension of the DQN architecture. The main difference is in using Dueling network architecture as opposed to the $\mathrm { \bf Q }$ network in DQN. Dueling network estimates the action-value function using two parallel sub-networks, the value and advantage subnetwork, sharing a convolutional layer. Let $\theta _ { \mathrm { c o n v } }$ , $\theta _ { V }$ , and $\theta _ { A }$ be, respectively, the parameters of the convolutional encoder $f$ , of the value network $V$ , and of the advantage network $A$ ; and $\theta = \{ \theta _ { \mathrm { c o n v } } , \theta _ { V } , \theta _ { A } \}$ is their concatenation. The output of these two networks are combined as follows for every $( x , a ) \in \mathcal { X } \times \mathcal { A }$ :
+
+$$
+Q ( x , a ; \theta ) = V ( f ( x ; \theta _ { \mathrm { c o n v } } ) , \theta _ { V } ) + A ( f ( x ; \theta _ { \mathrm { c o n v } } ) , a ; \theta _ { A } ) - \frac { \sum _ { b } A ( f ( x ; \theta _ { \mathrm { c o n v } } ) , b ; \theta _ { A } ) } { N _ { \mathrm { a c t o n s } } } .
+$$
+
+The Dueling algorithm then makes use of the double-DQN update rule (van Hasselt et al., 2016) to optimise $\theta$ :
+
+$$
+\begin{array} { r l } & { L ( \theta ) = \mathbb { E } _ { ( x , a , r , y ) \sim D } \left[ \left( r + \gamma Q ( y , b ^ { \ast } ( y ) ; \theta ^ { - } ) - Q ( x , a ; \theta ) \right) ^ { 2 } \right] , } \\ { \mathrm { s . t . } \quad } & { b ^ { \ast } ( y ) = \arg \operatorname* { m a x } _ { b \in \mathcal { A } } Q ( y , b ; \theta ) , } \end{array}
+$$
+
+where the definition distribution $D$ and the target network parameter set $\theta ^ { - }$ is identical to DQN.
+
+In contrast to DQN and Dueling, A3C (Mnih et al., 2016) is a policy gradient algorithm. A3C’s network directly learns a policy $\pi$ and a value function $V$ of its policy. The gradient of the loss on the
+
+A3C policy at step $t$ for the roll-out $( x _ { t + i } , a _ { t + i } \sim \pi ( \cdot | x _ { t + i } ; \theta ) , r _ { t + i } ) _ { i = 0 } ^ { k }$ is:
+
+$$
+\nabla _ { \theta } L ^ { \pi } ( \theta ) = - \mathbb { E } ^ { \pi } \left[ \sum _ { i = 0 } ^ { k } \nabla _ { \theta } \log ( \pi ( a _ { t + i } | x _ { t + i } ; \theta ) ) A ( x _ { t + i } , a _ { t + i } ; \theta ) + \beta \sum _ { i = 0 } ^ { k } \nabla _ { \theta } H ( \pi ( \cdot | x _ { t + i } ; \theta ) ) \right] .
+$$
+
+$H [ \pi ( \cdot | x _ { t } ; \theta ) ]$ denotes the entropy of the policy $\pi$ and $\beta$ is a hyper parameter that trades off between optimising the advantage function and the entropy of the policy. The advantage function $A ( x _ { t + i } , a _ { t + i } ; \theta )$ is the dnetwork: $\begin{array} { r } { A ( x _ { t + i } , a _ { t + i } ; \theta ) = \sum _ { j = i } ^ { k - 1 } \gamma ^ { j - i } r _ { t + j } + \gamma ^ { k - i } V ( x _ { t + k } ; \theta ) - V ( x _ { t + i } ; \theta ) , } \end{array}$ $r _ { t + j }$ $t + j$ $V ( x ; \theta )$ $x$
+
+The parameters of the value function are found to match on-policy returns; namely we have
+
+$$
+L ^ { V } ( \theta ) = \sum _ { i = 0 } ^ { k } \mathbb { E } ^ { \pi } \left[ ( Q _ { i } - V ( x _ { t + i } ; \theta ) ) ^ { 2 } \mid x _ { t + i } \right]
+$$
+
+where $\mathbb { Q } _ { i }$ is the return obtained by executing policy $\pi$ starting in state $x _ { t + i }$ . In practice, and as in Mnih et al. (2016), we estimate $Q _ { i }$ as $\begin{array} { r } { \hat { Q } _ { i } = \sum _ { j = i } ^ { k - 1 } \gamma ^ { j - i } r _ { t + j } + \gamma ^ { k - i } V ( x _ { t + k } ; \theta ) } \end{array}$ where $\{ r _ { t + j } \} _ { j = i } ^ { k - 1 }$ are rewards observed by the agent, and $x _ { t + k }$ is the $k$ th state observed when starting from observed state $x _ { t }$ . The overall A3C loss is then $L ( { \dot { \theta } } ) = L ^ { \pi } ( \theta ) + \lambda L ^ { V } ( \theta )$ where $\lambda$ balances optimising the policy loss relative to the baseline value function loss.
+
+# 3 NOISYNETS FOR REINFORCEMENT LEARNING
+
+NoisyNets are neural networks whose weights and biases are perturbed by a parametric function of the noise. These parameters are adapted with gradient descent. More precisely, let $y = f _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ be a neural network parameterised by the vector of noisy parameters $\theta$ which takes the input $x$ and outputs $y$ . We represent the noisy parameters $\theta$ as $\boldsymbol { \theta } \stackrel { \mathrm { d e f } } { = } \boldsymbol { \mu } + \boldsymbol { \Sigma } \odot \boldsymbol { \varepsilon }$ , where $\zeta \ { \stackrel { \mathrm { d e f } } { = } } \ ( \mu , \Sigma )$ is a set of vectors of learnable parameters, $\varepsilon$ is a vector of zero-mean noise with fixed statistics and $\odot$ represents element-wise multiplication. The usual loss of the neural network is wrapped by expectation over the noise $\varepsilon \colon \bar { L } ( \zeta ) \ { \stackrel { \mathrm { d e f } } { = } } \ \mathbb { E } \left[ L ( \theta ) \right]$ . Optimisation now occurs with respect to the set of parameters $\zeta$ .
+
+Consider a linear layer of a neural network with $p$ inputs and $q$ outputs, represented by
+
+$$
+y = w x + b ,
+$$
+
+where $x \in \mathbb { R } ^ { p }$ is the layer input, $w \in \mathbb { R } ^ { q \times p }$ the weight matrix, and $b \in \mathbb { R } ^ { q }$ the bias. The corresponding noisy linear layer is defined as:
+
+$$
+\begin{array} { r l r } { y } & { \stackrel { \mathrm { d e f } } { = } } & { \big ( \mu ^ { w } + \sigma ^ { w } \odot \varepsilon ^ { w } \big ) x + \mu ^ { b } + \sigma ^ { b } \odot \varepsilon ^ { b } , } \end{array}
+$$
+
+where $\mu ^ { w } + \sigma ^ { w } \odot \varepsilon ^ { w }$ and $\mu ^ { b } + \sigma ^ { b } \odot \varepsilon ^ { b }$ replace $w$ and $b$ in Eq. (8), respectively. The parameters $\boldsymbol { \mu } ^ { w } \in \mathbb { R } ^ { q \times p }$ , $\boldsymbol { \mu } ^ { b } \in \mathbb { R } ^ { q }$ , $\sigma ^ { w } \in \mathbb { R } ^ { q \times p }$ and $\sigma ^ { b } \in \mathbb { R } ^ { q }$ are learnable whereas $\varepsilon ^ { \bar { w } } \in \mathbb { R } ^ { q \times p }$ and $\hat { \boldsymbol { \varepsilon } } ^ { b } \in \mathbb { R } ^ { q }$ are noise random variables (the specific choices of this distribution are described below). We provide a graphical representation of a noisy linear layer in Fig. 4 (see Appendix B).
+
+We now turn to explicit instances of the noise distributions for linear layers in a noisy network. We explore two options: Independent Gaussian noise, which uses an independent Gaussian noise entry per weight and Factorised Gaussian noise, which uses an independent noise per each output and another independent noise per each input. The main reason to use factorised Gaussian noise is to reduce the compute time of random number generation in our algorithms. This computational overhead is especially prohibitive in the case of single-thread agents such as DQN and Duelling. For this reason we use factorised noise for DQN and Duelling and independent noise for the distributed A3C, for which the compute time is not a major concern.
+
+(a) Independent Gaussian noise: the noise applied to each weight and bias is independent, where each entry $\varepsilon _ { i , j } ^ { w }$ (respectively each entry $\varepsilon _ { j } ^ { b }$ ) of the random matrix $\varepsilon ^ { w }$ (respectively of the random vector $\varepsilon ^ { b }$ ) is drawn from a unit Gaussian distribution. This means that for each noisy linear layer, there are $p q + q$ noise variables (for $p$ inputs to the layer and $q$ outputs).
+
+(b) Factorised Gaussian noof the inputs and and e: by factorising unit Gaussian v $\varepsilon _ { i , j } ^ { w }$ , webles n use for $p$ unit Gaussian variables ise of the outputs (thus $\varepsilon _ { i }$ noiseunit $q$ $\varepsilon _ { j }$ $p + q$ Gaussian variables in total). Each $\varepsilon _ { i , j } ^ { w }$ and $\varepsilon _ { j } ^ { b }$ can then be written as:
+
+$$
+\begin{array} { c } { { \varepsilon _ { i , j } ^ { w } = f ( \varepsilon _ { i } ) f ( \varepsilon _ { j } ) , } } \\ { { \varepsilon _ { j } ^ { b } = f ( \varepsilon _ { j } ) , } } \end{array}
+$$
+
+where $f$ is a real-valued function. In our experiments we used $f ( x ) = \operatorname { s g n } ( x ) { \sqrt { | x | } }$ . Note that for the bias Eq. (11) we could have set $f ( x ) = x$ , but we decided to keep the same output noise for weights and biases.
+
+Since the loss of a noisy network, $\bar { L } ( \zeta ) = \mathbb { E } \left[ L ( \theta ) \right]$ , is an expectation over the noise, the gradients are straightforward to obtain:
+
+$$
+\nabla \bar { L } ( \zeta ) = \nabla \mathbb { E } \left[ L ( \theta ) \right] = \mathbb { E } \left[ \nabla _ { \mu , \Sigma } L ( \mu + \Sigma \odot \varepsilon ) \right] .
+$$
+
+We use a Monte Carlo approximation to the above gradients, taking a single sample $\xi$ at each step of optimisation:
+
+$$
+\nabla \bar { L } ( \zeta ) \approx \nabla _ { \mu , \Sigma } L ( \mu + \Sigma \odot \xi ) .
+$$
+
+# 3.1 DEEP REINFORCEMENT LEARNING WITH NOISYNETS
+
+We now turn to our application of noisy networks to exploration in deep reinforcement learning. Noise drives exploration in many methods for reinforcement learning, providing a source of stochasticity external to the agent and the RL task at hand. Either the scale of this noise is manually tuned across a wide range of tasks (as is the practice in general purpose agents such as DQN or A3C) or it can be manually scaled per task. Here we propose automatically tuning the level of noise added to an agent for exploration, using the noisy networks training to drive down (or up) the level of noise injected into the parameters of a neural network, as needed.
+
+A noisy network agent samples a new set of parameters after every step of optimisation. Between optimisation steps, the agent acts according to a fixed set of parameters (weights and biases). This ensures that the agent always acts according to parameters that are drawn from the current noise distribution.
+
+Deep Q-Networks (DQN) and Dueling. We apply the following modifications to both DQN and Dueling: first, $\varepsilon$ -greedy is no longer used, but instead the policy greedily optimises the (randomised) action-value function. Secondly, the fully connected layers of the value network are parameterised as a noisy network, where the parameters are drawn from the noisy network parameter distribution after every replay step. We used factorised Gaussian noise as explained in (b) from Sec. 3. For replay, the current noisy network parameter sample is held fixed across the batch. Since DQN and Dueling take one step of optimisation for every action step, the noisy network parameters are re-sampled before every action. We call the new adaptations of DQN and Dueling, NoisyNet-DQN and NoisyNet-Dueling, respectively.
+
+We now provide the details of the loss function that our variant of DQN is minimising. When replacing the linear layers by noisy layers in the network (respectively in the target network), the parameterised action-value function $Q ( x , a , \varepsilon ; \zeta )$ (respectively $Q ( x , a , \varepsilon ^ { \prime } ; \zeta ^ { - } ) )$ can be seen as a random variable and the DQN loss becomes the NoisyNet-DQN loss:
+
+$$
+\bar { L } ( \zeta ) = \mathbb { E } \left[ \mathbb { E } _ { ( x , a , r , y ) \sim D } [ r + \gamma \operatorname* { m a x } _ { b \in A } Q ( y , b , \varepsilon ^ { \prime } ; \zeta ^ { - } ) - Q ( x , a , \varepsilon ; \zeta ) ] ^ { 2 } \right] ,
+$$
+
+where the outer expectation is with respect to distribution of the noise variables $\varepsilon$ for the noisy value function $Q ( x , a , \varepsilon ; \zeta )$ and the noise variable $\varepsilon ^ { \prime }$ for the noisy target value function $Q ( y , b , \varepsilon ^ { \prime } ; \zeta ^ { - } )$ . Computing an unbiased estimate of the loss is straightforward as we only need to compute, for each transition in the replay buffer, one instance of the target network and one instance of the online network. We generate these independent noises to avoid bias due to the correlation between the noise in the target network and the online network. Concerning the action choice, we generate another independent sample $\varepsilon ^ { \prime \prime }$ for the online network and we act greedily with respect to the corresponding output action-value function.
+
+Similarly the loss function for NoisyNet-Dueling is defined as:
+
+$$
+\begin{array} { r l } & { \bar { L } ( \zeta ) = \mathbb { E } \left[ \mathbb { E } _ { ( x , a , r , y ) \sim D } [ r + \gamma Q ( y , b ^ { * } ( y ) , \varepsilon ^ { \prime } ; \zeta ^ { - } ) - Q ( x , a , \varepsilon ; \zeta ) ] ^ { 2 } \right] } \\ & { b ^ { * } ( y ) = \arg \operatorname* { m a x } _ { b \in \mathcal { A } } Q ( y , b ( y ) , \varepsilon ^ { \prime \prime } ; \zeta ) . } \end{array}
+$$
+
+Both algorithms are provided in Appendix C.1.
+
+Asynchronous Advantage Actor Critic (A3C). A3C is modified in a similar fashion to DQN: firstly, the entropy bonus of the policy loss is removed. Secondly, the fully connected layers of the policy network are parameterised as a noisy network. We used independent Gaussian noise as explained in (a) from Sec. 3. In A3C, there is no explicit exploratory action selection scheme (such as $\epsilon$ -greedy); and the chosen action is always drawn from the current policy. For this reason, an entropy bonus of the policy loss is often added to discourage updates leading to deterministic policies. However, when adding noisy weights to the network, sampling these parameters corresponds to choosing a different current policy which naturally favours exploration. As a consequence of direct exploration in the policy space, the artificial entropy loss on the policy can thus be omitted. New parameters of the policy network are sampled after each step of optimisation, and since A3C uses $n$ step returns, optimisation occurs every $n$ steps. We call this modification of A3C, NoisyNet-A3C.
+
+Indeed, when replacing the linear layers by noisy linear layers (the parameters of the noisy network are now noted $\zeta ,$ ), we obtain the following estimation of the return via a roll-out of size $k$ :
+
+$$
+\hat { Q } _ { i } = \sum _ { j = i } ^ { k - 1 } \gamma ^ { j - i } r _ { t + j } + \gamma ^ { k - i } V ( x _ { t + k } ; \zeta , \varepsilon _ { i } ) .
+$$
+
+As A3C is an on-policy algorithm the gradients are unbiased when noise of the network is consistent for the whole roll-out. Consistency among action value functions $\hat { Q } _ { i }$ is ensured by letting letting the noise be the same throughout each rollout, i.e., $\forall i , \varepsilon _ { i } = \varepsilon$ . Additional details are provided in the Appendix A and the algorithm is given in Appendix C.2.
+
+# 3.2 INITIALISATION OF NOISY NETWORKS
+
+In the case of an unfactorised noisy networks, the parameters $\mu$ and $\sigma$ are initialised as follows. Each element $\mu _ { i , j }$ is sampled from independent uniform distributions $\mathcal { U } [ - \sqrt { \frac { 3 } { p } } , + \sqrt { \frac { 3 } { p } } ]$ , where $p$ is the number of inputs to the corresponding linear layer, and each element $\sigma _ { i , j }$ is simply set to 0.017 for all parameters. This particular initialisation was chosen because similar values worked well for the supervised learning tasks described in Fortunato et al. (2017), where the initialisation of the variances of the posteriors and the variances of the prior are related. We have not tuned for this parameter, but we believe different values on the same scale should provide similar results.
+
+For factorised noisy networks, each element $\mu _ { i , j }$ was initialised by a sample from an independent uniform distributions $\mathcal { U } [ - \frac { 1 } { \sqrt { p } } , + \frac { 1 } { \sqrt { p } } ]$ and each element $\sigma _ { i , j }$ was initialised to a constant $\textstyle { \frac { \sigma _ { 0 } } { \sqrt { p } } }$ The hyperparameter $\sigma _ { 0 }$ is set to 0.5.
+
+# 4 RESULTS
+
+We evaluated the performance of noisy network agents on 57 Atari games (Bellemare et al., 2015) and compared to baselines that, without noisy networks, rely upon the original exploration methods $\dot { \varepsilon }$ -greedy and entropy bonus).
+
+# 4.1 TRAINING DETAILS AND PERFORMANCE
+
+We used the random start no-ops scheme for training and evaluation as described the original DQN paper (Mnih et al., 2015). The mode of evaluation is identical to those of Mnih et al. (2016) where randomised restarts of the games are used for evaluation after training has happened. The raw average scores of the agents are evaluated during training, every 1M frames in the environment, by suspending learning and evaluating the latest agent for 500K frames. Episodes are truncated at 108K frames (or 30 minutes of simulated play) (van Hasselt et al., 2016).
+
+![](images/eeded447d8312644d3982e75d676773955b151dd915500a7e342fde559e0efa7.jpg)  
+(a) Improvement in percentage of NoisyNet-DQN over DQN (Mnih et al., 2015)
+
+![](images/917e01b1bc2ad5edeaa8bae15c927a06c2c30237e0db6f89675c6872d4960ee8.jpg)  
+(b) Improvement in percentage of NoisyNet-Dueling over Dueling (Wang et al., 2016)
+
+![](images/36fe170c45d35d080ac281feb91097f4b81424a3d03b0cb550b98ed0dc817432.jpg)  
+Figure 1: Comparison of NoisyNet agent versus the baseline according to Eq. (19). The maximum score is truncated at $2 5 0 \%$ .
+
+We consider three baseline agents: DQN (Mnih et al., 2015), duel clip variant of Dueling algorithm (Wang et al., 2016) and A3C (Mnih et al., 2016). The DQN and A3C agents were training for 200M and 320M frames, respectively. In each case, we used the neural network architecture from the corresponding original papers for both the baseline and NoisyNet variant. For the NoisyNet variants we used the same hyper parameters as in the respective original paper for the baseline.
+
+We compared absolute performance of agents using the human normalised score:
+
+$$
+1 0 0 \times \frac { \mathrm { S c o r e } _ { \mathrm { a g e n t } } - \mathrm { S c o r e } _ { \mathrm { R a n d o m } } } { \mathrm { S c o r e } _ { \mathrm { H u m a n } } - \mathrm { S c o r e } _ { \mathrm { R a n d o m } } } ,
+$$
+
+where human and random scores are the same as those in Wang et al. (2016). Note that the human normalised score is zero for a random agent and 100 for human level performance. Per-game maximum scores are computed by taking the maximum raw scores of the agent and then averaging over three seeds. However, for computing the human normalised scores in Figure 2, the raw scores are evaluated every 1M frames and averaged over three seeds. The overall agent performance is measured by both mean and median of the human normalised score across all 57 Atari games.
+
+The aggregated results across all 57 Atari games are reported in Table 1, while the individual scores for each game are in Table 3 from the Appendix E. The median human normalised score is improved in all agents by using NoisyNet, adding at least 18 (in the case of A3C) and at most 48 (in the case of DQN) percentage points to the median human normalised score. The mean human normalised score is also significantly improved for all agents. Interestingly the Dueling case, which relies on multiple modifications of DQN, demonstrates that NoisyNet is orthogonal to several other improvements made to DQN. We also compared relative performance of NoisyNet agents to the respective baseline agent
+
+<table><tr><td rowspan="2"></td><td colspan="2">Baseline</td><td colspan="2">NoisyNet</td><td rowspan="2">Improvement (On median)</td></tr><tr><td>Mean</td><td>Median</td><td>Mean</td><td>Median</td></tr><tr><td>DQN</td><td>319</td><td>83</td><td>379</td><td>123</td><td>48%</td></tr><tr><td>Dueling</td><td>524</td><td>132</td><td>633</td><td>172</td><td>30%</td></tr><tr><td>A3C</td><td>293</td><td>80</td><td>347</td><td>94</td><td>18%</td></tr></table>
+
+Table 1: Comparison between the baseline DQN, Dueling and A3C and their NoisyNet version in terms of median and mean human-normalised scores defined in Eq. (18). We report on the last column the percentage improvement on the baseline in terms of median human-normalised score.
+
+without noisy networks:
+
+$$
+1 0 0 \times \frac { \mathrm { S c o r e } _ { \mathrm { N o i s y N e t } } - \mathrm { S c o r e } _ { \mathrm { B a s e l i n e } } } { \mathrm { m a x } ( \mathrm { S c o r e } _ { \mathrm { H u m a n } } , \mathrm { S c o r e } _ { \mathrm { B a s e l i n e } } ) - \mathrm { S c o r e } _ { \mathrm { R a n d o m } } } .
+$$
+
+As before, the per-game score is computed by taking the maximum performance for each game and then averaging over three seeds. The relative human normalised scores are shown in Figure 1. As can be seen, the performance of NoisyNet agents (DQN, Dueling and A3C) is better for the majority of games relative to the corresponding baseline, and in some cases by a considerable margin. Also as it is evident from the learning curves of Fig. 2 NoisyNet agents produce superior performance compared to their corresponding baselines throughout the learning process. This improvement is especially significant in the case of NoisyNet-DQN and NoisyNet-Dueling. Also in some games, NoisyNet agents provide an order of magnitude improvement on the performance of the vanilla agent; as can be seen in Table 3 in the Appendix E with detailed breakdown of individual game scores and the learning curves plots from Figs 6, 7 and 8, for DQN, Dueling and A3C, respectively. We also ran some experiments evaluating the performance of NoisyNet-A3C with factorised noise. We report the corresponding learning curves and the scores in Fig. 5 and Table 2, respectively (see Appendix D). This result shows that using factorised noise does not lead to any significant decrease in the performance of A3C. On the contrary it seems that it has positive effects in terms of improving the median score as well as speeding up the learning process.
+
+![](images/f8b3e1a03cf45fff09d05d34bab186ac97fba302c9e577c3e086461de7c4120b.jpg)  
+Figure 2: Comparison of the learning curves of NoisyNet agent versus the baseline according to the median human normalised score.
+
+# 4.2 ANALYSIS OF LEARNING IN NOISY LAYERS
+
+In this subsection, we try to provide some insight on how noisy networks affect the learning process and the exploratory behaviour of the agent. In particular, we focus on analysing the evolution of the noise weights $\sigma ^ { w }$ and $\sigma ^ { b }$ throughout the learning process. We first note that, as $\bar { L } ( \zeta )$ is a positive and continuous function of $\zeta$ , there always exists a deterministic optimiser for the loss $L ( \zeta )$ (defined in
+
+Eq. (14)). Therefore, one may expect that, to obtain the deterministic optimal solution, the neural network may learn to discard the noise entries by eventually pushing $\sigma ^ { w } \mathrm { s }$ and $\sigma ^ { b }$ towards 0.
+
+To test this hypothesis we track the changes in $\sigma ^ { w } \mathbf { s }$ throughout the learning process. Let ${ \boldsymbol { \sigma } } _ { i } ^ { w }$ denote the $i ^ { \mathrm { { t h } } }$ weight of a noisy layer. We then define $\bar { \Sigma }$ , the mean-absolute of the $\sigma _ { i } ^ { w } \mathbf { s }$ of a noisy layer, as
+
+$$
+\bar { \Sigma } = \frac { 1 } { \mathrm { N } _ { \mathrm { w e i g h t s } } } \sum _ { i } | \sigma _ { i } ^ { w } | .
+$$
+
+Intuitively speaking $\bar { \Sigma }$ provides some measure of the stochasticity of the Noisy layers. We report the learning curves of the average of $\bar { \Sigma }$ across 3 seeds in Fig. 3 for a selection of Atari games in NoisyNet-DQN agent. We observe that $\bar { \Sigma }$ of the last layer of the network decreases as the learning proceeds in all cases, whereas in the case of the penultimate layer this only happens for 2 games out of 5 (Pong and Beam rider) and in the remaining 3 games $\bar { \Sigma }$ in fact increases. This shows that in the case of NoisyNet-DQN the agent does not necessarily evolve towards a deterministic solution as one might have expected. Another interesting observation is that the way $\bar { \Sigma }$ evolves significantly differs from one game to another and in some cases from one seed to another seed, as it is evident from the error bars. This suggests that NoisyNet produces a problem-specific exploration strategy as opposed to fixed exploration strategy used in standard DQN.
+
+![](images/01a19dddcbd8dd4681c12cfc247c4d3c15eeac77a5655fdd5b2f945cbccd6d13.jpg)  
+Figure 3: Comparison of the learning curves of the average noise parameter $\bar { \Sigma }$ across five Atari games in NoisyNet-DQN. The results are averaged across 3 seeds and error bars $+ / -$ standard deviation) are plotted.
+
+# 5 CONCLUSION
+
+We have presented a general method for exploration in deep reinforcement learning that shows significant performance improvements across many Atari games in three different agent architectures. In particular, we observe that in games such as Beam rider, Asteroids and Freeway that the standard DQN, Dueling and A3C perform poorly compared with the human player, NoisyNet-DQN, NoisyNet-Dueling and NoisyNet-A3C achieve super human performance, respectively. Although the improvements in performance might also come from the optimisation aspect since the cost functions are modified, the uncertainty in the parameters of the networks introduced by NoisyNet is the only exploration mechanism of the method. Having weights with greater uncertainty introduces more variability into the decisions made by the policy, which has potential for exploratory actions, but further analysis needs to be done in order to disentangle the exploration and optimisation effects.
+
+Another advantage of NoisyNet is that the amount of noise injected in the network is tuned automatically by the RL algorithm. This alleviates the need for any hyper parameter tuning (required with standard entropy bonus and $\epsilon$ -greedy types of exploration). This is also in contrast to many other methods that add intrinsic motivation signals that may destabilise learning or change the optimal policy. Another interesting feature of the NoisyNet approach is that the degree of exploration is contextual and varies from state to state based upon per-weight variances. While more gradients are needed, the gradients on the mean and variance parameters are related to one another by a computationally efficient affine function, thus the computational overhead is marginal. Automatic differentiation makes implementation of our method a straightforward adaptation of many existing methods. A similar randomisation technique can also be applied to LSTM units (Fortunato et al., 2017) and is easily extended to reinforcement learning, we leave this as future work.
+
+Note NoisyNet exploration strategy is not restricted to the baselines considered in this paper. In fact, this idea can be applied to any deep RL algorithms that can be trained with gradient descent, including DDPG (Lillicrap et al., 2015), TRPO (Schulman et al., 2015) or distributional RL (C51) (Bellemare et al., 2017). As such we believe this work is a step towards the goal of developing a universal exploration strategy.
+
+# REFERENCES
+
+Peter Auer and Ronald Ortner. Logarithmic online regret bounds for undiscounted reinforcement learning. Advances in Neural Information Processing Systems, 19:49, 2007.
+
+Mohammad Gheshlaghi Azar, Ian Osband, and Rémi Munos. Minimax regret bounds for reinforcement learning. arXiv preprint arXiv:1703.05449, 2017.
+
+Marc Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. In Twenty-Fourth International Joint Conference on Artificial Intelligence, 2015.
+
+Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In Advances in Neural Information Processing Systems, pp. 1471–1479, 2016.
+
+Marc G Bellemare, Will Dabney, and Rémi Munos. A distributional perspective on reinforcement learning. In International Conference on Machine Learning, pp. 449–458, 2017.
+
+Richard Bellman and Robert Kalaba. Dynamic programming and modern control theory. Academic Press New York, 1965.
+
+Dimitri Bertsekas. Dynamic programming and optimal control, volume 1. Athena Scientific, Belmont, MA, 1995.
+
+Chris M Bishop. Training with noise is equivalent to Tikhonov regularization. Neural computation, 7 (1):108–116, 1995.
+
+Charles Blundell, Julien Cornebise, Koray Kavukcuoglu, and Daan Wierstra. Weight uncertainty in neural networks. In Proceedings of The 32nd International Conference on Machine Learning, pp. 1613–1622, 2015.
+
+Jeremy Fix and Matthieu Geist. Monte-Carlo swarm policy search. In Swarm and Evolutionary Computation, pp. 75–83. Springer, 2012.
+
+Meire Fortunato, Charles Blundell, and Oriol Vinyals. Bayesian recurrent neural networks. arXiv preprint arXiv:1704.02798, 2017.
+
+Yarin Gal and Zoubin Ghahramani. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. In Maria Florina Balcan and Kilian Q. Weinberger (eds.), Proceedings of The 33rd International Conference on Machine Learning, volume 48 of Proceedings of Machine Learning Research, pp. 1050–1059, New York, New York, USA, 20–22 Jun 2016. PMLR. URL http://proceedings.mlr.press/v48/gal16.html.
+
+Matthieu Geist and Olivier Pietquin. Kalman temporal differences. Journal of artificial intelligence research, 39:483–532, 2010a.
+
+Matthieu Geist and Olivier Pietquin. Managing uncertainty within value function approximation in reinforcement learning. In Active Learning and Experimental Design workshop (collocated with AISTATS 2010), Sardinia, Italy, volume 92, 2010b.
+
+Alex Graves. Practical variational inference for neural networks. In Advances in Neural Information Processing Systems, pp. 2348–2356, 2011.
+
+Elad Hazan, Kfir Yehuda Levy, and Shai Shalev-Shwartz. On graduated optimization for stochastic non-convex problems. In International Conference on Machine Learning, pp. 1833–1841, 2016.
+
+Geoffrey E Hinton and Drew Van Camp. Keeping the neural networks simple by minimizing the description length of the weights. In Proceedings of the sixth annual conference on Computational learning theory, pp. 5–13. ACM, 1993.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Flat minima. Neural Computation, 9(1):1–42, 1997.
+
+Rein Houthooft, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. VIME: Variational information maximizing exploration. In Advances in Neural Information Processing Systems, pp. 1109–1117, 2016.
+
+Thomas Jaksch, Ronald Ortner, and Peter Auer. Near-optimal regret bounds for reinforcement learning. Journal of Machine Learning Research, 11(Apr):1563–1600, 2010.
+
+Michael Kearns and Satinder Singh. Near-optimal reinforcement learning in polynomial time. Machine Learning, 49(2-3):209–232, 2002.
+
+Tor Lattimore, Marcus Hutter, and Peter Sunehag. The sample-complexity of general reinforcement learning. In Proceedings of The 30th International Conference on Machine Learning, pp. 28–36, 2013.
+
+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.
+
+Zachary C Lipton, Jianfeng Gao, Lihong Li, Xiujun Li, Faisal Ahmed, and Li Deng. Efficient exploration for dialogue policy learning with BBQ networks & replay buffer spiking. arXiv preprint arXiv:1608.05081, 2016.
+
+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–533, 2015.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, pp. 1928–1937, 2016.
+
+Hossein Mobahi. Training recurrent neural networks by diffusion. arXiv preprint arXiv:1601.04114, 2016.
+
+David E Moriarty, Alan C Schultz, and John J Grefenstette. Evolutionary algorithms for reinforcement learning. Journal of Artificial Intelligence Research, 11:241–276, 1999.
+
+Ian Osband, Benjamin Van Roy, and Zheng Wen. Generalization and exploration via randomized value functions. arXiv preprint arXiv:1402.0635, 2014.
+
+Ian Osband, Charles Blundell, Alexander Pritzel, and Benjamin Van Roy. Deep exploration via bootstrapped DQN. In Advances In Neural Information Processing Systems, pp. 4026–4034, 2016.
+
+Ian Osband, Daniel Russo, Zheng Wen, and Benjamin Van Roy. Deep exploration via randomized value functions. arXiv preprint arXiv:1703.07608, 2017.
+
+Georg Ostrovski, Marc G Bellemare, Aaron van den Oord, and Remi Munos. Count-based exploration with neural density models. arXiv preprint arXiv:1703.01310, 2017.
+
+Pierre-Yves Oudeyer and Frederic Kaplan. What is intrinsic motivation? A typology of computational approaches. Frontiers in neurorobotics, 1, 2007.
+
+Matthias Plappert, Rein Houthooft, Prafulla Dhariwal, Szymon Sidor, Richard Y Chen, Xi Chen, Tamim Asfour, Pieter Abbeel, and Marcin Andrychowicz. Parameter space noise for exploration. arXiv preprint arXiv:1706.01905, 2017.
+
+Martin Puterman. Markov decision processes: discrete stochastic dynamic programming. John Wiley & Sons, 1994.
+
+Tim Salimans, J. Ho, X. Chen, and I. Sutskever. Evolution Strategies as a Scalable Alternative to Reinforcement Learning. ArXiv e-prints, 2017.   
+Jürgen Schmidhuber. Formal theory of creativity, fun, and intrinsic motivation (1990–2010). IEEE Transactions on Autonomous Mental Development, 2(3):230–247, 2010.   
+J. Schulman, S. Levine, P. Abbeel, M. Jordan, and P. Moritz. Trust region policy optimization. In Proc. of ICML, pp. 1889–1897, 2015.   
+Satinder P Singh, Andrew G Barto, and Nuttapong Chentanez. Intrinsically motivated reinforcement learning. In NIPS, volume 17, pp. 1281–1288, 2004.   
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. Cambridge Univ Press, 1998.   
+Richard S. Sutton, David A. McAllester, Satinder P. Singh, and Yishay Mansour. Policy gradient methods for reinforcement learning with function approximation. In Proc. of NIPS, volume 99, pp. 1057–1063, 1999.   
+William R Thompson. On the likelihood that one unknown probability exceeds another in view of the evidence of two samples. Biometrika, 25(3/4):285–294, 1933.   
+Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. In Proc. of AAAI, pp. 2094–2100, 2016.   
+Ziyu Wang, Tom Schaul, Matteo Hessel, Hado van Hasselt, Marc Lanctot, and Nando de Freitas. Dueling network architectures for deep reinforcement learning. In Proceedings of The 33rd International Conference on Machine Learning, pp. 1995–2003, 2016.   
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992.
+
+# A NOISYNET-A3C IMPLEMENTATION DETAILS
+
+In contrast with value-based algorithms, policy-based methods such as A3C (Mnih et al., 2016) parameterise the policy $\pi ( a | x ; \bar { \theta _ { \pi } } )$ directly and update the parameters $\theta _ { \pi }$ by performing a gradient ascent on the mean value-function $\mathbb { E } _ { x \sim D } [ V ^ { \pi ( \cdot | \cdot ; \theta _ { \pi } ) } ( x ) ]$ (also called the expected return) (Sutton et al., 1999). A3C uses a deep neural network with weights $\theta = \theta _ { \pi } \cup \theta _ { V }$ to parameterise the policy $\pi$ and the value $V$ . The network has one softmax output for the policy-head $\pi ( \cdot | \cdot ; \theta _ { \pi } )$ and one linear output for the value-head $V ( \cdot ; \theta _ { V } )$ , with all non-output layers shared. The parameters $\theta _ { \pi }$ (resp. $\theta _ { V }$ ) are relative to the shared layers and the policy head (resp. the value head). A3C is an asynchronous and online algorithm that uses roll-outs of size $k + 1$ of the current policy to perform a policy improvement step.
+
+For simplicity, here we present the A3C version with only one thread. For a multi-thread implementation, refer to the pseudo-code C.2 or to the original A3C paper (Mnih et al., 2016). In order to train the policy-head, an approximation of the policy-gradient is computed for each state of the roll-out $( x _ { t + i } , a _ { t + i } \sim \pi ( \cdot | x _ { t + i } ; \theta _ { \pi } ) , r _ { t + i } ) _ { i = 0 } ^ { k }$ :
+
+$$
+\nabla _ { \boldsymbol { \theta } _ { \pi } } \log ( \pi ( a _ { t + i } | \boldsymbol { x } _ { t + i } ; \boldsymbol { \theta } _ { \pi } ) ) [ \hat { Q } _ { i } - V ( \boldsymbol { x } _ { t + i } ; \boldsymbol { \theta } _ { V } ) ] ,
+$$
+
+where $\hat { Q } _ { i }$ is an estimation of the return $\begin{array} { r } { \hat { Q } _ { i } = \sum _ { j = i } ^ { k - 1 } \gamma ^ { j - i } r _ { t + j } + \gamma ^ { k - i } V ( x _ { t + k } ; \theta _ { V } ) } \end{array}$ . The gradients
+
+$$
+\sum _ { i = 0 } ^ { k } \nabla _ { \theta _ { \pi } } \log ( \pi ( a _ { t + i } | x _ { t + i } ; \theta _ { \pi } ) ) [ \hat { Q } _ { i } - V ( x _ { t + i } ; \theta _ { V } ) ] .
+$$
+
+A3C trains the value-head by minimising the error between the estimated return and the value $\textstyle \sum _ { i = 0 } ^ { k } ( \hat { Q } _ { i } - V ( x _ { t + i } ; \theta _ { V } ) ) ^ { 2 }$ . Therefore, the network parameters $( \theta _ { \pi } , \theta _ { V } )$ are updated after each
+
+$$
+\begin{array} { l } { { \displaystyle \theta _ { \pi }  \theta _ { \pi } + \alpha _ { \pi } \sum _ { i = 0 } ^ { k } \nabla _ { \theta _ { \pi } } \log ( \pi ( a _ { t + i } | x _ { t + i } ; \theta _ { \pi } ) ) [ \hat { Q } _ { i } - V ( x _ { t + i } ; \theta _ { V } ) ] } , } \\ { { \displaystyle \theta _ { V }  \theta _ { V } - \alpha _ { V } \sum _ { i = 0 } ^ { k } \nabla _ { \theta _ { V } } [ \hat { Q } _ { i } - V ( x _ { t + i } ; \theta _ { V } ) ] ^ { 2 } , } } \end{array}
+$$
+
+where $( \alpha _ { \pi } , \alpha _ { V } )$ are hyper-parameters. As mentioned previously, in the original A3C algorithm, it is recommended to add an entropy term $\begin{array} { r } { \beta \sum _ { i = 0 } ^ { k } \nabla _ { \theta _ { \pi } } H ( \pi ( \cdot | x _ { t + i } ; \theta _ { \pi } ) ) } \end{array}$ to the policy update, where $\begin{array} { r } { H ( \pi ( \cdot | x _ { t + i } ; \theta _ { \pi } ) ) = - \beta \sum _ { a \in A } \pi ( a | x _ { t + i } ; \theta _ { \pi } ) \overset { \longleftrightarrow } { \log } ( \pi ( a | x _ { t + i } ; \theta _ { \pi } ) ) } \end{array}$ . Indeed, this term encourages exploration as it favours policies which are uniform over actions. When replacing the linear layers in the value and policy heads by noisy layers (the parameters of the noisy network are now $\zeta _ { \pi }$ and $\zeta _ { V }$ ), we obtain the following estimation of the return via a roll-out of size $k$ :
+
+$$
+\hat { Q } _ { i } = \sum _ { j = i } ^ { k - 1 } \gamma ^ { j - i } r _ { t + j } + \gamma ^ { k - i } V ( x _ { t + k } ; \zeta _ { V } , \varepsilon _ { i } ) .
+$$
+
+We would like $\hat { Q } _ { i }$ to be a consistent estimate of the return of the current policy. To do so, we should force $\forall i , \varepsilon _ { i } = \varepsilon$ . As A3C is an on-policy algorithm, this involves fixing the noise of the network for the whole roll-out so that the policy produced by the network is also fixed. Hence, each update of the parameters $( \zeta _ { \pi } , \zeta _ { V } )$ is done after each roll-out with the noise of the whole network held fixed for the duration of the roll-out:
+
+$$
+\begin{array} { l } { { \zeta _ { \pi }  \zeta _ { \pi } + \alpha _ { \pi } \displaystyle \sum _ { i = 0 } ^ { k } \nabla _ { \zeta _ { \pi } } \log ( \pi ( a _ { t + i } | x _ { t + i } ; \zeta _ { \pi } , \varepsilon ) ) [ \hat { Q } _ { i } - V ( x _ { t + i } ; \zeta _ { V } , \varepsilon ) ] , } } \\ { { \zeta _ { V }  \zeta _ { V } - \alpha _ { V } \displaystyle \sum _ { i = 0 } ^ { k } \nabla _ { \zeta _ { V } } [ \hat { Q } _ { i } - V ( x _ { t + i } ; \zeta _ { V } , \varepsilon ) ] ^ { 2 } . } } \end{array}
+$$
+
+# B NOISY LINEAR LAYER
+
+In this Appendix we provide a graphical representation of noisy layer.
+
+![](images/b70a3d226cd97ad825e8a231ab55d9475756027b821c58c9416e952334960955.jpg)  
+Figure 4: Graphical representation of a noisy linear layer. The parameters $\mu ^ { w }$ , $\mu ^ { b }$ , $\sigma ^ { w }$ and $\sigma ^ { b }$ are the learnables of the network whereas $\varepsilon ^ { w }$ and $\dot { \varepsilon } ^ { b }$ are noise variables which can be chosen in factorised or non-factorised fashion. The noisy layer functions similarly to the standard fully connected linear layer. The main difference is that in the noisy layer both the weights vector and the bias is perturbed by some parametric zero-mean noise, that is, the noisy weights and the noisy bias can be expressed as $w = \mu ^ { w } + \sigma ^ { w } \odot \varepsilon ^ { w }$ and $b = \mu ^ { b } + \sigma ^ { b } \odot \varepsilon ^ { b }$ , respectively. The output of the noisy layer is then simply obtained as $y = w x + b$ .
+
+# C ALGORITHMS
+
+C.1 NOISYNET-DQN AND NOISYNET-DUELING
+
+# Algorithm 1: NoisyNet-DQN / NoisyNet-Dueling
+
+Input :Env Environment; $\varepsilon$ set of random variables of the network   
+Input :DUELING Boolean; "true" for NoisyNet-Dueling and "false" for NoisyNet-DQN   
+Input : $B$ empty replay buffer; $\zeta$ initial network parameters; $\zeta ^ { - }$ initial target network parameters   
+Input : $N _ { B }$ replay buffer size; $N _ { T }$ training batch size; $N ^ { - }$ target network replacement frequency   
+Output : $Q ( \cdot , \varepsilon ; \zeta )$ action-value function
+
+1 for episode $e \in \{ 1 , \ldots , M \}$ do
+
+2 Initialise state sequence $x _ { 0 } \sim E n v$ 3 for $t \in \{ 1 , \ldots \}$ do $/ \star l [ - 1 ]$ is the last element of the list l \*/ 4 Set $x  x _ { 0 }$ 5 Sample a noisy network $\xi \sim \varepsilon$ 6 Select an action $a \gets \operatorname { a r g m a x } _ { b \in A } Q ( x , b , \xi ; \zeta )$ 7 Sample next state $y \sim P ( \cdot | x , a )$ , receive reward $r \gets R ( x , a )$ and set $x _ { 0 } \gets y$ 8 Add transition $( x , a , r , y )$ to the replay buffer $B [ - 1 ]  ( x , a , r , y )$ 9 if $| B | > N _ { B }$ then 10 Delete oldest transition from $B$ 11 end $/ \star \_ D$ is a distribution over the replay, it can be uniform or implementing prioritised replay \*/ 12 Sample a minibatch of $N _ { T }$ transitions $( ( x _ { j } , a _ { j } , r _ { j } , y _ { j } ) \sim D ) _ { j = 1 } ^ { N _ { T } }$ Construction of the target values. \*/ 13 Sample the noisy variable for the online network $\xi \sim \varepsilon$ 14 Sample the noisy variables for the target network $\xi ^ { \prime } \sim \varepsilon$ 15 if DUELING then 16 Sample the noisy variables for the action selection network $\xi ^ { \prime \prime } \sim \varepsilon$ 17 for $j \in \bar { \left\{ 1 , \dots , N _ { T } \right\} }$ do 18 if $y _ { j }$ is a terminal state then 19 ${ \widehat { Q } } \gets r _ { j }$ 20 if DUELING then 21 $\begin{array} { l } { { b ^ { * } ( y _ { j } ) = \arg \operatorname* { m a x } _ { b \in \cal { A } } Q ( y _ { j } , b , \xi ^ { \prime \prime } ; \zeta ) } } \\ { { \widehat { Q }  r _ { j } + \gamma Q ( y _ { j } , b ^ { * } ( y _ { j } ) , \xi ^ { \prime } ; \zeta ^ { - } ) } } \end{array}$ 22 23 else 24 $\begin{array} { r } { \widehat { Q }  r _ { j } + \gamma \operatorname* { m a x } _ { b \in A } Q ( y _ { j } , b , \xi ^ { \prime } ; \zeta ^ { - } ) } \end{array}$ 25 Do a gradient step with loss $( \widehat { Q } - Q ( x _ { j } , a _ { j } , \xi ; \zeta ) ) ^ { 2 }$ 26 end 27 if $t \equiv 0$ (mod $N ^ { - }$ ) then 28 Update the target network: $\zeta ^ { - }  \zeta$ 29 end 30 end 31 end
+
+# C.2 NOISYNET-A3C
+
+Input :Environment $E n v$ , Global shared parameters $( \zeta _ { \pi } , \zeta _ { V } )$ , global shared counter $T$ and maximal time Tmax. Input :Thread-specific parameters $\left( \zeta _ { \pi } ^ { \prime } , \zeta _ { V } ^ { \prime } \right)$ , Set of random variables $\varepsilon$ , thread-specific counter $t$ and roll-out size $t _ { m a x }$ . Output : $\pi ( \cdot ; \zeta _ { \pi } , \varepsilon )$ the policy and $V ( \cdot ; \zeta _ { V } , \varepsilon )$ the value. 1 Initial thread counter $t \gets 1$ 2 repeat 3 Reset cumulative gradients: $d \zeta _ { \pi } \gets 0$ and $d \zeta _ { V } \gets 0$ . 4 Synchronise thread-specific parameters: $\zeta _ { \pi } ^ { \prime } \gets \zeta _ { \pi }$ and $\zeta _ { V } ^ { \prime }  \zeta _ { V }$ . 5 counter $\gets 0$ . 6 Get state $x _ { t }$ from $E n v$ 7 Choice of the noise: $\xi \sim \varepsilon$ $\mathbf { \nabla } / \star \mathbf { \nabla } r$ is a list of rewards \*/ 8 $r \gets [ ]$ $\mathbf { \nabla } / \star \mathbf { \nabla } a$ is a list of actions \*/ 9 $a \gets [ ]$ $/ \star x$ is a list of states \*/ 10 $x \gets [ ]$ and $x [ 0 ]  x _ { t }$ 11 repeat 12 Policy choice: $a _ { t } \sim \pi ( \cdot | x _ { t } ; \zeta _ { \pi } ^ { \prime } ; \xi )$ 13 $a [ - 1 ]  a _ { t }$ 14 Receive reward $r _ { t }$ and new state $x _ { t + 1 }$ 15 $r [ - 1 ]  r _ { t }$ and $x [ - 1 ]  x _ { t + 1 }$ 16 $t \gets t + 1$ and $T \gets T + 1$ 17 $c o u n t e r = c o u n t e r + 1$ 18 until $x _ { t }$ terminal or counter $= = t _ { m a x } + 1$ 19 if $x _ { t }$ is a terminal state then 20 $\mid \mathrm { ~ \boldsymbol ~ Q ~ } = 0$ 21 else 22 $Q = V ( x _ { t } ; \zeta _ { V } ^ { \prime } , \xi )$ 23 for $i \in \{ c o u n t e r - 1 , \ldots , 0 \}$ do 24 Update $Q$ : $Q  r [ i ] + \gamma Q$ . 25 Accumulate policy-gradient: $d \zeta _ { \pi } \gets d \zeta _ { \pi } + \nabla _ { \zeta _ { \pi } ^ { \prime } } \log ( \pi ( a [ i ] | x [ i ] ; \zeta _ { \pi } ^ { \prime } , \xi ) ) [ Q - V ( x [ i ] ; \zeta _ { V } ^ { \prime } , \xi ) ] .$ 26 Accumulate value-gradient: $d \zeta _ { V } \gets d \zeta _ { V } + \nabla _ { \zeta _ { V } ^ { \prime } } [ Q - V ( x [ i ] ; \zeta _ { V } ^ { \prime } , \xi ) ] ^ { 2 }$ . 27 end 28 Perform asynchronous update of $\zeta _ { \pi } \colon \zeta _ { \pi } \gets \zeta _ { \pi } + \alpha _ { \pi } d \zeta _ { \pi }$ 29 Perform asynchronous update of $\zeta _ { V }$ : $\zeta _ { V } \gets \zeta _ { V } - \alpha _ { V } d \zeta _ { V }$ 30 until $T > T _ { m a x }$
+
+# D COMPARISON BETWEEN NOISYNET-A3C (FACTORISED AND NON-FACTORISED NOISE) AND A3C
+
+![](images/c1f0a81c99291ae78a48479af58b8e667b7a761d1edbd74439a066d0e221ddbb.jpg)  
+Figure 5: Comparison of the learning curves of factorised and non-factorised NoisyNet-A3C versus the baseline according to the median human normalised score.
+
+<table><tr><td></td><td colspan="2">Baseline</td><td colspan="2">NoisyNet</td><td rowspan="2">Improvement (On median)</td></tr><tr><td></td><td>Mean</td><td>Median</td><td>Mean</td><td>Median</td></tr><tr><td>DQN</td><td>319</td><td>83</td><td>379</td><td>123</td><td>48%</td></tr><tr><td>Dueling</td><td>524</td><td>132</td><td>633</td><td>172</td><td>30%</td></tr><tr><td>A3C</td><td>293</td><td>80</td><td>347</td><td>94</td><td>18%</td></tr><tr><td>A3C (factorised)</td><td>293</td><td>80</td><td>276</td><td>99</td><td>24 %</td></tr></table>
+
+Table 2: Comparison between the baseline DQN, Dueling and A3C and their NoisyNet version in terms of median and mean human-normalised scores defined in Eq. (18). In the case of A3C we inculde both factorised and non-factorised variant of the algorithm. We report on the last column the percentage improvement on the baseline in terms of median human-normalised score.
+
+# E LEARNING CURVES AND RAW SCORES
+
+Here we directly compare the performance of DQN, Dueling DQN and A3C and their NoisyNet counterpart by presenting the maximal score in each of the 57 Atari games (Table 3), averaged over three seeds. In Figures 6-8 we show the respective learning curves.   
+Table 3: Raw scores across all games with random starts.   
+
+<table><tr><td>Games</td><td>Human</td><td>Random</td><td>DQN</td><td>NoisyNet-DQN</td><td>A3C</td><td>NoisyNet-A3C</td><td>Dueling</td><td>NoisyNet-Dueling</td></tr><tr><td>alien</td><td>7128</td><td>228</td><td>2404±242</td><td>2403±78</td><td>2027±92</td><td>1899±111</td><td>6163±1077</td><td>5778±2189</td></tr><tr><td>amidar</td><td>1720</td><td>6</td><td>924±159</td><td>1610 ± 228</td><td>904±125</td><td>491±485</td><td>2296±154</td><td>3537±521</td></tr><tr><td>assault</td><td>742</td><td>222</td><td>3595±169</td><td>5510±483</td><td>2879±293</td><td>3060 ±101</td><td>8010 ±381</td><td>11231± 503</td></tr><tr><td>asterix</td><td>8503</td><td>210</td><td>6253±154</td><td>14328± 2859</td><td>6822 ±181</td><td>32478±2567</td><td>11170 ± 5355</td><td>28350± 607</td></tr><tr><td>asteroids</td><td>47389</td><td>719</td><td>1824±83</td><td>3455±1054</td><td>2544±523</td><td>4541 ± 311</td><td>2220±91</td><td>86700 ± 80459</td></tr><tr><td>atlantis</td><td>29028</td><td>12580</td><td>876000 ± 15013</td><td>923733 ± 25798</td><td>422700 ± 4759</td><td>465700 ± 4224</td><td>902742 ± 17087</td><td>972175 ± 31961</td></tr><tr><td>bank heist</td><td>753</td><td>14</td><td>455±25</td><td>1068 ± 277</td><td>1296±20</td><td>1033±463</td><td>1428±37</td><td>1318±37</td></tr><tr><td>battle zone</td><td>37188</td><td>2360</td><td>28981 ± 1497</td><td>36786±2892</td><td>16411 ±1283</td><td>17871 ± 5007</td><td>40481 ± 2161</td><td>52262 ±1480</td></tr><tr><td>beam rider</td><td>16926</td><td>364</td><td>10564 ± 613</td><td>20793±284</td><td>9214±608</td><td>11237 ± 1582</td><td>16298 ± 1101</td><td>18501 ± 662</td></tr><tr><td>berzerk</td><td>2630</td><td>124</td><td>634±16</td><td>905±21</td><td>1022 ±151</td><td>1235±259</td><td>1122 ±35</td><td>1896 ± 604</td></tr><tr><td>bowling</td><td>161</td><td>23</td><td>62±4</td><td>71±26</td><td>37±2</td><td>42 ±11</td><td>72±6</td><td>68±6</td></tr><tr><td>boxing</td><td>12</td><td>0</td><td>87±1</td><td>89±4</td><td>91±1</td><td>100±0</td><td>99±0</td><td>100±0</td></tr><tr><td>breakout</td><td>30</td><td>2</td><td>396±13</td><td>516±26</td><td>496±56</td><td>374±27</td><td>200±21</td><td>263±20</td></tr><tr><td>centipede</td><td>12017</td><td>2091</td><td>6440 ± 1194</td><td>4269 ± 261</td><td>5350±432</td><td>8282 ±685</td><td>4166± 23</td><td>7596±1134</td></tr><tr><td>chopper command</td><td>7388</td><td>811</td><td>7271±473</td><td>8893 ±871</td><td>5285±159</td><td>7561±1190</td><td>7388 ±1024</td><td>11477 ±1299</td></tr><tr><td>crazy climber</td><td>35829</td><td>10780</td><td>116480 ± 896</td><td>118305 ± 7796</td><td>134783± 5495</td><td>139950 ± 18190</td><td>163335±2460</td><td>171171 ± 2095</td></tr><tr><td>defender</td><td>18689</td><td>2874</td><td>18303 ± 2611</td><td>20525± 3114</td><td>52917±3355</td><td>55492± 3844</td><td>37275±1572</td><td>42253±2142</td></tr><tr><td>demon attack</td><td>1971</td><td>152</td><td>12696±214</td><td>36150 ± 4646</td><td>37085±803</td><td>37880±2093</td><td>61033 ± 9707</td><td>69311 ± 26289</td></tr><tr><td>double dunk</td><td>-16</td><td>-19</td><td>-6±1</td><td>1±0</td><td>3±1</td><td>3±1</td><td>17±7</td><td>1±0</td></tr><tr><td>enduro</td><td>860</td><td>0</td><td>835±56</td><td>1240±83</td><td>0±0</td><td>300±424</td><td>2064±81</td><td>2013 ±219</td></tr><tr><td>fishing derby</td><td>-39</td><td>-92</td><td>4±4</td><td>11±2</td><td>-7±30</td><td>-38±39</td><td>35±5</td><td>57±2</td></tr><tr><td>freeway</td><td>30</td><td>0</td><td>31±0</td><td>32±0</td><td>0±0</td><td>18±13</td><td>34±0</td><td>34±0</td></tr><tr><td>frostbite</td><td>4335</td><td>65</td><td>1000±258</td><td>753 ±101</td><td>288±20</td><td>261±0</td><td>2807 ±1457</td><td>2923 ±1519</td></tr><tr><td>gopher</td><td>2412</td><td>258</td><td>11825 ± 1444</td><td>14574 ± 1837</td><td>7992 ± 672</td><td>12439 ± 16229</td><td>27313 ± 2629</td><td>38909± 2229</td></tr><tr><td>gravitar</td><td>3351</td><td>173</td><td>366±26</td><td>447±94</td><td>379±31</td><td>314±25</td><td>1682 ±170</td><td>2209±99</td></tr><tr><td>hero</td><td>30826</td><td>1027</td><td>15176 ± 3870</td><td>6246±2092</td><td>30791± 246</td><td>8471±4332</td><td>35895±1035</td><td>31533±4970</td></tr><tr><td>ice hockey</td><td>1</td><td>-11</td><td>-2±0</td><td>-3±0</td><td>-2±0</td><td>-3±1</td><td>-0±0</td><td>3±1</td></tr><tr><td>jamesbond</td><td>303</td><td>29</td><td>909±223</td><td>1235± 421</td><td>509±34</td><td>188 ±103</td><td>1667 ±134</td><td>4682 ± 2281</td></tr><tr><td>kangaroo</td><td>3035</td><td>52</td><td>8166 ± 1512</td><td>10944± 4149</td><td>1166 ±76</td><td>1604 ±278</td><td>14847±29</td><td>15227 ± 243</td></tr><tr><td>krull</td><td>2666</td><td>1598</td><td>8343±79</td><td>8805±313</td><td>9422 ±980</td><td>22849±12175</td><td>10733±65</td><td>10754 ± 181</td></tr><tr><td>kung fu master</td><td>22736</td><td>258</td><td>30444 ±1673</td><td>36310±5093</td><td>37422 ± 2202</td><td>55790± 23886</td><td>30316±2397</td><td>41672 ± 1668</td></tr><tr><td>montezuma revenge</td><td>4753</td><td>0</td><td>2±3</td><td>3±4</td><td>14 ±12</td><td>4±3</td><td>0±0</td><td>57±15</td></tr><tr><td>ms pacman</td><td>6952</td><td>307</td><td>2674±43</td><td>2722 ±148</td><td>2436±249</td><td>3401 ±761</td><td>3650±445</td><td>5546±367</td></tr><tr><td>name this game</td><td>8049</td><td>2292</td><td>8179 ± 551</td><td>8181±742</td><td>7168± 224</td><td>8798±1847</td><td>9919 ±38</td><td>12211 ± 251</td></tr><tr><td>phoenix</td><td>7243</td><td>761</td><td>9704 ± 2907</td><td>16028 ± 3317</td><td>9476±569</td><td>50338± 30396</td><td>8215±403</td><td>10379 ± 547</td></tr><tr><td>pitfall</td><td>6464</td><td>-229</td><td>0±0</td><td>0±0</td><td>0±0</td><td>0±0</td><td>0±0</td><td>0±0</td></tr><tr><td>pong</td><td>15</td><td>-21</td><td>20±0</td><td>21±0</td><td>7±19</td><td>12 ± 11</td><td>21±0</td><td>21±0</td></tr><tr><td>private eye</td><td>69571</td><td>25</td><td>2361±781</td><td>3712 ± 161</td><td>3781 ± 2994</td><td>100±0</td><td>227±138</td><td>279 ±109</td></tr><tr><td>qbert</td><td>13455</td><td>164</td><td>11241 ± 1579</td><td>15545± 462</td><td>18586± 574</td><td>17896 ± 1522</td><td>19819 ± 2640</td><td>27121± 422</td></tr><tr><td>riverraid</td><td>17118</td><td>1338</td><td>7241 ±140</td><td>9425±705</td><td>8135±483</td><td>7878±162</td><td>18405±93</td><td>23134±1434</td></tr><tr><td>road runner</td><td>7845</td><td>12</td><td>37910 ± 1778</td><td>45993± 2709</td><td>45315±1837</td><td>30454±13309</td><td>64051 ± 1106</td><td>234352 ±132671</td></tr><tr><td>robotank</td><td>12</td><td>2</td><td>55±1</td><td>51±5</td><td>6±0</td><td>36±3</td><td>63±1</td><td>64±1</td></tr><tr><td>seaquest</td><td>42055</td><td>68</td><td>4163±425</td><td>2282±361</td><td>1744±0</td><td>943± 41</td><td>19595 ± 1493</td><td>16754 ± 6619</td></tr><tr><td>skiing</td><td>-4337</td><td>-17098 1263</td><td>-12630± 202 4055±842</td><td>-14763 ± 706 6088 ± 1791</td><td>-12972 ± 2846 12380 ± 519</td><td>-15970 ± 9887 10427 ± 3878</td><td>-7989 ±1349 3423±152</td><td>-7550 ±451 6522±750</td></tr><tr><td>solaris space invaders</td><td>12327 1669</td></table>
+
+![](images/6dc44e0375370dd767c5132066e9fefe60e4ea11ef83a24c8080a304d861926c.jpg)  
+Figure 6: Training curves for all Atari games comparing DQN and NoisyNet-DQN.
+
+![](images/0fbae35b0515600598535510a646f79b1428b22f14c18bc4db668379f4b93e65.jpg)  
+Figure 7: Training curves for all Atari games comparing Duelling and NoisyNet-Dueling.
+
+![](images/6f151046db4ae4e8405824f408a132d27b98762db382818789fbaf61f357b673.jpg)  
+Figure 8: Training curves for all Atari games comparing A3C and NoisyNet-A3C.