Add files using upload-large-folder tool

parse/train/Hyq4yhile/Hyq4yhile.md

@@ -0,0 +1,272 @@
+# LEARNING INVARIANT FEATURE SPACES TO TRANSFER SKILLS WITH REINFORCEMENT LEARNING
+
+Abhishek Gupta†∗, Coline Devin†∗, YuXuan Liu†, Pieter Abbeel†‡, Sergey Levine† † UC Berkeley, Department of Electrical Engineering and Computer Science ‡ OpenAI {abhigupta,coline,svlevine}@eecs.berkeley.edu {yuxuanliu}@berkeley.edu {pieter}@openai.com
+
+# ABSTRACT
+
+People can learn a wide range of tasks from their own experience, but can also learn from observing other creatures. This can accelerate acquisition of new skills even when the observed agent differs substantially from the learning agent in terms of morphology. In this paper, we examine how reinforcement learning algorithms can transfer knowledge between morphologically different agents (e.g., different robots). We introduce a problem formulation where two agents are tasked with learning multiple skills by sharing information. Our method uses the skills that were learned by both agents to train invariant feature spaces that can then be used to transfer other skills from one agent to another. The process of learning these invariant feature spaces can be viewed as a kind of “analogy making,” or implicit learning of partial correspondences between two distinct domains. We evaluate our transfer learning algorithm in two simulated robotic manipulation skills, and illustrate that we can transfer knowledge between simulated robotic arms with different numbers of links, as well as simulated arms with different actuation mechanisms, where one robot is torque-driven while the other is tendon-driven.
+
+# 1 INTRODUCTION
+
+People can learn large repertoires of motor skills autonomously from their own experience. However, learning is accelerated substantially when the learner is allowed to observe another person performing the same skill. In fact, human infants learn faster when they observe adults performing a task, even when the adult performs the task differently from the child, and even when the adult performs the task incorrectly (Meltzoff, 1999). Clearly, we can accelerate our own skill learning by observing a novel behavior, even when that behavior is performed by an agent with different physical capabilities or differences in morphology. Furthermore, evidence in neuroscience suggests that the parts of the brain in monkeys that respond to the pose of the hand can quickly adapt to instead respond to the pose of the end-effector of a tool held in the hand (Umilta et al., 2008). This suggests that the brain learns an invariant feature space for the task (e.g., reaching with a tool) that is independent of the morphology of the limb performing that task. Mirror neurons also fire both when the animal performs a task and when it observes another animal performing it (Rizzolatti & Craighero, 2004; Ferrari et al., 2005). Can we enable robots and other autonomous agents to transfer knowledge from other agents with different morphologies by learning such invariant representations?
+
+In robotics and reinforcement learning, prior works have considered building direct isomorphisms between state spaces, as discussed in Section 2. However, most of these methods require specific domain knowledge to determine how to form the mapping, or operate on simple, low-dimensional environments. For instance, Taylor et al. (2008) find a mapping between state spaces by searching through all possible pairings. Learning state-to-state isomorphisms involves an assumption that the two domains can be brought into correspondence, which may not be the case for morphologically different agents. Some aspects of the skill may not be transferable at all, in which case they must be learned from scratch, but we would like to maximize the information transferred between the agents.
+
+In this paper, we formulate this multi-agent transfer learning problem in a setting where two agents are learning multiple skills. Using the skills that have been already acquired by both agents, each agent can construct a mapping from their states into an invariant feature space. Each agent can then transfer a new skill from the other agent by projecting the executions of that skill into the invariant space, and tracking the corresponding features through its own actions. This provides a well-shaped reward function to the learner that allows it to imitate those aspects of the “teacher” agent that are invariant to differences in their morphology, while ignoring the parts of the state that cannot be imitated. Since the mapping from the state spaces of each agent into the invariant feature space might be complex and nonlinear, we use deep neural networks to represent the mappings, and we present an algorithm that can learn these mappings from the shared previously acquired skills.
+
+The main contributions of our work are a formulation of the multi-skill transfer problem, a definition of the common feature space, and an algorithm that can be used to learn the maximally informative feature space for transfer between two agents (e.g., two robots with different morphologies). To evaluate the efficiency of this transfer process, we use a reinforcement learning algorithm to transfer skills from one agent to another through the invariant feature space. The agents we consider may differ in state-space, action-space, and dynamics. We evaluate our transfer learning method in two simulated robotic manipulation tasks, and illustrate that we can transfer knowledge between simulated robotic arms with different numbers of links, as well as simulated arms with different actuation mechanisms, where one robot is torque-driven while the other is tendon-driven.
+
+# 2 RELATED WORK
+
+Transfer learning has long been recognized as an important direction in robotics and reinforcement learning (Taylor & Stone (2009)). Konidaris & Barto (2006) learned value functions on subsets of the state representation that were shared between tasks, providing a shaping reward in the target task. Taylor et al. (2007) manually construct a function to map a $Q$ -function from one Markov decision process (MDP) to another. Ammar & Taylor (2012) manually define a common feature space between the states of two MDPs, and use this feature space to learn a mapping between states.
+
+Later work by Ammar et al. (2015a) uses unsupervised manifold alignment to assign pairings between states for transfer. Like in our method, they aim to transfer skills between robots with different configurations and action spaces by guiding exploration in the target domain. The main difference from our work is that Ammar et al. (2015a) assume the presence of a feature mapping that provides distances between states, and use these (hand designed) features to assign correspondences between states in the different domains. In contrast, we assume that good correspondences in episodic tasks can be extracted through time alignment, and focus on learning the feature mapping itself. Additionally, we do not try to learn a direct mapping between state spaces but instead try to learn nonlinear embedding functions into a common feature space, as compared to linear mappings between state spaces learned in Ammar et al. (2015a). In a similar vein, Raimalwala et al. (2016) consider transfer learning across linear time-invariant (LTI) systems through simple alignment based methods. Although this method is quite effective in enabling transfer in these systems, it does not apply to the higher dimensional continuous control tasks we consider which may have non-linear dynamics, and may not be LTI.
+
+In machine learning, Pan & Yang (2010) provide an extensive survey on transfer learning which addresses the case of train and test data being drawn from different distributions, as well as learning models that succeed on multiple, related tasks. Ben-David & Schuller (2003) derive theoretical guarantees on this sort of multitask learning and provide a formal framework for defining task relatedness. In deep learning, Caruana (1997) show that a multitask network can leverage a shared representation of the input to learn multiple tasks more quickly together than separately.
+
+More recent work in deep learning has also looked at transferring policies by reusing policy parameters between environments (Rusu et al., 2016a;b; Braylan et al., 2015; Daftry et al., 2016), using either regularization or novel neural network architectures, though this work has not looked at transfer between agents with structural differences in state, such as different dimensionalities. Our approach is largely orthogonal to policy transfer methods, since our aim is not to directly transfer a skill policy, which is typically impossible in the presence of substantial morphological differences, but rather to learn a shared feature space that can be used to transfer information about a skill that is shared across robots, while ignoring those aspects that are not shared. Our own recent work has looked at morphological differences in the context of multi-agent and multi-task learning (Devin et al., 2016), by reusing neural network components across agent/task combinations. In contrast to that work, which transferred components of policies, our present work aims to learn common feature spaces in situations where we have just two agents. We do not aim to transfer parts of policies themselves, but instead look at shared structure in the states visited by optimal policies, which can be viewed as a kind of analogy making across domains.
+
+Learning feature spaces has also been studied in the domain of computer vision as a mechanism for domain adaptation and metric learning. Xing et al. (2002) finds a linear transformation of the input data to satisfy pairwise similarity contraints, while past work by Chopra et al. (2005) used Siamese networks to learn a feature space where paired images are brought close together and unpaired images are pushed apart. This enables a semantically meaningful metric space to be learned with only pairs as labels. Later work on domain adaptation by Tzeng et al. (2015) and Ganin et al. (2016) use an adversarial approach to learn an image embedding that is useful for classification and invariant to the input image’s domain. We use the idea of learning a metric space from paired states, though the adversarial approach could also be used with our method as an alternative objective function in future work.
+
+# 3 PROBLEM FORMULATION AND ASSUMPTIONS
+
+We formalize our transfer problem in a general way by considering a source domain and a target domain, denoted $D _ { S }$ and $D _ { T }$ , which each correspond to Markov decision processes (MDPs) $D _ { S } =$ $( \mathcal { S } _ { S } , \mathcal { A } _ { S } , T _ { S } , R _ { S } )$ and $D _ { T } = \left( \mathcal { S } _ { T } , \mathcal { A } _ { T } , T _ { T } , R _ { T } \right)$ , each with its own state space $\mathcal { S }$ , action space $\mathcal { A }$ , dynamics or transition function $T$ , and reward function $R$ . In general, the state and action spaces in the two domains might be completely different. Correspondingly, the dynamics $T _ { S }$ and $T _ { T }$ also differ, often dramatically. However, we assume that the reward functions share some structural similarity, in that the state distribution of an optimal policy in the source domain will resemble the state distribution of an optimal policy in the target domain when projected into some common feature space. For example, in one of our experimental tasks, $D _ { S }$ corresponds to a robotic arm with 3 links, while $D _ { T }$ is an arm with 4 links. While the dimensionalities of the states and action are completely different, the two arms are performing the same task, with a reward that depends on the position of the end-effector. Although this end-effector is a complex nonlinear function of the state, the reward is structurally similar for both agents.
+
+# 3.1 COMMON FEATURE SPACES
+
+We can formalize this common feature space assumption as following: if $\pi _ { S } ( s _ { S } )$ denotes the state distribution of the optimal policy in $D _ { S }$ , and $\pi _ { T } ( s _ { T } )$ denotes the state distribution of the optimal policy in $D _ { T }$ , it is possible to learn two functions, $f$ and $g$ , such that $p ( f ( s _ { S } ) ) = p ( g ( s _ { T } ) )$ for $s _ { S } \sim \pi _ { S }$ and $s _ { T } \sim \pi _ { T }$ . That is, the images of $\pi _ { S }$ under $f$ and $\pi _ { T }$ under $g$ correspond to the same distribution. This assumption is trivially true if we allow lossy mappings $f$ and $g$ (e.g. if $f ( s _ { S } ) = g ( s _ { T } ) = 0$ for all $s _ { S }$ and $s _ { T }$ ). However, the less information we lose in $f$ and $g$ , the more informative the shared feature will be for the purpose of transfer. So while we might not in general be able to fully recover $\pi _ { T }$ from the image of $\pi _ { S }$ under $f$ , we can attempt to learn $f$ and $g$ to maximize the amount of information contained in the shared space.
+
+# 3.2 LEARNING WITH MULTIPLE SKILLS
+
+In order to learn the common feature space, we need examples from both domains. While both agents could in principle learn a common feature space through direct exploration, in this work we instead assume that the agents have prior knowledge about each other, in the form of other skills that they have both learned. This assumption is reasonable, since many practical use-cases of transfer involve two agents that already have competence in a range of simple settings, and wish to transfer the competence of one agent in a new setting to another one. For example, we might wish to transfer a particular cooking skill from one home robot to another one, in a setting where both robots have already learned some basic manipulation behaviors that can allow us to build a common feature space between the two robots. Humans similarly leverage their extensive prior knowledge to aid in transfer, by recognizing limbs and hands and understanding their function.
+
+To formalize the setting where the two agents can perform multiple tasks, we divide the state space in each of the two domains into an agent-specific state $s _ { r }$ and a task-specific state $s _ { \mathrm { e n v } }$ . A similar partitioning of the state variables was previously discussed by Devin et al. (2016), and is closely related to the agent-space proposed by Konidaris (2006). For simplicity, we will consider a case where there are just two skills: one proxy skill that has been learned by both agents, and one test skill that has been learned by the source agent in the domain $D _ { S }$ and is currently being transferred to the target agent in domain $D _ { T }$ . We will use $D _ { S p }$ and $D _ { T p }$ to denote the proxy task domains for the source and target agents. We assume that $D _ { S }$ and $D _ { S p }$ (and similarly $D _ { T }$ and $D _ { T p }$ ) differ only in their reward functions and task-specific states, with the agent-specific state spaces $\mathcal { S } _ { r }$ and action spaces being the same between the proxy and test domains. For example $D _ { S p }$ might correspond to a 3-link robot pushing an object, while $D _ { S }$ might correspond to the same robot opening a drawer, and $D _ { T p }$ and $D _ { T }$ correspond to a completely different robot performing those tasks. Then, we can learn functions $f$ and $g$ on the robot-specific states of the proxy domains, and use them to transfer knowledge from $D _ { S }$ to $D _ { T }$ .
+
+The idea in this setup is that both agents will have already learned the proxy task, and we can compare how they perform this task in order to determine the common feature space. This is a natural problem setup for many robotic transfer learning problems, as well as other domains where multiple distinct agents might need to each learn a large collection of skills, exchanging their experience and learning which information they can and cannot transfer from each other. In a practical scenario, each robot might have already learned a large number of basic skills, some of which were learned by both robots. These skills are candidate proxy tasks that the robots can use to learn their shared space, which one robot can then use to transfer knowledge from the other one and more quickly learn skills that it does not yet possess.
+
+# 3.3 ESTIMATING CORRESPONDENCES FROM PROXY SKILL
+
+The proxy skill is useful for learning which pairs of agent-specific states correspond across both domains. We want to learn a pairing $P$ , which is a list of pairs of states in both domains which are corresponding. This is then used for the contrastive loss as described in Section 4. These correspondences could be obtained through an unsupervised alignment procedure but in our method we explore two simpler approaches exploiting the fact that the skills we consider are episodic.
+
+# 3.3.1 TIME-BASED ALIGNMENT
+
+The first extremely simple approach we consider is to say that in such episodic skills, a reasonable approximate alignment can be obtained by assuming that the two agents will perform each task at roughly the same rate, and we can therefore simply pair the states that are visited in the same time step in the two proxy domains.
+
+# 3.3.2 ALTERNATING OPTIMIZATION USING DYNAMIC TIME WARPING
+
+However, this alignment is sensitive to time based alignment and may not be very robust if the agents are performing the task at somewhat different rates. In order to address this, we formulate an alternating optimization procedure to be more robust than time-based alignment. This optimization alternates between learning a common feature space using currently estimated correspondences, and re-estimating correspondences using the currently learned feature space. We make use of Dynamic Time Warping (DTW) as described in Muller (2007), a well known method for learning correspon- ¨ dences across sequences which may vary in speed. Dynamic time warping requires a metric space to compare elements in the sequences to compute an optimal alignment between the sequences. In this method, we initialize the weak time-based alignment described in the previous paragraph and use it to learn a common feature space. This feature space serves as a metric space for DTW to re-estimate correspondences across domains. The new correspondences are then used as pairs for learning a better feature space, and so on. This forms an Expectation-Maximization style approach which can help estimate better correspondences than naive time-alignment.
+
+# 4 LEARNING COMMON FEATURE SPACES FOR SKILL TRANSFER
+
+In this section, we will discuss how the shared space can be learned by means of the proxy task. We will then describe how this shared space can be used for knowledge transfer for a new task, and finally present results that evaluate transfer on a set of simulated robotic control domains.
+
+We wish to find functions $f$ and $g$ such that, for states $s _ { S } p$ and $s _ { T } p$ along the optimal policies $\pi _ { S } p ^ { * }$ and $\pi _ { T } p ^ { * }$ , $f$ and $g$ approximately satisfy $p ( f ( s _ { S p , r } ) ) = p ( g ( s _ { T p , r } ) )$ . If we can find the common feature space by learning $f$ and $g$ , we can optimize $\pi _ { T }$ by directly mimicking the distribution over $f ( s _ { S p , r } )$ , where $s _ { S p , r } \sim \pi _ { S }$ .
+
+# 4.1 LEARNING THE EMBEDDING FUNCTIONS FROM A PROXY TASK
+
+To approximate the requirement that $p ( f ( s _ { S p , r } ) ) = p ( g ( s _ { T p , r } ) )$ , we assume a pairing $P$ of states in the proxy domains as described in 3.3. The pairing $P$ is a list of pairs of states $\left( s _ { S p } , s _ { T p } \right)$ which are corresponding across domains. As $f$ and $g$ are parametrized as neural networks, we can optimize them using the similarity loss metric introduced by Chopra et al. (2005):
+
+$$
+\mathcal { L } _ { \mathrm { { s i m } } } ( s _ { S p } , s _ { T p } ; \theta _ { f } , \theta _ { g } ) = | | f ( s _ { S p , r } ; \theta _ { f } ) - g ( s _ { T p , r } ; \theta _ { g } ) | | _ { 2 } .
+$$
+
+Where $\theta _ { f }$ and $\theta _ { g }$ are the function parameters, $( s _ { S p , r } , s _ { T p , r } ) \in P$
+
+However, as described in Section 3, if this is the only objective for learning $f$ and $g$ , we can easily end up with uninformative degenerate mappings, such as the one where $f ( s _ { S p , r } ) = g ( \bar { s _ { T p , r } } ) = 0$ . Intuitively, a good pair of mappings $f$ and $g$ would be as close as possible to being invertible, so as to preserve as much of the information about the source domain as possible. We therefore train a second pair of decoder networks with the goal of optimizing the quality of the reconstruction of $s _ { S p , r }$ and $s _ { T p , r }$ from the shared feature space, which encourages $f$ and $g$ to preserve the maximum amount of domaininvariant information. We define decoders $\operatorname { D e c } _ { S } ( f ( s _ { S p , r } ) )$ and $\mathrm { D e c } _ { T } \big ( g \big ( s _ { T p , r } \big ) \big )$ that map from the feature space back to their respective states. Note that, compared to conventional Siamese network methods, the weights between $f$ and $g$ are not tied, and in general the networks have different dimensional inputs. The objectives for these are:
+
+![](images/68e8999470c53a38fc73207865a5e205119a61753930b25a6e68be26ef937f80.jpg)  
+Figure $^ { l }$ : The two embedding functions $f$ and $g$ are trained with a contrastive loss between the domains, along with decoders that optimize autoencoder losses.
+
+$$
+\mathcal { L } _ { \mathrm { A E } _ { \mathrm { S } } } ( s _ { S p , r } ; \theta _ { f } , \theta _ { \mathrm { D e c } _ { S } } ) = | | s _ { S p , r } - \mathrm { D e c } _ { S } ( f ( s _ { S p , r } ; \theta _ { f } ) ; \theta _ { \mathrm { D e c } _ { S } } ) | | _ { 2 } ,
+$$
+
+$$
+\mathcal { L } _ { \mathrm { A E } _ { \mathrm { T } } } ( s _ { T p , r } ; \theta _ { g } , \theta _ { \mathrm { D e c } _ { T } } ) = | | s _ { T p , r } - \mathrm { D e c } _ { T } ( g ( s _ { T p , r } ; \theta _ { g } ) ; \theta _ { \mathrm { D e c } _ { T } } ) | | _ { 2 } ,
+$$
+
+where $\theta _ { \mathrm { D e c } _ { S } }$ and $\theta _ { \mathrm { D e c } _ { T } }$ are the decoder weights. We train the entire network end-to-end using backpropagation, where the full objective is
+
+$$
+\operatorname* { m i n } _ { \substack { \theta _ { f } , \theta _ { g } , \theta _ { \mathrm { D e c } _ { T } } } } \sum _ { ( s _ { S p } , s _ { T p } ) \in P } \mathcal { L } _ { \mathrm { A E } _ { S } } ( s _ { S p , r } ; \theta _ { f } , \theta _ { \mathrm { D e c } _ { S } } ) + \mathcal { L } _ { \mathrm { A E } _ { \mathrm { T } } } ( s _ { T p , r } ; \theta _ { g } , \theta _ { \mathrm { D e c } _ { T } } ) + \mathcal { L } _ { \mathrm { s i m } } ( s _ { S p , r } , s _ { T p , r } ; \theta _ { f } , \theta _ { g } )
+$$
+
+A diagram of this learning approach is shown in Figure 1.
+
+# 4.1.1 USING THE COMMON EMBEDDING FOR KNOWLEDGE TRANSFER
+
+The functions $f$ and $g$ learned using the approach described above establish an invariant space across the two domains. However, because these functions need not be invertible, directly mapping from a state in the source domain to a state in the target domain is not feasible.
+
+Instead of attempting direct policy transfer, we match the distributions of optimal trajectories across the domains. Given $f$ and $g$ learned from the network described in Section 4, and the distribution $\pi _ { S } ^ { * }$ of optimal trajectories in the source domain, we can incentivize the distribution of trajectories in the target domain to be similar to the source domains under the mappings $f$ and $g$ . Ideally, we would like the distributions $p ( f ( s _ { S , r } ) )$ and $p ( g ( s _ { T , r } ) )$ to match as closely as possible. However, it may still be necessary for the target agent to learn some aspects of the skill from scratch, since not all intricacies will transfer in the presence of morphological differences. We therefore use a reinforcement learning algorithm to learn $\pi _ { T }$ , but with an additional term added to the reward function that provides guidance via $f ( s _ { S , r } )$ . This term has following form:
+
+$$
+r _ { \mathrm { t r a n s f e r } } ( s _ { T , r } ^ { ( t ) } ) = \alpha \lvert | f ( s _ { S , r } ^ { ( t ) } ; \theta _ { f } ) - g ( s _ { T , r } ^ { ( t ) } ; \theta _ { g } ) \rvert | _ { 2 } ,
+$$
+
+where s(t)S,r is the agent-specific state along the optimal policy in the source domain at time step $t$ , and s(t)T,r is the agent-specific state along the current policy that is being learned in the target domain at time step $t$ , and $\alpha$ is a weight on the transfer reward that controls its importance relative to the overall task goal. In essence, this additional reward provides a form of reward shaping, which gives additional learning guidance in the target domain. In sparse reward environments, task performance is highly dependent on directed exploration, and this additional incentive to match trajectory distributions in the embedding space provides strong guidance for task performance.
+
+In tasks where the pairs mapping $\mathcal { P }$ is imperfect, the transfer reward may sometimes interfere with learning when the target domain policy is already very good, though it is usually very helpful in the early stages of learning. We therefore might consider gradually reducing the weight $\alpha$ as learning progresses in the target domain. We use this technique for our second experiment, which learns a policy for a tendon-driven arm.
+
+![](images/fcd30238b300e881b7bb4c9eb50031c4e3553ace0d7f7ccd1831730a5e7630c1.jpg)  
+Figure 2: The 3 and 4 link robots performing the button pressing task, which we use to evaluate the performance of our transfer method. Each task is trained on multiple conditions where the objects start in different locations.
+
+# 5 EXPERIMENTS
+
+Our experiments aim to evaluate how well common feature space learning can transfer skills between morphologically different agents. The experiments were performed in simulation using the MuJoCo physics simulator (Todorov et al., 2012), in order to explore a variety of different robots and actuation mechanisms. The embedding functions $f$ and $g$ in our experiments are 3 layer neural networks with 60 hidden units each and ReLu non-linearities. They are trained end-to-end with standard backpropagation using the ADAM optimizer (Kingma & Ba, 2015). Videos of our experiment will be available at https://sites.google.com/ site/invariantfeaturetransfer/ For details of the reinforcement learning algorithm used, refer to Appendix A.
+
+# 5.1 METHODS USED FOR COMPARISON
+
+In the following experiments, we compare our method with other methods. The simplest one, referred to as “no transfer”, aims to learn the target task from scratch. This method generally cannot succeed in sparse reward environments without a large number of episodes. Table 1 shows that, without transfer, the tasks are not learned even with 3-4 times more experience.
+
+We also compare to several linear methods, including random projections, canonical correlation analysis (CCA), and unsupervised manifold alignment (UMA). Random projections of data have been found to provide meaningful dimensionality reduction (Hegde et al., 2008). We assign $f$ and $g$ be random projections into spaces of the same dimension, and transfer as described in Section 4.1.1. CCA (Hotelling, 1936) aims to find a basis for the data in which the source data and target data are maximally correlated. We use the matrices that map from state space to the learned basis as $f$ and $g$ . UMA (Wang & Mahadevan (2009), Ammar et al. (2015b)) uses pairwise distances between states to align the manifolds of the two domains. These methods impose a linearity constraint on $f$ and $g$ which proves to limit the expressiveness of the embeddings. We find that using CCA to learn the embedding allows for transfer between robots, albeit without as much performance gained than if $f$ and $g$ are neural networks.
+
+We also compare to kernel-CCA (KCCA) which uses a kernel matrix to perform CCA, allowing the method to use an implied non-linear feature mapping of the data. We test on several different kernels, including polynomial (quad), radial basis (rbf), and linear. These methods perform especially well on transfer between different actuation methods, but which kernel to use for best performance is not consistent between experiments. For example, although the quadratic kernel performs competitively with our method for the tendon experiment, it does not work at all for our button pushing experiment.
+
+The last method we compare with is “direct mapping” which learns to directly predict $s _ { T , r }$ from $s _ { S , r }$ instead of mapping both into a common space. This is representative of a number of prior techniques that attempt to put source and target domains into direct correspondence such as Taylor et al. (2008). In this method, we use the same pairs as we do for our method, estimated from prior experience, but try to map directly from the source domain to the target domain. In order to guide learning using this method, we pass optimal source trajectories through the learned mapping, and then penalize the target robot for deviating from these predicted trajectories. As seen in Figures 5 and 8 this method does not succeed, probably because mapping from one state space to another is more difficult than mapping both state spaces into similar embeddings. The key difference between this method and ours is that we map both domains into a common space, which allows us to put only the common parts of the state spaces in correspondence instead of trying to map between entire states across domains.
+
+We have also included a comparison between using time-based alignment across domains versus using a more elaborate EM-style procedure as described in 3.3.2.
+
+# 5.2 TRANSFER BETWEEN ROBOTS WITH DIFFERENT NUMBERS OF LINKS
+
+![](images/e19b97d8d06e20b39fb09ef4495d0dce9f1f1521d5dbd8249580bed4768ca9f0.jpg)  
+Figure 3: The 4-link robot pushing the button. Note that the reward function only tells the agent how far the button has been depressed, and provides no information to indicate that the arm should reach for the button.
+
+![](images/4ee4b94688723b3e5668aba56e507c54c3cc8675794167b5da4d28907a1ae2ad.jpg)  
+Figure 4: The 3 and 4 link robots performing each of the three proxy tasks we consider: target reaching, peg insertion, and block moving. Our results indicate that using all three proxy tasks to learn the common feature space improves performance over any single proxy task.
+
+In our first experiment, we evaluate our method on transferring information from a 3-link robot to a 4-link robot. These robots have similar size but different numbers of links and actuators, making the representation needed for transfer non-trivial to learn. In order to evaluate the effectiveness of our method, we consider tasks with sparse or delayed rewards, which are difficult to learn quickly without the use of prior knowledge, large amounts of experience, or a detailed shaping function to guide exploration. For transfer between the 3 link and 4 link robots, we evaluate our method on a button pressing task as shown in Figures 2 and 3. The goal of this task is to reach through a narrow opening and press the white button to the red goal marker indicated in the figure. The caveat is that the reward signal tells the arms nothing about where the button is, but only penalizes distance between the white button and the red goal. Prior work has generally used well-shaped reward functions for tasks of this type, with terms that reward the arm for approaching the object of interest (Lillicrap et al., 2015; Devin et al., 2016). Without the presence of a directed reward shaping guiding the arm towards the button, it is very difficult for the task to be performed at all in the target domain, as seen from the performance of learning from scratch with no transfer (“baseline”) in the target domain in Figure 5. This is indicative of how such a task might be learned in the real world, where it is hard to provide anything but very sparse feedback by using a sensor on the button.
+
+For this experiment, we compare the quality of transfer when using different proxy tasks: reaching a target, moving a white block to the red goal, and inserting a peg into a slot near the robot, as shown in Figure 4. These tasks are significantly easier than the sparse reward button pressing task. Collecting successful trajectories from the proxy task, we train the functions $f$ and $g$ as described in
+
+Table 1: Maximum success rate of “no transfer” method over 75 iterations of training shown for the 3 tasks considered in Sections 5.2, 5.3, and 5.4. Because the target environments suffer from sparse rewards, this method is unable to learn the tasks with a tractable amount of data.   
+
+<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>Button (Section 5.2)</td><td rowspan=1 colspan=1>Block Pull (Section 5.3)</td><td rowspan=1 colspan=1>Block Push (Section 5.4)</td></tr><tr><td rowspan=1 colspan=1>Best in 75 iters</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>4.2%</td><td rowspan=1 colspan=1>7.1%</td></tr></table>
+
+Section 4. Note that the state in both robots is just the joint angles and joint velocities. Learning a suitable common feature space therefore requires the networks to understand how to map from joint angles to end-effectors for both robots.
+
+We consider the 3-link robot pressing the button as the source domain and the 4-link robot pressing the button as the target domain. We allow the domain with the 3-link robot to have a well shaped cost function which has 2 terms: one for bringing the arm close to the button, and one for the distance of the button from the red goal position. The performance of our method is shown in Figure 5. The agent trained with our method performs more directed exploration and achieves an almost perfect success rate in 7 iterations. The CCA method requires about 4 times more experience to reach $60 \%$ success than our method, indicating that using deep function approximators for the functions $f$ and $g$ which allows for a more expressive mapping than CCA. Even with kernel CCA, the task is not able to be performed as well as our method. Additionally the UMA and random projections baselines perform much worse than our method. We additionally find that using the EM style alignment procedure described in 3.3.2 also allows us to reach perfect formance as shown in Figure 5. Investigating this method further will be the subject of future work.
+
+Learning a direct mapping between states in both domains only provides limited transfer because this approach is forced to learn a mapping directly from one state space to the other, even though there is often no complete correspondence between two morphologically different robots. For example there may be some parts of the state which can be put in correspondence, but others which cannot. Our method of learning a common space between robots allows the embedding functions to only retain transferable information.
+
+![](images/35f4346cf2a000a00908964bf83ee6b32ef4b399aca560719a2c161ac78719b9.jpg)  
+Figure 5: Performance of 4-link arm on the sparse reward button pressing task described in Section 5.2. On the left and middle, we compare our method with the methods described in Section 5.1. On the right, the “peg,” “push,” and “reach” proxy ablations indicate the performance when using embedding functions learned from those proxy tasks. The embedding improves significantly when learned from all three proxy tasks, indicating that our method benefits from additional prior experience.
+
+# 5.3 TRANSFER BETWEEN TORQUE CONTROLLED AND TENDON CONTROLLED MANIPULATORS
+
+In order to illustrate the ability of our method to transfer across vastly different actuation mechanisms and learn representations that are hard to specify by hand, we consider transfer between a torque driven arm and a tendon driven arm, both with 3 links. These arms are pictured in Figure 6. The torque driven arm has motors at each of its joints that directly control its motion, and the state includes joint angles and joint velocities. The tendon driven arm, illustrated in Figure 6, uses three tendons to actuate the joints. The first tendon spans both the shoulder and the elbow, while the second and third control the elbow and wrist individually. The last tendon has a variable-length lever arm, while the first two have fixed-length lever arms, corresponding to tendons that conform to the arm as it bends. This coupled system uses tendon lengths and tendon velocities as the state representation, without direct access to joint angles or end-effector positions.
+
+The state representations of the two robots are dramatically different, both in terms of units, dimensionality, and semantics. Therefore, learning a suitable common feature space represents a considerable challenge. In our evaluation, the torque driven arm is the source robot, and the tendon driven arm is the target robot. The task we require both robots to perform is a block pulling task indicated in Figure 7. This involves pulling a block in the direction indicated, which is nontrivial because it requires moving the arm under and around the block, which is restricted to only move in the directions indicated in Figure 6. With random exploration, the target robot is unable to perform directed exploration to get the arm to actually pull the block in the desired direction, as shown in Figure 8.
+
+![](images/cca7e0dd7adde288ffb05b71cbdeaef6c25ff0c6d54a8bec5ec4d8b29cdb38b8.jpg)  
+Figure 6: The top images show the source and target domain robots: the robot on the left is torque driven at the joints and the one on the right is tendon driven. The tendons are highlighted in the image; the green tendon has a variable-length lever arm, while the yellow tendons have fixed-length lever arms. Note that the first tendon couples two joints. The bottom images show two variations of the test task.
+
+We use one proxy task in the experiment, which involves both arms reaching to various locations. With embedding functions $f$ and $g$ trained on optimal trajectories from the proxy task, we see that the transfer reward from our method enables the task to actually be performed with a tendon driven arm. The baseline of learning from scratch, which again corresponds to attempting to learn the task with the target tendon-driven arm from scratch, fails completely. The other methods of using CCA, and learning a direct mapping are able to achieve better performance than learning from scratch but learn slower. Kernel CCA with the quadratic kernel does competitively with our method but in turn performed very poorly on the button task so is not very consistent. Additionally, the random projection and UMA baselines perform quite poorly. The performance of the EM style alignment procedure is very similar to the standard time based alignment as seen in Figure 8, likely because the data is already quite time aligned across the domains. These results indicate that learning the common feature subspace can enable substantially accelerated learning in the target domain, and in fact can allow the target agent to learn a task that it fails to learn without any transfer rewards, and performs better than alternative methods.
+
+![](images/5335128dc06055cb07a9c0955bff0bbf88a37b54a594edb747e0dc9fc274433c.jpg)  
+Figure 7: The tendon-driven robot pulling the block. Note that the reward function only tells the agent how far the block is from the red goal and provides no information to indicate that the arm should reach around the block in order to pull it. The block is restricted to move only towards the red goal, but the agent needs to move under and around the block to pull it.
+
+# 5.4 TRANSFER THROUGH IMAGE FEATURES
+
+A compelling use-case for learned common embeddings is in learning vision-based policies. In this experimental setup, we evaluate our method on learning embeddings from raw pixels instead of from robot state. Enabling transfer from extra high dimensional inputs like images would allow significantly more natural transfer across a variety of robots without restrictive assumptions about full state information.
+
+We evaluate our method on transfer across a 3-link and a 4-link robot as in Section 5.2, but use images instead of state. Because images from the source and target domains are the same size and the same ”type”, we let $g = f$ . We parametrize $f$ as 3 convolutional layers with 5x5 filters and no pooling. A spatial softmax (Levine et al., 2016) is applied to the output of the third layer such that $f$ outputs normalized pixel indices of feature points on the image. These “feature points” form the latent representation that we compare across domains. Intuitively the common “feature points” embeddings should represent parts of the robots which are common across different robots.
+
+Embeddings between the domains are built using a proxy task of reaching to a point, similar to the one described in the previous experiments. The test task in this case is to push a white block to a red target as shown in Figure 9a, which suffers from sparse rewards because the reward only accounts for the distance of the block from the goal. Unless the robot knows that it has to touch the block, it receives no reward and has unguided exploration. As shown in Figure $^ \mathrm { 9 b }$ , our method is able to transfer meaningful information from source to target robot directly from raw images and successfully perform the task even in the presence of sparse rewards.
+
+![](images/127e491224236b3ae8e9e08416d210bb3f17a3b3df0cdb57aa2e8d3ebe609dd6.jpg)  
+Figure 8: Performance of tendon-controlled arm on block pulling task. While the environment’s reward is too sparse to succeed in a reasonable time without transfer, using our method to match feature space state distributions enables faster learning. Using a linear embedding or mapping directly from source states to target states allows for some transfer. Optimizing over $P$ instead of assuming time-based alignment does not hurt performance. KCCA with quadratic kernel performs very well in this experiment, but not in experiment $^ { l }$ .
+
+![](images/09f6e3ac04715fa7555e8526eea8f814c5cfc21ecb2637ffec87982754c53530.jpg)
+
+![](images/cfa59e2b456a88d3726010ea59af2f71135622f4a80fe037b8aa6ee529a94b96.jpg)  
+(a) The 3-link robot demonstrating the task. The yellow triangles mark the locations of the feature points output by $f$ applied to the image pixels. We then use the feature points to transfer the skill to the 4-link robot.
+
+(b) Performance of 4-link robot on block pushing task for transfer using raw images. We transfer from the 3-link robot by learning a feature space from raw pixels of both domains, enabling effective faster learning. Random projections and linear kernel-CCA have some success in transfer. The baseline is unable to succeed because of the reward signal is too sparse without transfer.
+
+# 6 DISCUSSION AND FUTURE WORK
+
+We presented a method for transferring skills between morphologically different agents using invariant feature spaces. The formulation of our transfer problem corresponds to a setting where two agents (e.g. two different robots) have each learned a collection of skills, with some skills known to just one of the agents, and some shared by both. A shared skill can be used to learn a space that implicitly brings the agents into correspondence, without assuming that an explicit state space isomorphism can be constructed. By then mapping into this space a skill that is known to only one of the agents, the other agent can substantially accelerate its learning of this skill by transferring the shared structure. We present an algorithm for learning the shared feature spaces using a shared proxy task, and experimentally illustrate that we can use this method to transfer manipulation skills between different simulated robotic arms. Our experiments include transfer between arms with different numbers of links, as well as transfer from a torque-driven arm to a tendon-driven arm.
+
+A promising direction for future work is to explicitly handle situations where the two (or more) agents must transfer new skills by using a large collection of prior behaviors, with different degrees of similarity between the agents. In this case, constructing a shared feature space involves not only mapping the skills into a single space, but deciding which skills should or should not be combined. For example, a wheeled robot might share manipulation strategies with a legged robot, but should not attempt to share locomotion behaviors.
+
+In a large-scale lifelong learning domain with many agent and many skills, we could also consider using our approach to gradually construct more and more detailed common feature spaces by transferring a skill from one agent to another, using that new skill to build a better common feature space, and then using this improved feature space to transfer more skills. Automatically choosing which skills to transfer when in order to minimize the training time of an entire skill repertoire is an interesting and exciting direction for future work.
+
+# REFERENCES
+
+Haitham Bou Ammar and Matthew E. Taylor. Reinforcement learning transfer via common subspaces. In Adaptive and Learning Agents: International Workshop, 2012.
+
+Haitham Bou Ammar, Eric Eaton, Paul Ruvolo, and Matthew Taylor. Unsupervised cross-domain transfer in policy gradient reinforcement learning via manifold alignment. In AAAI Conference on Artificial Intelligence, 2015a.
+
+Haitham Bou Ammar, Eric Eaton, Paul Ruvolo, and Matthew E Taylor. Unsupervised cross-domain transfer in policy gradient reinforcement learning via manifold alignment. In Proc. of AAAI, 2015b.
+
+Shai Ben-David and Reba Schuller. Exploiting task relatedness for multiple task learning. In Learning Theory and Kernel Machines, pp. 567–580. Springer, 2003.
+
+Alexander Braylan, Mark Hollenbeck, Elliot Meyerson, and Risto Miikkulainen. Reuse of neural modules for general video game playing. CoRR, abs/1512.01537, 2015.
+
+Rich Caruana. Multitask learning. Machine Learning, 1997.
+
+Sumit Chopra, Raia Hadsell, and Yann LeCun. Learning a similarity metric discriminatively, with application to face verification. In Computer Vision and Pattern Recognition, 2005. CVPR 2005. IEEE Computer Society Conference on, volume 1, pp. 539–546. IEEE, 2005.
+
+Shreyansh Daftry, J. Andrew Bagnell, and Martial Hebert. Learning transferable policies for monocular reactive MAV control. In International Symposium on Experimental Robotics (ISER), 2016.
+
+Coline Devin, Abhishek Gupta, Trevor Darrell, Pieter Abbeel, and Sergey Levine. Learning modular neural network policies for multi-task and multi-robot transfer. arXiv preprint arXiv:1609.07088, 2016.
+
+P. F. Ferrari, S. Rozzi, and L. Fogassi. Mirror neurons responding to observation of actions made with tools in monkey ventral premotor cortex. Journal of Cognitive Neuroscience, 17(2), 2005.
+
+Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, Francois Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. Journal of Machine Learning Research, 17, 2016.
+
+Chinmay Hegde, Michael Wakin, and Richard Baraniuk. Random projections for manifold learning. In Advances in neural information processing systems, pp. 641–648, 2008.
+
+Harold Hotelling. Relations between two sets of variates. Biometrika, 28, 1936.
+
+D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015.
+
+George Konidaris. A framework for transfer in reinforcement learning. In ICML-06 Workshop on Structural Knowledge Transfer for Machine Learning, 2006.
+
+George Konidaris and Andrew Barto. Autonomous shaping: knowledge transfer in reinforcement learning. In International Conference on Machine Learning (ICML), pp. 489–496, 2006.
+
+Sergey Levine and Pieter Abbeel. Learning neural network policies with guided policy search under unknown dynamics. In Advances in Neural Information Processing Systems, 2014.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17:1–40, 2016.
+
+Weiwei Li and Emanuel Todorov. Iterative linear quadratic regulator design for nonlinear biological movement systems. In ICINCO (1), 2004.
+
+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. CoRR, abs/1509.02971, 2015.
+
+Andrew Meltzoff. Born to learn: What infants learn from watching us. Skillman, NJ: Pediatric Institute Publication, 1999.
+
+Meinard Muller. Dynamic time warping. ¨ Information retrieval for music and motion, pp. 69–84, 2007.
+
+Sinno Jialin Pan and Qiang Yang. A survey on transfer learning. IEEE Transactions on knowledge and data engineering, 22(10):1345–1359, 2010.
+
+Kaizad V Raimalwala, Bruce A Francis, and Angela P Schoellig. A preliminary study of transfer learning between unicycle robots. In 2016 AAAI Spring Symposium Series, 2016.
+
+Giacomo Rizzolatti and Laila Craighero. The mirror neuron system. Annual Review of Neuroscience, 27:169–192, 2004.
+
+Andrei A. Rusu, Neil C. Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. CoRR, abs/1606.04671, 2016a.
+
+Andrei A Rusu, Matej Vecerik, Thomas Rothorl, Nicolas Heess, Razvan Pascanu, and Raia Hadsell. ¨ Sim-to-real robot learning from pixels with progressive nets. arXiv preprint arXiv:1610.04286, 2016b.
+
+Matthew Taylor, Peter Stone, and Yaxin Liu. Transfer learning via inter-task mappings for temporal difference learning. Journal of Machine Learning Research, 8(1):2125–2167, 2007.
+
+Matthew E. Taylor and Peter Stone. Transfer learning for reinforcement learning domains: A survey. Journal of Machine Learning Research, 10:1633–1685, 2009.
+
+Matthew E. Taylor, Nicholas K. Jong, and Peter Stone. Transferring instances for model-based reinforcement learning. In Proceedings of the European Conference on Machine Learning and Principles and Practice of Knowledge Discovery in Databases (ECML PKDD), 2008.
+
+E. Todorov, T. Erez, and Y. Tassa. MuJoCo: A physics engine for model-based control. In International Conference on Intelligent Robots and Systems (IROS), 2012.
+
+Eric Tzeng, Judy Hoffman, Trevor Darrell, and Kate Saenko. Simultaneous deep transfer across domains and tasks. In International Conference in Computer Vision (ICCV), 2015.
+
+M. A. Umilta, L. Escola, I. Intskirveli, F. Grammont, M. Rochat, F. Caruana, A. Jezzini, V. Gallese, and G. Rizzolatti. When pliers become fingers in the monkey motor system. Proceedings of the National Academy of Sciences, 105(6):2209–2213, 2008.
+
+Chang Wang and Sridhar Mahadevan. Manifold alignment without correspondence. In IJCAI, volume 2, pp. 3, 2009.
+
+Eric P. Xing, Andrew Y. Ng, Michael I. Jordan, and Stuart Russell. Distance metric learning, with application to clustering with side-information. In Proceedings of the 15th International Conference on Neural Information Processing Systems, NIPS’02, pp. 521–528, Cambridge, MA, USA, 2002. MIT Press. URL http://dl.acm.org/citation.cfm?id $=$ 2968618.2968683.
+
+# 7 APPENDIX
+
+# 7.1 REINFORCEMENT LEARNING WITH LOCAL MODELS
+
+Although we can use any suitable reinforcement learning algorithm for learning policies, in this work, we use a simple trajectory-centric reinforcement learning method that trains time-varying linear-Gaussian policies (Levine & Abbeel, 2014). While this method produces simple policies, it is very efficient, making it well suited for robotic learning. To obtain robot trajectories for training tasks and source robots, we optimize time-varying linear-Gaussian policies through a trajectorycentric reinforcement learning algorithm that alternates between fitting local time-varying linear dynamics models, and updating the time-varying linear-Gaussian policies using the iterative linearquadratic Gaussian regulator algorithm (iLQG) (Li & Todorov, 2004). This approach is simple and efficient, and is typically able to learn complex high-dimensional skills using just tens of trials, making it well suited for rapid transfer. The resulting time-varying linear-Gaussian policies are parametrized as $p ( u _ { t } | x _ { t } ) = \mathcal { \bar { N } } ( K _ { t } x _ { t } + k _ { t } , C _ { t } )$ where $K _ { t }$ , $k _ { t }$ , and $C _ { t }$ are learned parameters. Further details of this method are presented in prior work (Levine & Abbeel, 2014).
+
+We use the same reinforcement learning algorithm to provide solutions in the source domain $D _ { S }$ , though again any suitable reinforcement learning method (or even human demonstrations) could be used instead. To evaluate the ability of our method to provide detailed guidance through the transfer reward $r _ { \mathrm { t r a n s f e r } }$ , we use relatively sparse reward functions in the target domain $D _ { T }$ , as discussed below. To generate the original skills in the source domain $D _ { S }$ and in the proxy domains $D _ { S p }$ and $D _ { T p }$ , we manually designed the appropriate shaped costs to enable learning from scratch to succeed, though we note again that our method is agnostic to how the source domain and proxy domain skills are acquired.

parse/train/Hyq4yhile/Hyq4yhile_content_list.json

@@ -0,0 +1,1573 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING INVARIANT FEATURE SPACES TO TRANSFER SKILLS WITH REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Gupta†∗, Coline Devin†∗, YuXuan Liu†, Pieter Abbeel†‡, Sergey Levine† † UC Berkeley, Department of Electrical Engineering and Computer Science ‡ OpenAI {abhigupta,coline,svlevine}@eecs.berkeley.edu {yuxuanliu}@berkeley.edu {pieter}@openai.com ",
+        "bbox": [
+            230,
+            174,
+            766,
+            190
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            248,
+            202,
+            750,
+            272
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            315,
+            544,
+            330
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "People can learn a wide range of tasks from their own experience, but can also learn from observing other creatures. This can accelerate acquisition of new skills even when the observed agent differs substantially from the learning agent in terms of morphology. In this paper, we examine how reinforcement learning algorithms can transfer knowledge between morphologically different agents (e.g., different robots). We introduce a problem formulation where two agents are tasked with learning multiple skills by sharing information. Our method uses the skills that were learned by both agents to train invariant feature spaces that can then be used to transfer other skills from one agent to another. The process of learning these invariant feature spaces can be viewed as a kind of “analogy making,” or implicit learning of partial correspondences between two distinct domains. We evaluate our transfer learning algorithm in two simulated robotic manipulation skills, and illustrate that we can transfer knowledge between simulated robotic arms with different numbers of links, as well as simulated arms with different actuation mechanisms, where one robot is torque-driven while the other is tendon-driven. ",
+        "bbox": [
+            233,
+            347,
+            764,
+            554
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            583,
+            336,
+            598
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "People can learn large repertoires of motor skills autonomously from their own experience. However, learning is accelerated substantially when the learner is allowed to observe another person performing the same skill. In fact, human infants learn faster when they observe adults performing a task, even when the adult performs the task differently from the child, and even when the adult performs the task incorrectly (Meltzoff, 1999). Clearly, we can accelerate our own skill learning by observing a novel behavior, even when that behavior is performed by an agent with different physical capabilities or differences in morphology. Furthermore, evidence in neuroscience suggests that the parts of the brain in monkeys that respond to the pose of the hand can quickly adapt to instead respond to the pose of the end-effector of a tool held in the hand (Umilta et al., 2008). This suggests that the brain learns an invariant feature space for the task (e.g., reaching with a tool) that is independent of the morphology of the limb performing that task. Mirror neurons also fire both when the animal performs a task and when it observes another animal performing it (Rizzolatti & Craighero, 2004; Ferrari et al., 2005). Can we enable robots and other autonomous agents to transfer knowledge from other agents with different morphologies by learning such invariant representations? ",
+        "bbox": [
+            174,
+            614,
+            825,
+            809
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In robotics and reinforcement learning, prior works have considered building direct isomorphisms between state spaces, as discussed in Section 2. However, most of these methods require specific domain knowledge to determine how to form the mapping, or operate on simple, low-dimensional environments. For instance, Taylor et al. (2008) find a mapping between state spaces by searching through all possible pairings. Learning state-to-state isomorphisms involves an assumption that the two domains can be brought into correspondence, which may not be the case for morphologically different agents. Some aspects of the skill may not be transferable at all, in which case they must be learned from scratch, but we would like to maximize the information transferred between the agents. ",
+        "bbox": [
+            174,
+            816,
+            823,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we formulate this multi-agent transfer learning problem in a setting where two agents are learning multiple skills. Using the skills that have been already acquired by both agents, each agent can construct a mapping from their states into an invariant feature space. Each agent can then transfer a new skill from the other agent by projecting the executions of that skill into the invariant space, and tracking the corresponding features through its own actions. This provides a well-shaped reward function to the learner that allows it to imitate those aspects of the “teacher” agent that are invariant to differences in their morphology, while ignoring the parts of the state that cannot be imitated. Since the mapping from the state spaces of each agent into the invariant feature space might be complex and nonlinear, we use deep neural networks to represent the mappings, and we present an algorithm that can learn these mappings from the shared previously acquired skills. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main contributions of our work are a formulation of the multi-skill transfer problem, a definition of the common feature space, and an algorithm that can be used to learn the maximally informative feature space for transfer between two agents (e.g., two robots with different morphologies). To evaluate the efficiency of this transfer process, we use a reinforcement learning algorithm to transfer skills from one agent to another through the invariant feature space. The agents we consider may differ in state-space, action-space, and dynamics. We evaluate our transfer learning method in two simulated robotic manipulation tasks, and illustrate that we can transfer knowledge between simulated robotic arms with different numbers of links, as well as simulated arms with different actuation mechanisms, where one robot is torque-driven while the other is tendon-driven. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            410
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            436,
+            344,
+            452
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Transfer learning has long been recognized as an important direction in robotics and reinforcement learning (Taylor & Stone (2009)). Konidaris & Barto (2006) learned value functions on subsets of the state representation that were shared between tasks, providing a shaping reward in the target task. Taylor et al. (2007) manually construct a function to map a $Q$ -function from one Markov decision process (MDP) to another. Ammar & Taylor (2012) manually define a common feature space between the states of two MDPs, and use this feature space to learn a mapping between states. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            555
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Later work by Ammar et al. (2015a) uses unsupervised manifold alignment to assign pairings between states for transfer. Like in our method, they aim to transfer skills between robots with different configurations and action spaces by guiding exploration in the target domain. The main difference from our work is that Ammar et al. (2015a) assume the presence of a feature mapping that provides distances between states, and use these (hand designed) features to assign correspondences between states in the different domains. In contrast, we assume that good correspondences in episodic tasks can be extracted through time alignment, and focus on learning the feature mapping itself. Additionally, we do not try to learn a direct mapping between state spaces but instead try to learn nonlinear embedding functions into a common feature space, as compared to linear mappings between state spaces learned in Ammar et al. (2015a). In a similar vein, Raimalwala et al. (2016) consider transfer learning across linear time-invariant (LTI) systems through simple alignment based methods. Although this method is quite effective in enabling transfer in these systems, it does not apply to the higher dimensional continuous control tasks we consider which may have non-linear dynamics, and may not be LTI. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            756
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In machine learning, Pan & Yang (2010) provide an extensive survey on transfer learning which addresses the case of train and test data being drawn from different distributions, as well as learning models that succeed on multiple, related tasks. Ben-David & Schuller (2003) derive theoretical guarantees on this sort of multitask learning and provide a formal framework for defining task relatedness. In deep learning, Caruana (1997) show that a multitask network can leverage a shared representation of the input to learn multiple tasks more quickly together than separately. ",
+        "bbox": [
+            174,
+            762,
+            823,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "More recent work in deep learning has also looked at transferring policies by reusing policy parameters between environments (Rusu et al., 2016a;b; Braylan et al., 2015; Daftry et al., 2016), using either regularization or novel neural network architectures, though this work has not looked at transfer between agents with structural differences in state, such as different dimensionalities. Our approach is largely orthogonal to policy transfer methods, since our aim is not to directly transfer a skill policy, which is typically impossible in the presence of substantial morphological differences, but rather to learn a shared feature space that can be used to transfer information about a skill that is shared across robots, while ignoring those aspects that are not shared. Our own recent work has looked at morphological differences in the context of multi-agent and multi-task learning (Devin et al., 2016), by reusing neural network components across agent/task combinations. In contrast to that work, which transferred components of policies, our present work aims to learn common feature spaces in situations where we have just two agents. We do not aim to transfer parts of policies themselves, but instead look at shared structure in the states visited by optimal policies, which can be viewed as a kind of analogy making across domains. ",
+        "bbox": [
+            176,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Learning feature spaces has also been studied in the domain of computer vision as a mechanism for domain adaptation and metric learning. Xing et al. (2002) finds a linear transformation of the input data to satisfy pairwise similarity contraints, while past work by Chopra et al. (2005) used Siamese networks to learn a feature space where paired images are brought close together and unpaired images are pushed apart. This enables a semantically meaningful metric space to be learned with only pairs as labels. Later work on domain adaptation by Tzeng et al. (2015) and Ganin et al. (2016) use an adversarial approach to learn an image embedding that is useful for classification and invariant to the input image’s domain. We use the idea of learning a metric space from paired states, though the adversarial approach could also be used with our method as an alternative objective function in future work. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            375
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PROBLEM FORMULATION AND ASSUMPTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            397,
+            586,
+            412
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We formalize our transfer problem in a general way by considering a source domain and a target domain, denoted $D _ { S }$ and $D _ { T }$ , which each correspond to Markov decision processes (MDPs) $D _ { S } =$ $( \\mathcal { S } _ { S } , \\mathcal { A } _ { S } , T _ { S } , R _ { S } )$ and $D _ { T } = \\left( \\mathcal { S } _ { T } , \\mathcal { A } _ { T } , T _ { T } , R _ { T } \\right)$ , each with its own state space $\\mathcal { S }$ , action space $\\mathcal { A }$ , dynamics or transition function $T$ , and reward function $R$ . In general, the state and action spaces in the two domains might be completely different. Correspondingly, the dynamics $T _ { S }$ and $T _ { T }$ also differ, often dramatically. However, we assume that the reward functions share some structural similarity, in that the state distribution of an optimal policy in the source domain will resemble the state distribution of an optimal policy in the target domain when projected into some common feature space. For example, in one of our experimental tasks, $D _ { S }$ corresponds to a robotic arm with 3 links, while $D _ { T }$ is an arm with 4 links. While the dimensionalities of the states and action are completely different, the two arms are performing the same task, with a reward that depends on the position of the end-effector. Although this end-effector is a complex nonlinear function of the state, the reward is structurally similar for both agents. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            609
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 COMMON FEATURE SPACES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            628,
+            406,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We can formalize this common feature space assumption as following: if $\\pi _ { S } ( s _ { S } )$ denotes the state distribution of the optimal policy in $D _ { S }$ , and $\\pi _ { T } ( s _ { T } )$ denotes the state distribution of the optimal policy in $D _ { T }$ , it is possible to learn two functions, $f$ and $g$ , such that $p ( f ( s _ { S } ) ) = p ( g ( s _ { T } ) )$ for $s _ { S } \\sim \\pi _ { S }$ and $s _ { T } \\sim \\pi _ { T }$ . That is, the images of $\\pi _ { S }$ under $f$ and $\\pi _ { T }$ under $g$ correspond to the same distribution. This assumption is trivially true if we allow lossy mappings $f$ and $g$ (e.g. if $f ( s _ { S } ) = g ( s _ { T } ) = 0$ for all $s _ { S }$ and $s _ { T }$ ). However, the less information we lose in $f$ and $g$ , the more informative the shared feature will be for the purpose of transfer. So while we might not in general be able to fully recover $\\pi _ { T }$ from the image of $\\pi _ { S }$ under $f$ , we can attempt to learn $f$ and $g$ to maximize the amount of information contained in the shared space. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            781
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 LEARNING WITH MULTIPLE SKILLS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            799,
+            462,
+            814
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order to learn the common feature space, we need examples from both domains. While both agents could in principle learn a common feature space through direct exploration, in this work we instead assume that the agents have prior knowledge about each other, in the form of other skills that they have both learned. This assumption is reasonable, since many practical use-cases of transfer involve two agents that already have competence in a range of simple settings, and wish to transfer the competence of one agent in a new setting to another one. For example, we might wish to transfer a particular cooking skill from one home robot to another one, in a setting where both robots have already learned some basic manipulation behaviors that can allow us to build a common feature space between the two robots. Humans similarly leverage their extensive prior knowledge to aid in transfer, by recognizing limbs and hands and understanding their function. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To formalize the setting where the two agents can perform multiple tasks, we divide the state space in each of the two domains into an agent-specific state $s _ { r }$ and a task-specific state $s _ { \\mathrm { e n v } }$ . A similar partitioning of the state variables was previously discussed by Devin et al. (2016), and is closely related to the agent-space proposed by Konidaris (2006). For simplicity, we will consider a case where there are just two skills: one proxy skill that has been learned by both agents, and one test skill that has been learned by the source agent in the domain $D _ { S }$ and is currently being transferred to the target agent in domain $D _ { T }$ . We will use $D _ { S p }$ and $D _ { T p }$ to denote the proxy task domains for the source and target agents. We assume that $D _ { S }$ and $D _ { S p }$ (and similarly $D _ { T }$ and $D _ { T p }$ ) differ only in their reward functions and task-specific states, with the agent-specific state spaces $\\mathcal { S } _ { r }$ and action spaces being the same between the proxy and test domains. For example $D _ { S p }$ might correspond to a 3-link robot pushing an object, while $D _ { S }$ might correspond to the same robot opening a drawer, and $D _ { T p }$ and $D _ { T }$ correspond to a completely different robot performing those tasks. Then, we can learn functions $f$ and $g$ on the robot-specific states of the proxy domains, and use them to transfer knowledge from $D _ { S }$ to $D _ { T }$ . ",
+        "bbox": [
+            174,
+            154,
+            825,
+            347
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The idea in this setup is that both agents will have already learned the proxy task, and we can compare how they perform this task in order to determine the common feature space. This is a natural problem setup for many robotic transfer learning problems, as well as other domains where multiple distinct agents might need to each learn a large collection of skills, exchanging their experience and learning which information they can and cannot transfer from each other. In a practical scenario, each robot might have already learned a large number of basic skills, some of which were learned by both robots. These skills are candidate proxy tasks that the robots can use to learn their shared space, which one robot can then use to transfer knowledge from the other one and more quickly learn skills that it does not yet possess. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 ESTIMATING CORRESPONDENCES FROM PROXY SKILL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            500,
+            591,
+            513
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The proxy skill is useful for learning which pairs of agent-specific states correspond across both domains. We want to learn a pairing $P$ , which is a list of pairs of states in both domains which are corresponding. This is then used for the contrastive loss as described in Section 4. These correspondences could be obtained through an unsupervised alignment procedure but in our method we explore two simpler approaches exploiting the fact that the skills we consider are episodic. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            597
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3.1 TIME-BASED ALIGNMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            616,
+            408,
+            631
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The first extremely simple approach we consider is to say that in such episodic skills, a reasonable approximate alignment can be obtained by assuming that the two agents will perform each task at roughly the same rate, and we can therefore simply pair the states that are visited in the same time step in the two proxy domains. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            698
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3.2 ALTERNATING OPTIMIZATION USING DYNAMIC TIME WARPING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            717,
+            669,
+            732
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, this alignment is sensitive to time based alignment and may not be very robust if the agents are performing the task at somewhat different rates. In order to address this, we formulate an alternating optimization procedure to be more robust than time-based alignment. This optimization alternates between learning a common feature space using currently estimated correspondences, and re-estimating correspondences using the currently learned feature space. We make use of Dynamic Time Warping (DTW) as described in Muller (2007), a well known method for learning correspon- ¨ dences across sequences which may vary in speed. Dynamic time warping requires a metric space to compare elements in the sequences to compute an optimal alignment between the sequences. In this method, we initialize the weak time-based alignment described in the previous paragraph and use it to learn a common feature space. This feature space serves as a metric space for DTW to re-estimate correspondences across domains. The new correspondences are then used as pairs for learning a better feature space, and so on. This forms an Expectation-Maximization style approach which can help estimate better correspondences than naive time-alignment. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 LEARNING COMMON FEATURE SPACES FOR SKILL TRANSFER ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            720,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will discuss how the shared space can be learned by means of the proxy task. We will then describe how this shared space can be used for knowledge transfer for a new task, and finally present results that evaluate transfer on a set of simulated robotic control domains. ",
+        "bbox": [
+            174,
+            133,
+            823,
+            176
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We wish to find functions $f$ and $g$ such that, for states $s _ { S } p$ and $s _ { T } p$ along the optimal policies $\\pi _ { S } p ^ { * }$ and $\\pi _ { T } p ^ { * }$ , $f$ and $g$ approximately satisfy $p ( f ( s _ { S p , r } ) ) = p ( g ( s _ { T p , r } ) )$ . If we can find the common feature space by learning $f$ and $g$ , we can optimize $\\pi _ { T }$ by directly mimicking the distribution over $f ( s _ { S p , r } )$ , where $s _ { S p , r } \\sim \\pi _ { S }$ . ",
+        "bbox": [
+            174,
+            183,
+            825,
+            239
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 LEARNING THE EMBEDDING FUNCTIONS FROM A PROXY TASK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            256,
+            645,
+            270
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To approximate the requirement that $p ( f ( s _ { S p , r } ) ) = p ( g ( s _ { T p , r } ) )$ , we assume a pairing $P$ of states in the proxy domains as described in 3.3. The pairing $P$ is a list of pairs of states $\\left( s _ { S p } , s _ { T p } \\right)$ which are corresponding across domains. As $f$ and $g$ are parametrized as neural networks, we can optimize them using the similarity loss metric introduced by Chopra et al. (2005): ",
+        "bbox": [
+            174,
+            281,
+            825,
+            338
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2406a1ea0b0ec2dafc5c4e0ddcb30eab319abe63409570fb8c3aeb40fada575f.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { { s i m } } } ( s _ { S p } , s _ { T p } ; \\theta _ { f } , \\theta _ { g } ) = | | f ( s _ { S p , r } ; \\theta _ { f } ) - g ( s _ { T p , r } ; \\theta _ { g } ) | | _ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            344,
+            674,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Where $\\theta _ { f }$ and $\\theta _ { g }$ are the function parameters, $( s _ { S p , r } , s _ { T p , r } ) \\in P$ ",
+        "bbox": [
+            174,
+            369,
+            586,
+            385
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, as described in Section 3, if this is the only objective for learning $f$ and $g$ , we can easily end up with uninformative degenerate mappings, such as the one where $f ( s _ { S p , r } ) = g ( \\bar { s _ { T p , r } } ) = 0$ . Intuitively, a good pair of mappings $f$ and $g$ would be as close as possible to being invertible, so as to preserve as much of the information about the source domain as possible. We therefore train a second pair of decoder networks with the goal of optimizing the quality of the reconstruction of $s _ { S p , r }$ and $s _ { T p , r }$ from the shared feature space, which encourages $f$ and $g$ to preserve the maximum amount of domaininvariant information. We define decoders $\\operatorname { D e c } _ { S } ( f ( s _ { S p , r } ) )$ and $\\mathrm { D e c } _ { T } \\big ( g \\big ( s _ { T p , r } \\big ) \\big )$ that map from the feature space back to their respective states. Note that, compared to conventional Siamese network methods, the weights between $f$ and $g$ are not tied, and in general the networks have different dimensional inputs. The objectives for these are: ",
+        "bbox": [
+            174,
+            390,
+            549,
+            584
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/68e8999470c53a38fc73207865a5e205119a61753930b25a6e68be26ef937f80.jpg",
+        "image_caption": [
+            "Figure $^ { l }$ : The two embedding functions $f$ and $g$ are trained with a contrastive loss between the domains, along with decoders that optimize autoencoder losses. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            593,
+            369,
+            789,
+            507
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            585,
+            823,
+            613
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9003974eac9ff527ebc631bbe2c5fa5dc7d063acd62d210ce56577f6f74e2dd7.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { A E } _ { \\mathrm { S } } } ( s _ { S p , r } ; \\theta _ { f } , \\theta _ { \\mathrm { D e c } _ { S } } ) = | | s _ { S p , r } - \\mathrm { D e c } _ { S } ( f ( s _ { S p , r } ; \\theta _ { f } ) ; \\theta _ { \\mathrm { D e c } _ { S } } ) | | _ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            619,
+            699,
+            637
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/03fa75f8bedab7f5fd0f1ea0d2ac919c483803cd1c2f2a38729fb622fb3fb63a.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { A E } _ { \\mathrm { T } } } ( s _ { T p , r } ; \\theta _ { g } , \\theta _ { \\mathrm { D e c } _ { T } } ) = | | s _ { T p , r } - \\mathrm { D e c } _ { T } ( g ( s _ { T p , r } ; \\theta _ { g } ) ; \\theta _ { \\mathrm { D e c } _ { T } } ) | | _ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            642,
+            700,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\theta _ { \\mathrm { D e c } _ { S } }$ and $\\theta _ { \\mathrm { D e c } _ { T } }$ are the decoder weights. We train the entire network end-to-end using backpropagation, where the full objective is ",
+        "bbox": [
+            176,
+            662,
+            820,
+            690
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3b4503177f26fa3a6f79252df6f90fec694fda14bbec769f114dce54a5afe2bb.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\substack { \\theta _ { f } , \\theta _ { g } , \\theta _ { \\mathrm { D e c } _ { T } } } } \\sum _ { ( s _ { S p } , s _ { T p } ) \\in P } \\mathcal { L } _ { \\mathrm { A E } _ { S } } ( s _ { S p , r } ; \\theta _ { f } , \\theta _ { \\mathrm { D e c } _ { S } } ) + \\mathcal { L } _ { \\mathrm { A E } _ { \\mathrm { T } } } ( s _ { T p , r } ; \\theta _ { g } , \\theta _ { \\mathrm { D e c } _ { T } } ) + \\mathcal { L } _ { \\mathrm { s i m } } ( s _ { S p , r } , s _ { T p , r } ; \\theta _ { f } , \\theta _ { g } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            178,
+            696,
+            816,
+            729
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A diagram of this learning approach is shown in Figure 1. ",
+        "bbox": [
+            174,
+            736,
+            552,
+            752
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 USING THE COMMON EMBEDDING FOR KNOWLEDGE TRANSFER",
+        "text_level": 1,
+        "bbox": [
+            173,
+            766,
+            678,
+            781
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The functions $f$ and $g$ learned using the approach described above establish an invariant space across the two domains. However, because these functions need not be invertible, directly mapping from a state in the source domain to a state in the target domain is not feasible. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Instead of attempting direct policy transfer, we match the distributions of optimal trajectories across the domains. Given $f$ and $g$ learned from the network described in Section 4, and the distribution $\\pi _ { S } ^ { * }$ of optimal trajectories in the source domain, we can incentivize the distribution of trajectories in the target domain to be similar to the source domains under the mappings $f$ and $g$ . Ideally, we would like the distributions $p ( f ( s _ { S , r } ) )$ and $p ( g ( s _ { T , r } ) )$ to match as closely as possible. However, it may still be necessary for the target agent to learn some aspects of the skill from scratch, since not all intricacies will transfer in the presence of morphological differences. We therefore use a reinforcement learning algorithm to learn $\\pi _ { T }$ , but with an additional term added to the reward function that provides guidance via $f ( s _ { S , r } )$ . This term has following form: ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7d6a964ebb6085762e6a399e50b5c0fc05906b439820a80cd5a73b3a8711ed87.jpg",
+        "text": "$$\nr _ { \\mathrm { t r a n s f e r } } ( s _ { T , r } ^ { ( t ) } ) = \\alpha \\lvert | f ( s _ { S , r } ^ { ( t ) } ; \\theta _ { f } ) - g ( s _ { T , r } ^ { ( t ) } ; \\theta _ { g } ) \\rvert | _ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            150,
+            643,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where s(t)S,r is the agent-specific state along the optimal policy in the source domain at time step $t$ , and s(t)T,r is the agent-specific state along the current policy that is being learned in the target domain at time step $t$ , and $\\alpha$ is a weight on the transfer reward that controls its importance relative to the overall task goal. In essence, this additional reward provides a form of reward shaping, which gives additional learning guidance in the target domain. In sparse reward environments, task performance is highly dependent on directed exploration, and this additional incentive to match trajectory distributions in the embedding space provides strong guidance for task performance. ",
+        "bbox": [
+            173,
+            180,
+            825,
+            289
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In tasks where the pairs mapping $\\mathcal { P }$ is imperfect, the transfer reward may sometimes interfere with learning when the target domain policy is already very good, though it is usually very helpful in the early stages of learning. We therefore might consider gradually reducing the weight $\\alpha$ as learning progresses in the target domain. We use this technique for our second experiment, which learns a policy for a tendon-driven arm. ",
+        "bbox": [
+            174,
+            289,
+            576,
+            398
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/fcd30238b300e881b7bb4c9eb50031c4e3553ace0d7f7ccd1831730a5e7630c1.jpg",
+        "image_caption": [
+            "Figure 2: The 3 and 4 link robots performing the button pressing task, which we use to evaluate the performance of our transfer method. Each task is trained on multiple conditions where the objects start in different locations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            606,
+            300,
+            805,
+            358
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            419,
+            326,
+            434
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our experiments aim to evaluate how well common feature space learning can transfer skills between morphologically different agents. The experiments were performed in simulation using the MuJoCo physics simulator (Todorov et al., 2012), in order to explore a variety of different robots and actuation mechanisms. The embedding functions $f$ and $g$ in our experiments are 3 layer neural networks with 60 hidden units each and ReLu non-linearities. They are trained end-to-end with standard backpropagation using the ADAM optimizer (Kingma & Ba, 2015). Videos of our experiment will be available at https://sites.google.com/ site/invariantfeaturetransfer/ For details of the reinforcement learning algorithm used, refer to Appendix A. ",
+        "bbox": [
+            174,
+            450,
+            576,
+            463
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            462,
+            825,
+            575
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 METHODS USED FOR COMPARISON ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            592,
+            455,
+            606
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the following experiments, we compare our method with other methods. The simplest one, referred to as “no transfer”, aims to learn the target task from scratch. This method generally cannot succeed in sparse reward environments without a large number of episodes. Table 1 shows that, without transfer, the tasks are not learned even with 3-4 times more experience. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            672
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also compare to several linear methods, including random projections, canonical correlation analysis (CCA), and unsupervised manifold alignment (UMA). Random projections of data have been found to provide meaningful dimensionality reduction (Hegde et al., 2008). We assign $f$ and $g$ be random projections into spaces of the same dimension, and transfer as described in Section 4.1.1. CCA (Hotelling, 1936) aims to find a basis for the data in which the source data and target data are maximally correlated. We use the matrices that map from state space to the learned basis as $f$ and $g$ . UMA (Wang & Mahadevan (2009), Ammar et al. (2015b)) uses pairwise distances between states to align the manifolds of the two domains. These methods impose a linearity constraint on $f$ and $g$ which proves to limit the expressiveness of the embeddings. We find that using CCA to learn the embedding allows for transfer between robots, albeit without as much performance gained than if $f$ and $g$ are neural networks. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also compare to kernel-CCA (KCCA) which uses a kernel matrix to perform CCA, allowing the method to use an implied non-linear feature mapping of the data. We test on several different kernels, including polynomial (quad), radial basis (rbf), and linear. These methods perform especially well on transfer between different actuation methods, but which kernel to use for best performance is not consistent between experiments. For example, although the quadratic kernel performs competitively with our method for the tendon experiment, it does not work at all for our button pushing experiment. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The last method we compare with is “direct mapping” which learns to directly predict $s _ { T , r }$ from $s _ { S , r }$ instead of mapping both into a common space. This is representative of a number of prior techniques that attempt to put source and target domains into direct correspondence such as Taylor et al. (2008). In this method, we use the same pairs as we do for our method, estimated from prior experience, but try to map directly from the source domain to the target domain. In order to guide learning using this method, we pass optimal source trajectories through the learned mapping, and then penalize the target robot for deviating from these predicted trajectories. As seen in Figures 5 and 8 this method does not succeed, probably because mapping from one state space to another is more difficult than mapping both state spaces into similar embeddings. The key difference between this method and ours is that we map both domains into a common space, which allows us to put only the common parts of the state spaces in correspondence instead of trying to map between entire states across domains. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We have also included a comparison between using time-based alignment across domains versus using a more elaborate EM-style procedure as described in 3.3.2. ",
+        "bbox": [
+            173,
+            277,
+            823,
+            305
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 TRANSFER BETWEEN ROBOTS WITH DIFFERENT NUMBERS OF LINKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            321,
+            694,
+            337
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e19b97d8d06e20b39fb09ef4495d0dce9f1f1521d5dbd8249580bed4768ca9f0.jpg",
+        "image_caption": [
+            "Figure 3: The 4-link robot pushing the button. Note that the reward function only tells the agent how far the button has been depressed, and provides no information to indicate that the arm should reach for the button. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            351,
+            808,
+            401
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/4ee4b94688723b3e5668aba56e507c54c3cc8675794167b5da4d28907a1ae2ad.jpg",
+        "image_caption": [
+            "Figure 4: The 3 and 4 link robots performing each of the three proxy tasks we consider: target reaching, peg insertion, and block moving. Our results indicate that using all three proxy tasks to learn the common feature space improves performance over any single proxy task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            458,
+            795,
+            573
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our first experiment, we evaluate our method on transferring information from a 3-link robot to a 4-link robot. These robots have similar size but different numbers of links and actuators, making the representation needed for transfer non-trivial to learn. In order to evaluate the effectiveness of our method, we consider tasks with sparse or delayed rewards, which are difficult to learn quickly without the use of prior knowledge, large amounts of experience, or a detailed shaping function to guide exploration. For transfer between the 3 link and 4 link robots, we evaluate our method on a button pressing task as shown in Figures 2 and 3. The goal of this task is to reach through a narrow opening and press the white button to the red goal marker indicated in the figure. The caveat is that the reward signal tells the arms nothing about where the button is, but only penalizes distance between the white button and the red goal. Prior work has generally used well-shaped reward functions for tasks of this type, with terms that reward the arm for approaching the object of interest (Lillicrap et al., 2015; Devin et al., 2016). Without the presence of a directed reward shaping guiding the arm towards the button, it is very difficult for the task to be performed at all in the target domain, as seen from the performance of learning from scratch with no transfer (“baseline”) in the target domain in Figure 5. This is indicative of how such a task might be learned in the real world, where it is hard to provide anything but very sparse feedback by using a sensor on the button. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For this experiment, we compare the quality of transfer when using different proxy tasks: reaching a target, moving a white block to the red goal, and inserting a peg into a slot near the robot, as shown in Figure 4. These tasks are significantly easier than the sparse reward button pressing task. Collecting successful trajectories from the proxy task, we train the functions $f$ and $g$ as described in ",
+        "bbox": [
+            174,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/33cf742f1f8220b12ec99b88cea76fcb8032477303fee5964e22dbb2bac02824.jpg",
+        "table_caption": [
+            "Table 1: Maximum success rate of “no transfer” method over 75 iterations of training shown for the 3 tasks considered in Sections 5.2, 5.3, and 5.4. Because the target environments suffer from sparse rewards, this method is unable to learn the tasks with a tractable amount of data. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>Button (Section 5.2)</td><td rowspan=1 colspan=1>Block Pull (Section 5.3)</td><td rowspan=1 colspan=1>Block Push (Section 5.4)</td></tr><tr><td rowspan=1 colspan=1>Best in 75 iters</td><td rowspan=1 colspan=1>0.0%</td><td rowspan=1 colspan=1>4.2%</td><td rowspan=1 colspan=1>7.1%</td></tr></table>",
+        "bbox": [
+            179,
+            101,
+            815,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Section 4. Note that the state in both robots is just the joint angles and joint velocities. Learning a suitable common feature space therefore requires the networks to understand how to map from joint angles to end-effectors for both robots. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            251
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We consider the 3-link robot pressing the button as the source domain and the 4-link robot pressing the button as the target domain. We allow the domain with the 3-link robot to have a well shaped cost function which has 2 terms: one for bringing the arm close to the button, and one for the distance of the button from the red goal position. The performance of our method is shown in Figure 5. The agent trained with our method performs more directed exploration and achieves an almost perfect success rate in 7 iterations. The CCA method requires about 4 times more experience to reach $60 \\%$ success than our method, indicating that using deep function approximators for the functions $f$ and $g$ which allows for a more expressive mapping than CCA. Even with kernel CCA, the task is not able to be performed as well as our method. Additionally the UMA and random projections baselines perform much worse than our method. We additionally find that using the EM style alignment procedure described in 3.3.2 also allows us to reach perfect formance as shown in Figure 5. Investigating this method further will be the subject of future work. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Learning a direct mapping between states in both domains only provides limited transfer because this approach is forced to learn a mapping directly from one state space to the other, even though there is often no complete correspondence between two morphologically different robots. For example there may be some parts of the state which can be put in correspondence, but others which cannot. Our method of learning a common space between robots allows the embedding functions to only retain transferable information. ",
+        "bbox": [
+            174,
+            431,
+            825,
+            515
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/35f4346cf2a000a00908964bf83ee6b32ef4b399aca560719a2c161ac78719b9.jpg",
+        "image_caption": [
+            "Figure 5: Performance of 4-link arm on the sparse reward button pressing task described in Section 5.2. On the left and middle, we compare our method with the methods described in Section 5.1. On the right, the “peg,” “push,” and “reach” proxy ablations indicate the performance when using embedding functions learned from those proxy tasks. The embedding improves significantly when learned from all three proxy tasks, indicating that our method benefits from additional prior experience. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            530,
+            812,
+            681
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 TRANSFER BETWEEN TORQUE CONTROLLED AND TENDON CONTROLLED MANIPULATORS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            786,
+            727,
+            814
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to illustrate the ability of our method to transfer across vastly different actuation mechanisms and learn representations that are hard to specify by hand, we consider transfer between a torque driven arm and a tendon driven arm, both with 3 links. These arms are pictured in Figure 6. The torque driven arm has motors at each of its joints that directly control its motion, and the state includes joint angles and joint velocities. The tendon driven arm, illustrated in Figure 6, uses three tendons to actuate the joints. The first tendon spans both the shoulder and the elbow, while the second and third control the elbow and wrist individually. The last tendon has a variable-length lever arm, while the first two have fixed-length lever arms, corresponding to tendons that conform to the arm as it bends. This coupled system uses tendon lengths and tendon velocities as the state representation, without direct access to joint angles or end-effector positions. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The state representations of the two robots are dramatically different, both in terms of units, dimensionality, and semantics. Therefore, learning a suitable common feature space represents a considerable challenge. In our evaluation, the torque driven arm is the source robot, and the tendon driven arm is the target robot. The task we require both robots to perform is a block pulling task indicated in Figure 7. This involves pulling a block in the direction indicated, which is nontrivial because it requires moving the arm under and around the block, which is restricted to only move in the directions indicated in Figure 6. With random exploration, the target robot is unable to perform directed exploration to get the arm to actually pull the block in the desired direction, as shown in Figure 8. ",
+        "bbox": [
+            174,
+            154,
+            529,
+            361
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/cca7e0dd7adde288ffb05b71cbdeaef6c25ff0c6d54a8bec5ec4d8b29cdb38b8.jpg",
+        "image_caption": [
+            "Figure 6: The top images show the source and target domain robots: the robot on the left is torque driven at the joints and the one on the right is tendon driven. The tendons are highlighted in the image; the green tendon has a variable-length lever arm, while the yellow tendons have fixed-length lever arms. Note that the first tendon couples two joints. The bottom images show two variations of the test task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            589,
+            162,
+            776,
+            238
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We use one proxy task in the experiment, which involves both arms reaching to various locations. With embedding functions $f$ and $g$ trained on optimal trajectories from the proxy task, we see that the transfer reward from our method enables the task to actually be performed with a tendon driven arm. The baseline of learning from scratch, which again corresponds to attempting to learn the task with the target tendon-driven arm from scratch, fails completely. The other methods of using CCA, and learning a direct mapping are able to achieve better performance than learning from scratch but learn slower. Kernel CCA with the quadratic kernel does competitively with our method but in turn performed very poorly on the button task so is not very consistent. Additionally, the random projection and UMA baselines perform quite poorly. The performance of the EM style alignment procedure is very similar to the standard time based alignment as seen in Figure 8, likely because the data is already quite time aligned across the domains. These results indicate that learning the common feature subspace can enable substantially accelerated learning in the target domain, and in fact can allow the target agent to learn a task that it fails to learn without any transfer rewards, and performs better than alternative methods. ",
+        "bbox": [
+            174,
+            368,
+            825,
+            563
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/5335128dc06055cb07a9c0955bff0bbf88a37b54a594edb747e0dc9fc274433c.jpg",
+        "image_caption": [
+            "Figure 7: The tendon-driven robot pulling the block. Note that the reward function only tells the agent how far the block is from the red goal and provides no information to indicate that the arm should reach around the block in order to pull it. The block is restricted to move only towards the red goal, but the agent needs to move under and around the block to pull it. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            574,
+            802,
+            613
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 TRANSFER THROUGH IMAGE FEATURES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            688,
+            491,
+            702
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A compelling use-case for learned common embeddings is in learning vision-based policies. In this experimental setup, we evaluate our method on learning embeddings from raw pixels instead of from robot state. Enabling transfer from extra high dimensional inputs like images would allow significantly more natural transfer across a variety of robots without restrictive assumptions about full state information. ",
+        "bbox": [
+            174,
+            714,
+            825,
+            784
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our method on transfer across a 3-link and a 4-link robot as in Section 5.2, but use images instead of state. Because images from the source and target domains are the same size and the same ”type”, we let $g = f$ . We parametrize $f$ as 3 convolutional layers with 5x5 filters and no pooling. A spatial softmax (Levine et al., 2016) is applied to the output of the third layer such that $f$ outputs normalized pixel indices of feature points on the image. These “feature points” form the latent representation that we compare across domains. Intuitively the common “feature points” embeddings should represent parts of the robots which are common across different robots. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Embeddings between the domains are built using a proxy task of reaching to a point, similar to the one described in the previous experiments. The test task in this case is to push a white block to a red target as shown in Figure 9a, which suffers from sparse rewards because the reward only accounts for the distance of the block from the goal. Unless the robot knows that it has to touch the block, it receives no reward and has unguided exploration. As shown in Figure $^ \\mathrm { 9 b }$ , our method is able to transfer meaningful information from source to target robot directly from raw images and successfully perform the task even in the presence of sparse rewards. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/127e491224236b3ae8e9e08416d210bb3f17a3b3df0cdb57aa2e8d3ebe609dd6.jpg",
+        "image_caption": [
+            "Figure 8: Performance of tendon-controlled arm on block pulling task. While the environment’s reward is too sparse to succeed in a reasonable time without transfer, using our method to match feature space state distributions enables faster learning. Using a linear embedding or mapping directly from source states to target states allows for some transfer. Optimizing over $P$ instead of assuming time-based alignment does not hurt performance. KCCA with quadratic kernel performs very well in this experiment, but not in experiment $^ { l }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            103,
+            758,
+            297
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            400,
+            825,
+            472
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/09f6e3ac04715fa7555e8526eea8f814c5cfc21ecb2637ffec87982754c53530.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            475,
+            488,
+            766,
+            693
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/cfa59e2b456a88d3726010ea59af2f71135622f4a80fe037b8aa6ee529a94b96.jpg",
+        "image_caption": [
+            "(a) The 3-link robot demonstrating the task. The yellow triangles mark the locations of the feature points output by $f$ applied to the image pixels. We then use the feature points to transfer the skill to the 4-link robot. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            494,
+            333,
+            695
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(b) Performance of 4-link robot on block pushing task for transfer using raw images. We transfer from the 3-link robot by learning a feature space from raw pixels of both domains, enabling effective faster learning. Random projections and linear kernel-CCA have some success in transfer. The baseline is unable to succeed because of the reward signal is too sparse without transfer. ",
+        "bbox": [
+            426,
+            702,
+            818,
+            779
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            808,
+            485,
+            824
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We presented a method for transferring skills between morphologically different agents using invariant feature spaces. The formulation of our transfer problem corresponds to a setting where two agents (e.g. two different robots) have each learned a collection of skills, with some skills known to just one of the agents, and some shared by both. A shared skill can be used to learn a space that implicitly brings the agents into correspondence, without assuming that an explicit state space isomorphism can be constructed. By then mapping into this space a skill that is known to only one of the agents, the other agent can substantially accelerate its learning of this skill by transferring the shared structure. We present an algorithm for learning the shared feature spaces using a shared proxy task, and experimentally illustrate that we can use this method to transfer manipulation skills between different simulated robotic arms. Our experiments include transfer between arms with different numbers of links, as well as transfer from a torque-driven arm to a tendon-driven arm. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            172
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A promising direction for future work is to explicitly handle situations where the two (or more) agents must transfer new skills by using a large collection of prior behaviors, with different degrees of similarity between the agents. In this case, constructing a shared feature space involves not only mapping the skills into a single space, but deciding which skills should or should not be combined. For example, a wheeled robot might share manipulation strategies with a legged robot, but should not attempt to share locomotion behaviors. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            263
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In a large-scale lifelong learning domain with many agent and many skills, we could also consider using our approach to gradually construct more and more detailed common feature spaces by transferring a skill from one agent to another, using that new skill to build a better common feature space, and then using this improved feature space to transfer more skills. Automatically choosing which skills to transfer when in order to minimize the training time of an entire skill repertoire is an interesting and exciting direction for future work. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            354
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            376,
+            285,
+            391
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Haitham Bou Ammar and Matthew E. Taylor. Reinforcement learning transfer via common subspaces. In Adaptive and Learning Agents: International Workshop, 2012. ",
+        "bbox": [
+            174,
+            398,
+            823,
+            428
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Haitham Bou Ammar, Eric Eaton, Paul Ruvolo, and Matthew Taylor. Unsupervised cross-domain transfer in policy gradient reinforcement learning via manifold alignment. In AAAI Conference on Artificial Intelligence, 2015a. ",
+        "bbox": [
+            173,
+            435,
+            825,
+            479
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Haitham Bou Ammar, Eric Eaton, Paul Ruvolo, and Matthew E Taylor. Unsupervised cross-domain transfer in policy gradient reinforcement learning via manifold alignment. In Proc. of AAAI, 2015b. ",
+        "bbox": [
+            176,
+            488,
+            825,
+            530
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shai Ben-David and Reba Schuller. Exploiting task relatedness for multiple task learning. In Learning Theory and Kernel Machines, pp. 567–580. Springer, 2003. ",
+        "bbox": [
+            171,
+            540,
+            823,
+            570
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexander Braylan, Mark Hollenbeck, Elliot Meyerson, and Risto Miikkulainen. Reuse of neural modules for general video game playing. CoRR, abs/1512.01537, 2015. ",
+        "bbox": [
+            173,
+            577,
+            823,
+            608
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rich Caruana. Multitask learning. Machine Learning, 1997. ",
+        "bbox": [
+            171,
+            616,
+            570,
+            631
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sumit Chopra, Raia Hadsell, and Yann LeCun. Learning a similarity metric discriminatively, with application to face verification. In Computer Vision and Pattern Recognition, 2005. CVPR 2005. IEEE Computer Society Conference on, volume 1, pp. 539–546. IEEE, 2005. ",
+        "bbox": [
+            174,
+            640,
+            823,
+            683
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shreyansh Daftry, J. Andrew Bagnell, and Martial Hebert. Learning transferable policies for monocular reactive MAV control. In International Symposium on Experimental Robotics (ISER), 2016. ",
+        "bbox": [
+            173,
+            691,
+            821,
+            720
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Coline Devin, Abhishek Gupta, Trevor Darrell, Pieter Abbeel, and Sergey Levine. Learning modular neural network policies for multi-task and multi-robot transfer. arXiv preprint arXiv:1609.07088, 2016. ",
+        "bbox": [
+            176,
+            729,
+            823,
+            772
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "P. F. Ferrari, S. Rozzi, and L. Fogassi. Mirror neurons responding to observation of actions made with tools in monkey ventral premotor cortex. Journal of Cognitive Neuroscience, 17(2), 2005. ",
+        "bbox": [
+            174,
+            781,
+            823,
+            810
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, Francois Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. Journal of Machine Learning Research, 17, 2016. ",
+        "bbox": [
+            176,
+            819,
+            821,
+            862
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chinmay Hegde, Michael Wakin, and Richard Baraniuk. Random projections for manifold learning. In Advances in neural information processing systems, pp. 641–648, 2008. ",
+        "bbox": [
+            174,
+            871,
+            823,
+            900
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Harold Hotelling. Relations between two sets of variates. Biometrika, 28, 1936. ",
+        "bbox": [
+            173,
+            909,
+            697,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "George Konidaris. A framework for transfer in reinforcement learning. In ICML-06 Workshop on Structural Knowledge Transfer for Machine Learning, 2006. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "George Konidaris and Andrew Barto. Autonomous shaping: knowledge transfer in reinforcement learning. In International Conference on Machine Learning (ICML), pp. 489–496, 2006. ",
+        "bbox": [
+            174,
+            179,
+            823,
+            209
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine and Pieter Abbeel. Learning neural network policies with guided policy search under unknown dynamics. In Advances in Neural Information Processing Systems, 2014. ",
+        "bbox": [
+            174,
+            217,
+            823,
+            247
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17:1–40, 2016. ",
+        "bbox": [
+            176,
+            255,
+            823,
+            285
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Weiwei Li and Emanuel Todorov. Iterative linear quadratic regulator design for nonlinear biological movement systems. In ICINCO (1), 2004. ",
+        "bbox": [
+            173,
+            292,
+            823,
+            323
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "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. CoRR, abs/1509.02971, 2015. ",
+        "bbox": [
+            174,
+            330,
+            823,
+            375
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrew Meltzoff. Born to learn: What infants learn from watching us. Skillman, NJ: Pediatric Institute Publication, 1999. ",
+        "bbox": [
+            173,
+            382,
+            821,
+            412
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Meinard Muller. Dynamic time warping. ¨ Information retrieval for music and motion, pp. 69–84, 2007. ",
+        "bbox": [
+            173,
+            421,
+            821,
+            450
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sinno Jialin Pan and Qiang Yang. A survey on transfer learning. IEEE Transactions on knowledge and data engineering, 22(10):1345–1359, 2010. ",
+        "bbox": [
+            173,
+            459,
+            821,
+            489
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaizad V Raimalwala, Bruce A Francis, and Angela P Schoellig. A preliminary study of transfer learning between unicycle robots. In 2016 AAAI Spring Symposium Series, 2016. ",
+        "bbox": [
+            173,
+            497,
+            821,
+            527
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Giacomo Rizzolatti and Laila Craighero. The mirror neuron system. Annual Review of Neuroscience, 27:169–192, 2004. ",
+        "bbox": [
+            173,
+            535,
+            823,
+            564
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrei A. Rusu, Neil C. Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. CoRR, abs/1606.04671, 2016a. ",
+        "bbox": [
+            173,
+            573,
+            823,
+            616
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrei A Rusu, Matej Vecerik, Thomas Rothorl, Nicolas Heess, Razvan Pascanu, and Raia Hadsell. ¨ Sim-to-real robot learning from pixels with progressive nets. arXiv preprint arXiv:1610.04286, 2016b. ",
+        "bbox": [
+            173,
+            625,
+            823,
+            667
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew Taylor, Peter Stone, and Yaxin Liu. Transfer learning via inter-task mappings for temporal difference learning. Journal of Machine Learning Research, 8(1):2125–2167, 2007. ",
+        "bbox": [
+            169,
+            676,
+            821,
+            707
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew E. Taylor and Peter Stone. Transfer learning for reinforcement learning domains: A survey. Journal of Machine Learning Research, 10:1633–1685, 2009. ",
+        "bbox": [
+            169,
+            714,
+            821,
+            744
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew E. Taylor, Nicholas K. Jong, and Peter Stone. Transferring instances for model-based reinforcement learning. In Proceedings of the European Conference on Machine Learning and Principles and Practice of Knowledge Discovery in Databases (ECML PKDD), 2008. ",
+        "bbox": [
+            176,
+            752,
+            823,
+            796
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "E. Todorov, T. Erez, and Y. Tassa. MuJoCo: A physics engine for model-based control. In International Conference on Intelligent Robots and Systems (IROS), 2012. ",
+        "bbox": [
+            171,
+            804,
+            821,
+            835
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eric Tzeng, Judy Hoffman, Trevor Darrell, and Kate Saenko. Simultaneous deep transfer across domains and tasks. In International Conference in Computer Vision (ICCV), 2015. ",
+        "bbox": [
+            171,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "M. A. Umilta, L. Escola, I. Intskirveli, F. Grammont, M. Rochat, F. Caruana, A. Jezzini, V. Gallese, and G. Rizzolatti. When pliers become fingers in the monkey motor system. Proceedings of the National Academy of Sciences, 105(6):2209–2213, 2008. ",
+        "bbox": [
+            176,
+            881,
+            821,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chang Wang and Sridhar Mahadevan. Manifold alignment without correspondence. In IJCAI, volume 2, pp. 3, 2009. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eric P. Xing, Andrew Y. Ng, Michael I. Jordan, and Stuart Russell. Distance metric learning, with application to clustering with side-information. In Proceedings of the 15th International Conference on Neural Information Processing Systems, NIPS’02, pp. 521–528, Cambridge, MA, USA, 2002. MIT Press. URL http://dl.acm.org/citation.cfm?id $=$ 2968618.2968683. ",
+        "bbox": [
+            174,
+            141,
+            825,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "7 APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            294,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "7.1 REINFORCEMENT LEARNING WITH LOCAL MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            575,
+            147
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Although we can use any suitable reinforcement learning algorithm for learning policies, in this work, we use a simple trajectory-centric reinforcement learning method that trains time-varying linear-Gaussian policies (Levine & Abbeel, 2014). While this method produces simple policies, it is very efficient, making it well suited for robotic learning. To obtain robot trajectories for training tasks and source robots, we optimize time-varying linear-Gaussian policies through a trajectorycentric reinforcement learning algorithm that alternates between fitting local time-varying linear dynamics models, and updating the time-varying linear-Gaussian policies using the iterative linearquadratic Gaussian regulator algorithm (iLQG) (Li & Todorov, 2004). This approach is simple and efficient, and is typically able to learn complex high-dimensional skills using just tens of trials, making it well suited for rapid transfer. The resulting time-varying linear-Gaussian policies are parametrized as $p ( u _ { t } | x _ { t } ) = \\mathcal { \\bar { N } } ( K _ { t } x _ { t } + k _ { t } , C _ { t } )$ where $K _ { t }$ , $k _ { t }$ , and $C _ { t }$ are learned parameters. Further details of this method are presented in prior work (Levine & Abbeel, 2014). ",
+        "bbox": [
+            174,
+            160,
+            825,
+            325
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We use the same reinforcement learning algorithm to provide solutions in the source domain $D _ { S }$ , though again any suitable reinforcement learning method (or even human demonstrations) could be used instead. To evaluate the ability of our method to provide detailed guidance through the transfer reward $r _ { \\mathrm { t r a n s f e r } }$ , we use relatively sparse reward functions in the target domain $D _ { T }$ , as discussed below. To generate the original skills in the source domain $D _ { S }$ and in the proxy domains $D _ { S p }$ and $D _ { T p }$ , we manually designed the appropriate shaped costs to enable learning from scratch to succeed, though we note again that our method is agnostic to how the source domain and proxy domain skills are acquired. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            444
+        ],
+        "page_idx": 13
+    }
+]

parse/train/JdQ2-DTaGF/JdQ2-DTaGF.md

@@ -0,0 +1,439 @@
+# Indicators of Attack Failure: Debugging and Improving Optimization of Adversarial Examples
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Evaluating robustness of machine-learning models to adversarial examples is a   
+2 challenging problem. Many defenses have been shown to provide a false sense of   
+3 security by causing gradient-based attacks to fail, and they have been broken under   
+4 more rigorous evaluations. Although guidelines and best practices have been sug  
+5 gested to improve current adversarial robustness evaluations, the lack of automatic   
+6 testing and debugging tools makes it difficult to apply these recommendations in   
+7 a systematic manner. In this work, we overcome these limitations by (i) defining   
+8 a set of quantitative indicators which unveil common failures in the optimization   
+9 of gradient-based attacks, and (ii) proposing specific mitigation strategies within   
+10 a systematic evaluation protocol. Our extensive experimental analysis shows that   
+11 the proposed indicators of failure can be used to visualize, debug and improve   
+12 current adversarial robustness evaluations, providing a first concrete step towards   
+13 automatizing and systematizing current adversarial robustness evaluations.
+
+# 14 1 Introduction
+
+15 Neural networks are now deployed in settings where it is important that they behave reliably and   
+16 robustly [19, 15, 33, 3]. Unfortunately, these systems are vulnerable to adversarial examples [29, 4],   
+17 i.e., inputs intentionally crafted to mislead machine-learning classifiers at test time. These attacks   
+18 are especially important in settings where classifiers have security-critical consequences, including   
+19 autonomous driving, automated medical diagnoses, and cybersecurity-related tasks such as spam and   
+20 malware detection, web-page ranking and network protocol verification [27, 18, 26, 2, 28, 15].   
+21 This vulnerability has caused a strong reaction from the community, with many proposed defenses [33,   
+22 22, 31, 25]. Early defenses often argued robustness by showing the defense could prevent prior   
+23 attacks, but not attacks tailored to that particular defense. As a result, most of these defenses have   
+24 turned out to only provide a false sense of security, i.e., to be broken when targeted by an adaptive   
+25 attack that tailors the attack strategy to the particular defense [11, 1]. More recent work has tried to   
+26 evaluate using such adaptive attacks. Unfortunately, even this has proven difficult; recent work has   
+27 shown that 13 published defenses proposed in the last year are ineffective despite almost all of them   
+28 containing an analysis to adaptive attacks [30].   
+29 The reason why adversarial example defense evaluations are incomplete comes down to the difficulty   
+30 of performing an adaptive attack, and diagnosing when they go wrong. Adversarial examples are   
+31 typically generated through gradient descent: the adversary first constructs a loss function so that a   
+32 minimum for that function is an adversarial example. While gradient-based attacks are highly effective   
+33 at finding adversarial examples on undefended classifiers with smooth loss functions, many defenses   
+34 substantially hinder the attack optimization by obfuscating gradients or by exhibiting harder-to  
+35 optimize loss functions. In particular, most attempted defenses to adversarial examples only succeed   
+36 at increasing the difficulty of solving the minimization formulation, and not at actually increasing the
+
+Input : $_ { \textbf { \em x } }$ , the initial point; $y$ , the true class of the initial point; $n$ , the number of iterations; $\alpha$ , the learning rate; $f$ , the target model; $\Delta$ , the considered region. Output : $\scriptstyle { \pmb x } ^ { \star }$ , the solution found by the algorithm 1 $\mathbf { \boldsymbol { x } } _ { 0 } \gets$ initialize $( { \pmb x } )$ $\triangleright$ Initialize starting point 2 $\hat { \pmb { \theta } } \gets$ approximation(θ) . Approximate model parameters 3 $\delta _ { 0 }  \mathbf { 0 }$ . Initial δ 4 for $i \in [ 1 , n ]$ do 5 $\pmb { \delta } ^ { \prime }  \pmb { \delta } _ { i } - \alpha \nabla _ { \pmb { x } _ { i } } L ( \pmb { x } _ { 0 } + \pmb { \delta } _ { i } , y ; \hat { \pmb { \theta } } )$ . Compute optimizer step 6 δi+1 ← apply-constraints(x0, δ0, ∆) . Apply constraints (if needed) 7 $\delta ^ { \star } \gets \mathsf { b e s t } ( \delta _ { 0 } , . . . , \delta _ { n } )$ . Choose best perturbation 8 return δ?
+
+37 robustness of the underlying classifier (i.e., increasing the actual distance of the decision boundary   
+38 from the input sample) [10, 11, 1, 30]. Moreover, even though guidelines and best practices have   
+39 been suggested to improve current adversarial robustness evaluations, the lack of automatic testing   
+40 and debugging tools makes it difficult to apply these recommendations in a systematic manner. These   
+41 difficulties have perpetuated a constant cat-and-mouse game where defenders propose new schemes,   
+42 and attackers find that actually the defense was only increasing the difficulty of solving the underlying   
+43 minimization problem [5, 3].   
+44 This paper directly addresses these limitations by (i) developing quantitative indicators of failure,   
+45 i.e., metrics designed to help debug optimization of gradient-based attacks for generating adversarial   
+46 examples, and (ii) suggesting a systematic evaluation protocol to improve current robustness eval  
+47 uations by applying a sequence of specific mitigation strategies. In four case studies of published   
+48 defenses that have been shown to be ineffective against stronger adaptive attacks, we show (i) that   
+49 our indicators would have highlighted different failure modes in the original evaluations, and (ii) how   
+50 these failures could have been easily overcome by following our suggested mitigation strategies.   
+51 To summarize, we make the following contributions: (i) we introduce a unified attack framework   
+52 that captures the predominant styles of existing gradient-based attack methods, and allows us to   
+53 categorize the five main causes of failure that may arise during their optimization (Sect. 2); (ii) we   
+54 propose five indicators of attack failures (IoAF), i.e., metrics and principles that help understand why   
+55 and when gradient-based attack algorithms fail (Sect. 3); (iii) we empirically evaluate the utility of   
+56 our metrics on four recently-published defenses, showing how their robustness evaluations could   
+57 have been improved by monitoring the IoAF values and following our evaluation protocol (Sect. 4;   
+58 and (iv) we provide open-source code and data we used in this paper for reproducing resources. Our   
+59 code is available at https://github.com/ioaf-todo. 1 We conclude by discussing related work   
+60 (Sect. 5), along with the limitations of our work and future research directions (Sect. 6).
+
+# 61 2 Adversarial Robustness: Gradient-based Attacks and Failures
+
+62 We argue here that optimizing adversarial examples amounts to solving a multi-objective optimization:
+
+$$
+\operatorname* { m i n } _ { \delta \in \Delta } \left( L ( \boldsymbol { x } + \delta , \boldsymbol { y } ; \boldsymbol { \theta } ) , \lVert \delta \rVert _ { p } \right) ,
+$$
+
+3 where $\pmb { x } \in [ 0 , 1 ] ^ { d }$ is the input sample, $y \in \{ 1 , \ldots , c \}$ is either its label (for untargeted attacks) or   
+64 the label of the target class (for targeted attacks), and $\delta \in \Delta$ is the perturbation optimized to have   
+65 the perturbed sample ${ \pmb x } ^ { \prime } = { \pmb x } + { \pmb \delta }$ misclassified as desired, within the given input domain. The   
+66 target model is parameterized by $\pmb \theta$ . The given problem presents an inherent tradeoff: minimizing $L$   
+amounts to finding an adversarial example with large misclassification confidence and perturbation   
+68 size, while minimizing $\| \delta \| _ { p }$ penalizes larger perturbations (in the given $\ell _ { p }$ norm) at the expense of   
+69 decreasing misclassification confidence.2 Typically the attacker loss $L$ is defined as the Cross-Entropy   
+70 (CE) loss, or the logit difference [11].   
+71 Multiobjective problems can be solved by establishing a different tradeoff between the given objectives   
+72 along the Pareto frontier, by either using soft- or hard-constraint reformulations. For example, Carlini  
+73 Wagner (CW) [11] is a soft-constraint attack, which reformulates the aforementioned multiobjective   
+74 problem as an unconstrained optimization: mi ${ \bf \psi } _ { 1 } \| \delta \| _ { p } + c \cdot \operatorname* { m i n } ( L ( { \pmb x } + \delta , { \pmb y } , { \pmb \theta } ) , - \kappa )$ , where the   
+75 hyperparameters $\kappa$ and $c$ tune the trade-off between misclassification confidence and perturbation   
+76 size. Hard-constraint reformulations instead aim to minimize one objective while constraining the   
+77 other. They include maximum-confidence attacks like Projected Gradient Descent (PGD) [17], which   
+78 is formulated as $\begin{array} { r l } {  { \operatorname* { m i n } _ { \delta } L \big ( \pmb { x } + \delta , \pmb { y } ; \pmb { \theta } \big ) } \quad } & { { } } \end{array}$ s.t. $\| \delta \| _ { p } \leq \epsilon$ , and minimum-norm attacks like Brendel-Bethge   
+79 (BB) [6] and Decoupling-Direction-Norm (DDN) [24], which can be formulated as minδ $\| \delta \| _ { p }$ s.t.   
+80 $L ( x + \delta , y ; \pmb \theta ) \le k$ . In these cases, $\epsilon$ and $k$ upper bound the perturbation size and the misclassification   
+81 confidence, respectively, thereby optimizing a different tradeoff between these two quantities.   
+82 The aforementioned attacks often need to use an approximation $\hat { \pmb { \theta } }$ of the target model, since the latter   
+83 may be either non-differentiable, or not sufficiently smooth [1], hindering the gradient-based attack   
+84 optimization process. In this case, once the attacker loss has been optimized on the surrogate model   
+85 $\hat { \pmb { \theta } }$ , the attack is considered successful if it evades the target model $\pmb \theta$ .   
+86 Attack Algorithm. According to the previous discussion, even if different attacks minimize different   
+87 objectives or require different constraints, all of them can be seen as solutions to a common multiob  
+88 jective problem, based on gradient descent. Thus, their main steps can be summarized as detailed in   
+89 Algorithm 1. First, an initialization point (line 1) needs to be set, and this can be achieved by directly   
+90 using the input point $_ { \textbf { \em x } }$ , a randomly-perturbed version of it, or even a sample from the target class [6].   
+91 Then, if the target model $\pmb { \theta }$ is difficult to deal with, or it is non-differentiable, the attacker must chose   
+92 a surrogate model $\hat { \pmb { \theta } }$ that approximates the real target $\pmb \theta$ (line 2). The attack then iteratively updates   
+93 the initial point searching for a better and better adversarial example (line 4), computing in each   
+94 iteration one (or more) gradient descent steps (line 5) using the initial point and the perturbation $\delta _ { i }$   
+95 computed so far. Hence, the new perturbation $\delta _ { i + 1 }$ is obtained by enforcing the constraints defined in   
+96 the problem (line 6), that can be updated accordingly to the chosen strategy [23, 24]. For maximum   
+97 confidence approaches, the attack can not exit the $\Delta$ region, and samples are projected accordingly on   
+98 this ball when reaching the constraints. Similarly, we consider minimum distance attacks successful   
+99 only if they found adversarial examples inside the $\Delta$ region. At the end of the iterations, the attacker   
+100 has collected all the perturbations along the iterations, formalized as the attack path. The final result   
+101 of the algorithm is the the best perturbation contained in the attack path, w.r.t. the loss they are   
+102 minimizing (line 7).
+
+![](images/8841d529fd55e6ac7ccd4b8c563e1264bc4f269eabd05b338d3bd9c198e225ab.jpg)  
+Figure 1: The four attack failures that can be encountered during the optimization of an attack. The failed attack path is shown in gray, while the successful attack is displayed in black. The point $\scriptstyle { \mathbf { { \mathit { x } } } } _ { 0 }$ is marked with the red dot, the returned point of the failed attack with a red cross, and the successful adversarial point with the green star. The top row shows the loss landscape, as $L ( { \pmb x } + a { \pmb v } _ { 1 } + b { \pmb v } _ { 2 } , y _ { i } ; { \pmb \theta } )$ . ${ \pmb v } _ { 1 }$ is the normalized direction $\left( \pmb { x } _ { n } - \pmb { x } _ { 0 } \right)$ , while $\mathbf { \boldsymbol { v } } _ { 2 }$ is a representative direction for the displayed case. In the second row we show the value of $L ( x + \delta _ { i } , y _ { i } ; \pmb { \theta } )$ for the evaluated model.
+
+![](images/42ce9a9a02498671eddc3a98f7835190352139579142f0e330db6a260351eb0e.jpg)  
+Figure 2: Indicators of Attack Failures. The top row lists the four general failures encountered in gradient-based attacks. The second row lists the Indicators of Attack failures we propose, and the last row depicts possible mitigations that can be applied.
+
+# 103 2.1 Attack failures
+
+04 We can now isolate four failures that can be encountered while optimizing adversarial attacks using   
+05 Algorithm 1, and we bound each of them to specific steps of such procedure.
+
+$F _ { I }$ : Implementation Problems. If no adversarial examples are found by the attack, it might be possible that the used implementation include errors or bugs. For example, we isolated a bug inside the procedure proposed by Madry et al. [17]. The attack as described returns the adversarial example only by looking at the last point of the attack path (line 7 of Algorithm 2), as shown in Fig. 1a, but would not return an adversarial example if one was found during search and then passed over.
+
+11 $F _ { 2 }$ : Non-converging attack. When performing gradient descent based attacks, a common problem   
+12 is that attacks do not converge to any local minimum, as shown in Fig. 1b. This problem can be   
+13 caused by either the setup of the attack, and in Algorithm 1, this is reflected on the values of $\alpha$ and $n$   
+14 i.e. the step size of the attack, and the number of iterations. If $\alpha$ is too small, the gradient update step   
+15 is not exploring the space (line 5 of Algorithm 1), while using too few iterations $n$ might cause an   
+16 early stopping of the attack (line 4 of Algorithm 1). An example of this failure can be found in the   
+17 evaluation of the defense proposed by Buckman et al. [7], where the authors only used 7 steps of   
+18 PGD for testing the robustness of their defense, or by the one proposed by Pang et al. [21], where   
+19 the defense has been evaluated with only 10 steps of PGD. Also, this failure might be triggered   
+20 either by a too-large step size, that lead the optimizer to keep overshooting the local minimum, or   
+21 the presence of gradient obfuscation techniques [31] that alter the gradients of the model to point to   
+22 random directions, leading the descent to fail.   
+23 $F _ { 3 }$ : Bad local optimum. Once the attack reached convergence, the computed point might not be   
+24 adversarial, since the optimizer has reached a region where it can not update anymore the adversarial   
+25 perturbation, as shown in Fig. 1c. There are few reasons that might lead to such failure. One of them   
+26 is again caused by the presence of gradient obfuscation, where the optimizer is unable to continue the   
+27 descent, since it arrived in a region where the norms of gradients are (nearly) zero (i.e. flat regions),   
+28 or again because the gradients are noisy, and the optimization lands on a bad local optimum (line 5   
+29 of Algorithm 1). An example of such failure is detected inside the defense proposed by Papernot   
+30 et al. [22], where the model is trained to have signal in correspondence of samples, and producing   
+31 regions with no gradient all around them. Another reason might be triggered by the choice of the   
+32 initialization point itself (line 1 of Algorithm 1), that leads the optimizer into a region where no   
+33 adversarial examples can be found. The latter has been detected by the analysis conducted by Tramèr   
+34 et al. [30] against the defense proposed by Pang et al. [21], where a different initialization point lead   
+35 the attack to find a better solution.   
+36 $F _ { 4 }$ : Non-adaptive attack. The loss function that the attacker optimizes does not match the actual loss   
+37 of the target system, and this is caused by a bad choice of the surrogate model (line 2 of Algorithm 1),   
+38 as shown in Fig. 1d. This issue manifests when either the attack is computed on an undefended   
+39 model, and later tested against the defense, or the target model is not differentiable and the surrogate   
+40 is not really approximating it. Since we consider both cases, we differ from the literature, where the   
+141 term non-adaptive has been used only for attacks that were not specifically designed to target a given   
+142 defense [30]. An examples of this failure is found in the defense proposed by Yu et al. [32], where the   
+143 attack has been computed against the undefended model, and then evaluated against the defense later.   
+144 To maximize the likelihood of creating successful attacks and hence avoiding such failures, current   
+145 recommendations [30] suggest to (i) select the strongest attacks against the model that is being tested;   
+146 (ii) state the precise threat model being considered; (iii) select the correct hyperparameters for the   
+147 attack being used; and (iv) compute charts to understand how the attacks behave by varying the size   
+148 of the perturbation. Indeed useful, such are only qualitative recommendations that require ad-hoc   
+149 inspection of each failed attack.
+
+# 150 3 Indicators of Attack Failure
+
+151 In this section we describe our Indicators of Attack Failures, i.e. tests that help an analyst debug a   
+152 failing attack. Each of these tests outputs a value bounded between 0 and 1, where values towards 1   
+153 implies the presence of the failure described by the test. Informed by the results of the indicators,   
+154 we propose potential mitigations that can resolve the presence of the detected failure. An overview   
+155 of such approach can be appreciated in Fig. 2, where we connect failures with the indicators that   
+156 quantify them, along with possible mitigations.   
+157 $I _ { I }$ : Silent Success. This indicator is designed as a binary flag that   
+158 triggers when the attack is failing, but a legitimate adversarial exam  
+159 ple is found inside the attack path, as described by the implementa  
+160 tion problem failure $( F _ { I } )$ .   
+161 $I _ { 2 }$ : Break-point angle. This indicator is designed to quantify the   
+162 non-convergence of the attack $( F _ { 2 } )$ caused by the choice of too small   
+163 hyperparameters. We normalize the loss along the attack path and   
+164 the iteration, to fit the loss in the domain $[ 0 , 1 ] \times [ 0 , 1 ]$ , and, ideally, a   
+165 well-converged loss should approximate a triangle in that domain, as   
+166 shown in Fig. 3. To create that triangle, we connect the first and the   
+167 last point in the loss curve, and we conclude the shape by considering   
+168 the point of the loss curve that is further to such conjunction. We are   
+169 interested in the amplitude of the basis $\beta$ angle, since it is the one   
+170 that characterizes the shape of the triangle: when $\beta \approx \pi$ , the triangle is flat, implying that the loss is   
+171 still decreasing. For this reason, the indicator computes $1 - | c o s \beta |$ , matching such intended behavior.   
+172 On the other hand, this indicator is close to 0 when the triangle is close to be right, hence $\beta \approx \frac { \pi } { 2 }$ .   
+173 $I _ { 3 }$ : Increasing loss. This indicator is designed to quantify either the   
+174 non-convergence of the attack $( F _ { 2 } )$ p, or the inability of converging   
+175 to a good local optimum $( F _ { 3 } )$ 1, both caused by the presence of noisy   
+176 gradients, where the loss of the attack is increasing while optimizing.   
+177 To characterize such behavior, we normalize the loss of the attack   
+178 and the iterations as we did in $I _ { 2 }$ , and we extract from it only the   
+179 portions where it increases, and we compute its area, as shown in   
+180 βFig. 4. When this indicator is close to 1, the values of the loss are   
+181 pp3fluctuating around its maximum value, difficult to be decreased by   
+182 the optimizer.
+
+![](images/6f7704ee1baf89a3a6bdd31160d349635bab6ed45706f8adc62cde14c4bbc380.jpg)  
+Figure 3: $I _ { 2 }$ indicator.
+
+![](images/3fe340e2e78952e0f7ed896a8dd07272dfa35f3706c1f9c19020b45f089c22e1.jpg)  
+Figure 4: $I _ { 3 }$ indicator.
+
+$I _ { 4 }$ : Zero gradients. This indicator is designed to quantify the bad-local optimum failure $( F _ { 3 } )$ , caused by the absence of gradient information. For this reason, we compute how many times, along the attack path, the gradients of the loss function are zero:
+
+$\begin{array} { r } { \frac { 1 } { n + 1 } \sum _ { i = 0 } ^ { n } \mathbb { 1 } _ { \| \nabla _ { \pmb { x } + \delta _ { i } } L \| = 0 } } \end{array}$ . This indicator is close to 1 when most of the norms of the gradient are 0, causing the attack step to fail.
+
+189 $I _ { 5 }$ : Non-transferability. This indicator is designed to quantify the non-adaptive failure $( F _ { 4 } )$ , by   
+190 measuring if the optimized attack fails against the real target model, while succeeding against the   
+191 surrogate one. If the attack transfers successfully, the indicator is set to 0, otherwise it is set to 1.
+
+# 192 3.1 Mitigate the Failures of Security Evaluations
+
+93 Once the robust accuracy of a model has been computed, the attacker should now check the feedback   
+94 of the indicators and mitigate accordingly the detected failures.   
+5 $M _ { I }$ : Fix the implementation. If $I _ { I }$ is active, the attack is considered failed, but there exists an   
+96 adversarial point inside the computed path that satisfies the attack objective. Hence, the resulting   
+7 robust accuracy must be lowered to reflect this patch accordingly. Also, the attacker would want to   
+98 run again their evaluations using another library, or a patched version of the same attack.
+
+$M _ { 2 }$ : Tune the hyperparameters. If $I _ { 2 }$ activates, it means that the optimization can be improved, and hence both the step size and iteration hyperparameters can be increased. Otherwise, if $I _ { 3 }$ activates, the attack should consider a smaller step size, since the loss might be overshooting local minima.
+
+202 $M _ { 3 }$ : Use a different loss function. If $I _ { 3 }$ activates, and the decrement of the step size did not work,   
+203 the attack should change the loss to be optimized [30], preferring one that has a smoother behavior. If   
+204 $I _ { 4 }$ activates, the attack should consider loss functions that do not saturate (e.g. avoid the softmax) [9],   
+205 or also increase the step size of the attack to avoid regions with zero gradients.
+
+$M _ { 4 }$ : Consider different restarts for the attack. If $I _ { 3 }$ or $I _ { 4 }$ activates, the attack might also consider to repeat the experiments with more initialization points and restarts, as the failure could be the result of added randomness or an unlucky initialization.
+
+209 $M _ { 5 }$ : Perform adaptive attacks. Lastly, if none of the above applied, the attack might be optimizing   
+210 against a bad surrogate model. If $I _ { 5 }$ is active, the attack should be repeated by changing the surrogate   
+211 to better approximate the target, or include the defense inside the attack itself [30]. This step implies   
+212 repeating the evaluation, as the change of the surrogate might trigger other previously-fixed failures.   
+213 When attacks fail even after the application of recommended mitigations, it would be easy to assume   
+214 that the evaluated defense is strong against adversarial attacks. However, the only thing known is   
+215 that baseline attacks, properly tested, are not working against the defense. Hence, the designer of the   
+216 defense should try as hard as possible to break the proposed defense with further investigations [12],   
+217 and by performing sanity checks, e.g., ensuring that the robust accuracy drops to $0 \%$ when the   
+218 perturbation size is unbounded, or by trying different attack strategies, e.g., using gradient-free   
+219 attacks or attacks designed by reversing the defense mechanism.
+
+# 4 Experiments
+
+We now exhibit the results of our experiments, by showing the correlation between the feedback of our indicators, and the false sense of security given by badly-evaluated defenses.
+
+223 Experimental setup. We run our attacks on an Intel
+224 GB of RAM, and equipped with an Nvidia Quadro M6000 with $2 4 \mathrm { G B }$ of memory. All the attacks   
+225 and models have been wrapped and run by using the SecML library [20]. We select four defenses that   
+226 have been reported as failing, and we show that our indicators would have detected such evaluation   
+227 errors. For each of them, we set the hyperparameters for the attack as done in the original evaluation,   
+228 in order to collect similar results.   
+229 $k$ -Winners-Take-All $( k W T A )$ , the defense proposed by Xiao et al. [31] uses only the top- $\mathbf { \nabla } \cdot \mathbf { k }$ outputs   
+230 from each layer, generating many discontinuities in the loss landscape, and hence resulting in the   
+231 non-converging failure due to noisy gradients $( F _ { 2 } )$ . We use the implementation provided by Tramèr   
+232 et al. [30], trained on CIFAR10, and we test its robustness by attacking it with $\ell _ { \infty }$ -PGD [17] with a   
+233 step size of $\alpha = 0 . 0 0 3$ , maximum perturbation $\epsilon = 8 / 2 5 5$ and 50 iterations, with 5 restarts for each   
+234 attack, scoring a robust accuracy of $58 \%$ on 100 samples.   
+235 Distillation, the defense proposed by Papernot et al. [22], works by training a model to have zero   
+236 gradients around the training points, leading gradient-based attacks towards bad local optimum $( F _ { 3 } )$ .   
+237 We re-implemented such defense, by training a distilled classifier on the MNIST dataset to mimic the   
+238 original evaluation. Then, we apply $\ell _ { \infty }$ -PGD [17], with step size $\alpha = 0 . 0 1$ , maximum perturbation   
+239 $\epsilon = 0 . 3$ for 50 iterations on 100 samples, resulting in a robust accuracy of ${ 9 4 , 2 \% }$ .   
+240 Ensemble diversity, the defense proposed by Pang et al. [21] is composed with different neural   
+241 networks, trained with a regularizer that encourages diversity. We adopt the implementation provided   
+242 by Tramèr et al. [30]. Then, following its original evaluation, we apply $\ell _ { \infty }$ -PGD [17], with step size   
+243 $\alpha = 0 . 0 0 1$ , maximum perturbation $\epsilon = 0 . 0 1$ for 10 iterations on 100 samples, resulting in a robust   
+244 accuracy of $38 \%$ .
+
+245 Turning a Weakness into a Strenght (TWS), the defense proposed by Yu et al. [32], applies a mechanism
+
+<table><tr><td>Model</td><td>Attack</td><td>I</td><td>I</td><td>I3</td><td>I4</td><td>I5</td><td>I</td><td>RA</td></tr><tr><td rowspan="3">k-WTA[31]</td><td>PGD</td><td>0.33</td><td>0.43</td><td>0.77</td><td>1</td><td>1</td><td>0.306</td><td>58,2%</td></tr><tr><td>APGD</td><td>=</td><td>0.310</td><td>0.33</td><td></td><td></td><td>0.128</td><td>36,4%</td></tr><tr><td>PGD*</td><td>0.07</td><td>0.48</td><td>0.55</td><td>1</td><td>=</td><td>0.220</td><td>6,4%</td></tr><tr><td rowspan="3">Distillation [22]</td><td>PGD</td><td>1</td><td>0.98</td><td>1</td><td>0.97</td><td>-</td><td>0.39</td><td>94.2%</td></tr><tr><td>APGD</td><td>1</td><td>0.4</td><td>0.21</td><td>1</td><td></td><td>0.122</td><td>00.4%</td></tr><tr><td>PGD*</td><td>1</td><td>0.04</td><td>1</td><td>1</td><td>-</td><td>0.008</td><td>0%</td></tr><tr><td rowspan="3">Ensemble Div. [21]</td><td>PGD</td><td>1</td><td>0.76</td><td>=</td><td></td><td></td><td>0.152</td><td>38%</td></tr><tr><td>APGD</td><td>1</td><td>0.370</td><td>0.14</td><td></td><td></td><td>0.102</td><td>0%</td></tr><tr><td>PGD*</td><td>0.08</td><td>0.17</td><td>0.15</td><td>-</td><td>-</td><td>0.080</td><td>9 %</td></tr><tr><td rowspan="3">TWS [32]</td><td>PGD</td><td>-</td><td>0.49</td><td>0.07</td><td>1</td><td>0.37</td><td>0.186</td><td>35%</td></tr><tr><td>APGD</td><td>1</td><td>0.41</td><td>0.09</td><td></td><td>1</td><td>0.10</td><td>0%</td></tr><tr><td>PGD*</td><td>=</td><td>0.37</td><td>0.10</td><td>=</td><td>=</td><td>0.094</td><td>0%</td></tr></table>
+
+Table 1: Values of the Indicators of Attack Failures, computed for all the attacks against all the evaluated models. We denote the attacks that apply also the mitigations as $\mathrm { P G D ^ { \star } }$ .
+
+246 for detecting the presence of adversarial examples on top of an undefended model, measuring how   
+247 much the decision changes locally around a sample. Even if the authors also apply other rejection   
+248 mechanisms, we take into account only the described one, as we wish to show that attacks optimized   
+249 neglecting such term will trigger the non-adaptive attack failure $( F _ { 4 } )$ . We apply this defended on   
+250 a WideResNet model trained on CIFAR10, provided by RobustBench [14]. We attack this model   
+251 with $\ell _ { \infty }$ -PGD [17], with step size $\alpha = 0 . 1$ , maximum perturbation $\epsilon = 0 . 3$ for 50 iterations on 100   
+252 samples, and then we query the defended model with all the computed adversarial examples. While   
+253 the attacks works against the standard model, some of them are rejected by the defense, resulting   
+254 in a robust accuracy of $3 5 \%$ , highlighted by the trigger of the $I _ { 5 }$ indicator. In this case, we consider   
+255 an attack unsuccessful if the original sample is not misclassified and the adversarial point is either   
+256 belonging to the same class, or it is labeled as rejected.   
+257 Each of these attacks have been executed with 5 random restarts. We also attack all these models with   
+258 the version of AutoPGD (APGD) [13] that uses the difference of logit (DLR) as a loss to optimize.   
+259 This strategy will take care to automatically tune its hyperparameters while optimizing, reducing   
+260 possible errors that occur while deciding the values of step size, and iterations. Lastly, we compute   
+261 attacks that take into account all the mitigations we prescribed, and they will be analyzed further on   
+262 in the paper.
+
+Identifying failures. We want now to understand if our indicators are correlated with faults of the security evaluations of defenses. We collect the results of all the attacks against the selected targets, and we compute our indicators, by listing their values in Table 1, along with their mean score. With a glance, it is possible to grasp that out hypothesis is right: the detection of a failure is linked with higher values for the robust accuracy, and also the opposite. Each original evaluation is characterized by high values of one or more indicator, while the opposite happens for stronger attacks. For instance, APGD automatically tunes its hyperparameter while optimizing, hence it is able to apply some mitigations directly during the attack. To gain a quantitative evaluation of out hypothesis, we compute both the p-value and the correlation between the average score of the indicators and the robust accuracy, depicting this result in Fig. 5. Both p-value and correlation suggest a strong connection between these analyzed quantities, confirming our initial belief.
+
+![](images/40f88aa3e9ff8ef8fa182b6e26b8c0119d17034475be78670da1e05d15bfe319.jpg)  
+Figure 5: Evaluation of our metrics for different models. Robust accuracy vs. average value of the indicators, for the initial evaluation (denoted with $\ ' _ { 0 } '$ ), with the evaluation after-mitigation (denoted with ’ $\times \overrightarrow { }$ ), and with APGD (denoted with $\overrightarrow { } \star \overrightarrow { }$ )
+
+Mitigating failures. We can now use our indicators to improve the quality of the security evaluations, and we apply the following pipeline: (i) we test the defense with a set of points with the original attack strategy proposed by the author of the defense; (ii) we select the failure cases and inspect the
+
+<table><tr><td>Model</td><td>Initial</td><td>M1</td><td>M2</td><td>M3</td><td>M4</td><td>M5</td><td>Final</td></tr><tr><td>k-WTA [31]</td><td>58.2%</td><td>36.4%</td><td>36.4%</td><td>6.4%</td><td>6.4%</td><td>6.4%</td><td>6.4%</td></tr><tr><td>Distillation [22]</td><td>94.2%</td><td>94.2%</td><td>94.2%</td><td>94.2%</td><td>94.2%</td><td>0.4%</td><td>0.4%</td></tr><tr><td>Ensemble Diversity [21]</td><td>38.0%</td><td>38.0%</td><td>36.0%</td><td>36.0%</td><td>29.0%</td><td>9.0%</td><td>9.0%</td></tr><tr><td>TWS [32]</td><td>35.0%</td><td>35.0%</td><td>35.0%</td><td>35.0%</td><td>35.0%</td><td>0.0%</td><td>0.0%</td></tr></table>
+
+Table 2: Robust accuracies $\overline { { ( \% ) } }$ after patching the security evaluations with the prescribed mitigations.
+
+286 feedback of our indicators per-sample; (iii) for each cause of failure, we apply the specific remediation   
+287 suggested by the metric; and (iv) we show that the attack now succeeds, thus reducing the robust   
+288 accuracy of the target model, and also the values of the indicators.
+
+9 We report all the results of this process in Table 2, where each row shows the original robust accuracy, and how it is decreased, mitigation after mitigation. Also, all the individual values of each indicator computed on these patched attacks can be found in Table 1, marked as $\mathrm { P G D ^ { \star } }$ .
+
+Mitigating $k$ -WTA failures. For many failing attacks, the $I I$ indicator triggers, implying that the attack found an adversarial example inside the path. We then apply mitigation $M _ { I }$ , and we lower accordingly the robust accuracy of the model to $3 6 { , } 4 \%$ . We then analyze the feedback of the $I _ { 3 }$ indicator, the one that detects the presence of noisy gradients. We apply mitigation $M _ { 3 }$ , and we change the loss of the attack as described by Tramèr et al. [30]. This loss is computed by averaging the gradient of each single point of the attack path with the information of the surrounding ones. The resulting direction is then able to correctly descent toward a minimum. We run $\ell _ { \infty }$ -PGD with the same parameters, but smoothing the gradients by averaging 100 neighboring points from a normal distribution $\mathcal { N } ( \mu = \pmb { x } _ { i } , \sigma = 0 . 0 3 1 )$ , where $x _ { i }$ is a point in the attack path. After such mitigation, the robust accuracy drops to $6 , 4 \%$ , and so follows the indicator (Fig. 6a).
+
+302 Mitigating Distillation failures. All the attacks fail because of the absence of gradient information,   
+303 leading the attack to a bad local optimum $( F _ { 3 } )$ , and such is highlighted by the feedback of the $I _ { 3 }$   
+304 indicator. We apply mitigation $M _ { 3 }$ , and we change the loss optimized during the attack, following the   
+305 strategy applied by Carlini et al. [9], that computes the loss of the attack on the logit of the model   
+306 rather than the final softmax layer. We repeat the PGD attack with such fix, and the robust accuracy   
+307 drops to $0 \%$ , along with the indicator $I _ { 3 }$ (Fig. 6b).   
+308 Mitigating Ensemble diversity failures. Firstly, the $I _ { I }$ indicator highlighted the presence of $F _ { I }$ ,   
+309 implying that some failing attacks are due to the implementation itself. We apply mitigation $M _ { I }$ , and   
+310 the robust accuracy decreases to $36 \%$ . Also, $I _ { 2 }$ indicator is active, implying that the loss of of failing   
+311 attacks could be optimized more. For this reason, we apply mitigation $M _ { 2 }$ , and we increase the step   
+312 size to 0.05 and the iterations to 50. This patch is enough for lowering the robust accuracy to $9 \%$   
+313 (Fig. 6c).   
+314 Mitigating TWS failures. The detector is rejecting adversarial attacks successfully computed on the   
+315 undefended model, triggering the $I _ { 5 }$ indicator. Hence we apply mitigation $M _ { 5 }$ , and we adapt the attack   
+316 to consider also the rejection class. This version of PGD minimizes the usual loss function of the   
+317 attacker, but it also minimizes the score of the rejection class when encountered, allowing it to evade   
+318 the rejection. We run such attack, and we obtain a new robust accuracy of $0 \%$ (Fig. 6d).
+
+# 319 5 Related Work
+
+320 Other systematic analysis on robustness evaluations. There have been a number of prior papers   
+321 evaluating the robustness of particular defense schemes [10, 1, 30]. These papers focus on under  
+322 standing whether the robustness claims of particular defenses are true, often by performing one-off   
+323 attacks or by proposing new general attack approaches that can be used to break future defenses. In   
+324 contrast our goal is not to break any particular defense, but rather to help researchers understand   
+325 when their evaluation may have gone wrong. In this way our paper is related to Carlini et al. [12]   
+326 that systematizes various suggestions from the literature for how to ensure that adversarial robust  
+327 ness evaluations are performed thoroughly. We imagine that our tests could be included in future   
+328 recommendations for robustness evaluations.
+
+![](images/0d4ee15b4cc7ac30f4546d995c930ae7c165872eed98319cda18c9eb8c18c627.jpg)  
+Figure 6: The values of our indicators and the success rate (SR) of the attack, before (semi-transparent colored area) and after (solid colored area) fixing the failures, computed for the analyzed models.
+
+Benchmarks. Related to this work, there are a number of attack benchmarks that have been constructed. Instead of measuring the robustness of individual schemes as the prior papers do, these benchmarks aim to provide a complete evaluation framework that can be applied to any future defense as well. Ling et. al [16] proposed DEEPSEC, a benchmark that tests several attacks against a wide range of defenses. However, this framework was shown to be flawed by several implementation issues and problems in the configuration of the attacks [8]. Croce et al. [14] propose RobustBench [14], that accepts state-of-the-art models as submissions, and it tests their robust accuracy by applying AutoAttack [13]. However, this benchmark suite only works on CIFAR-trained models, and it is not able to determine which are the possible causes of such scored performance.
+
+338 Hence, these benchmark would benefit from our indicators, since they might provide useful insight   
+339 that can be autonomously computed. Here we imagine that our framework could be used to help   
+340 these tools automatically detect when their evaluations are incomplete, so that they could warn the   
+341 operator that there was a potential error that should be investigated.
+
+# 342 6 Contributions, Limitations and Future Work
+
+343 We propose the Indicators of Attack Failures (IoAF), quantitative tests that help the debugging of   
+344 faulty-conducted security evaluations, and we propose a pipeline for mitigating their issues, leading to   
+345 a fairer evaluation. We select defenses that have been previously shown to be weak against adversarial   
+346 attacks, and we evaluate them with the lens of our indicators, showing that we could have detected   
+347 their misconduct in advance. We empirically prove that these test are correlated with wrongly high   
+348 robust accuracy, while they drop when attacks are successful.   
+349 On top of these contributions, we acknowledge some limitations in our methodology. We do not   
+350 provide a fully-autonomous way for deciding how to turn an attack into its adaptive version against   
+351 a particular defense (e.g. gradient obfuscation), but we provide quantitative tools for helping the   
+352 decision among all the possible solutions that the attacker could come up with. Another limitation   
+353 lurks in the choice of the attack itself, since some unknown-and-adaptive attack could behave very   
+354 differently w.r.t. standard one, triggering some indicator in the process. However, these tests can be   
+355 patched accordingly to take care of these newly-proposed patched attacks, and still being used as   
+356 debugging tools. Lastly, as already discussed in Sect. 3, if the evaluated defense is not triggering any   
+357 indicators it does not imply it is secure, but rather it forces the application of other sanity checks [12].   
+358 We believe some part of this last process can be automatized with additional indicators, however we   
+359 leave this as a future work.   
+360 We hope that future work will include our indicators during the evaluation phase of new methods, in   
+361 order to identify when attacks are failing for known reasons, and thus contributing to the creation of   
+362 better defense mechanisms. Also, this work pose a preliminary step towards the creation of interactive   
+363 dashboards that can be inspected as a web application. Finally, it would be insightful to attach   
+364 our pipeline of indicators and mitigations to already-available benchmarks (i.e. RobustBench [14]),   
+365 possibly detecting other failures in security evaluations we did not covered in our experiments.
+
+References [1] A. Athalye, N. Carlini, and D. A. Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In ICML, volume 80 of JMLR Workshop and Conference Proceedings, pages 274–283. JMLR.org, 2018. [2] M. Barreno, B. Nelson, A. Joseph, and J. Tygar. The security of machine learning. Machine Learning, 81:121–148, 2010. [3] B. Biggio and F. Roli. Wild patterns: Ten years after the rise of adversarial machine learning. Pattern Recognition, 84:317–331, 2018. [4] B. Biggio, I. Corona, D. Maiorca, B. Nelson, N. Šrndic, P. Laskov, G. Giacinto, and F. Roli. ´ Evasion attacks against machine learning at test time. In H. Blockeel, K. Kersting, S. Nijssen, and F. Železný, editors, Machine Learning and Knowledge Discovery in Databases (ECML PKDD), Part III, volume 8190 of LNCS, pages 387–402. Springer Berlin Heidelberg, 2013. [5] B. Biggio, G. Fumera, and F. Roli. Security evaluation of pattern classifiers under attack. IEEE Transactions on Knowledge and Data Engineering, 26(4):984–996, April 2014. ISSN 1041-4347. [6] W. Brendel, J. Rauber, M. Kümmerer, I. Ustyuzhaninov, and M. Bethge. Accurate, reliable and fast robustness evaluation, 2019. [7] J. Buckman, A. Roy, C. Raffel, and I. Goodfellow. Thermometer encoding: One hot way to resist adversarial examples. In International Conference on Learning Representations, 2018. [8] N. Carlini. A critique of the deepsec platform for security analysis of deep learning models, 2019. [9] N. Carlini and D. Wagner. Defensive distillation is not robust to adversarial examples, 2016. [10] N. Carlini and D. A. Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. In B. M. Thuraisingham, B. Biggio, D. M. Freeman, B. Miller, and A. Sinha, editors, 10th ACM Workshop on Artificial Intelligence and Security, AISec ’17, pages 3–14, New York, NY, USA, 2017. ACM.   
+392 [11] N. Carlini and D. A. Wagner. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy, pages 39–57. IEEE Computer Society, 2017.   
+394 [12] N. Carlini, A. Athalye, N. Papernot, W. Brendel, J. Rauber, D. Tsipras, I. Goodfellow, A. Madry, and A. Kurakin. On evaluating adversarial robustness, 2019.   
+396 [13] F. Croce and M. Hein. Reliable evaluation of adversarial robustness with an ensemble of diverse parameter-free attacks. In ICML, 2020.   
+398 [14] F. Croce, M. Andriushchenko, V. Sehwag, N. Flammarion, M. Chiang, P. Mittal, and M. Hein. Robustbench: a standardized adversarial robustness benchmark. arXiv preprint arXiv:2010.09670, 2020.   
+401 [15] S. G. Finlayson, J. D. Bowers, J. Ito, J. L. Zittrain, A. L. Beam, and I. S. Kohane. Adversarial attacks on medical machine learning. Science, 363(6433):1287–1289, 2019.   
+403 [16] X. Ling, S. Ji, J. Zou, J. Wang, C. Wu, B. Li, and T. Wang. Deepsec: A uniform platform for security analysis of deep learning model. In 2019 IEEE Symposium on Security and Privacy $( S P )$ , pages 673–690, 2019. doi: 10.1109/SP.2019.00023.   
+406 [17] A. Madry, A. Makelov, L. Schmidt, D. Tsipras, and A. Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.   
+408 [18] A. McCallum and K. Nigam. A comparison of event models for naive bayes text classification. In Proc. AAAI Workshop on learning for text categorization, pages 41–48, 1998.   
+410 [19] P. McDaniel, N. Papernot, and Z. B. Celik. Machine learning in adversarial settings. IEEE Security & Privacy, 14(3):68–72, May 2016.
+
+[20] M. Melis, A. Demontis, M. Pintor, A. Sotgiu, and B. Biggio. secml: A python library for secure and explainable machine learning. arXiv preprint arXiv:1912.10013, 2019. [21] T. Pang, K. Xu, C. Du, N. Chen, and J. Zhu. Improving adversarial robustness via promoting ensemble diversity. In K. Chaudhuri and R. Salakhutdinov, editors, Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pages 4970–4979. PMLR, 09–15 Jun 2019. URL http://proceedings.mlr. press/v97/pang19a.html. [22] N. Papernot, P. McDaniel, X. Wu, S. Jha, and A. Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In 2016 IEEE Symposium on Security and Privacy (SP), pages 582–597, May 2016. doi: 10.1109/SP.2016.41. [23] M. Pintor, F. Roli, W. Brendel, and B. Biggio. Fast minimum-norm adversarial attacks through adaptive norm constraints, 2021. [24] J. Rony, L. G. Hafemann, L. S. Oliveira, I. B. Ayed, R. Sabourin, and E. Granger. Decoupling direction and norm for efficient gradient-based l2 adversarial attacks and defenses, 2019. [25] K. Roth, Y. Kilcher, and T. Hofmann. The odds are odd: A statistical test for detecting adversarial examples. In International Conference on Machine Learning, pages 5498–5507. PMLR, 2019. [26] B. I. Rubinstein, B. Nelson, L. Huang, A. D. Joseph, S.-h. Lau, S. Rao, N. Taft, and J. D. Tygar. Antidote: understanding and defending against poisoning of anomaly detectors. In Proceedings of the 9th ACM SIGCOMM Internet Measurement Conference, IMC ’09, pages 1–14, New York, NY, USA, 2009. ACM. [27] M. Sahami, S. Dumais, D. Heckerman, and E. Horvitz. A bayesian approach to filtering junk e-mail. AAAI Technical Report WS-98-05, Madison, Wisconsin, 1998. [28] C. Smutz and A. Stavrou. Malicious pdf detection using metadata and structural features. In Proceedings of the 28th Annual Computer Security Applications Conference, ACSAC ’12, pages 239–248, New York, NY, USA, 2012. ACM. [29] C. Szegedy, W. Zaremba, I. Sutskever, J. Bruna, D. Erhan, I. Goodfellow, and R. Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations, 2014. URL http://arxiv.org/abs/1312.6199. [30] F. Tramer, N. Carlini, W. Brendel, and A. Madry. On adaptive attacks to adversarial example defenses. Advances in Neural Information Processing Systems, 33, 2020. [31] C. Xiao, P. Zhong, and C. Zheng. Resisting adversarial attacks by $k$ -winners-take-all. 2020. [32] T. Yu, S. Hu, C. Guo, W. Chao, and K. Weinberger. A new defense against adversarial images: Turning a weakness into a strength. In Proceedings of the 33rd Conference on Neural Information Processing Systems (NeurIPS 2019), Oct. 2019. 47 [33] X. Yuan, P. He, Q. Zhu, and X. Li. Adversarial examples: Attacks and defenses for deep learning. IEEE Transactions on Neural Networks and Learning Systems, 30(9):2805–2824, 2019. doi: 10.1109/TNNLS.2018.2886017.
+
+# Checklist
+
+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] We discuss the limitations in Sect. 6   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] In Sect. 6, we specified that the aim of our work is not to break defenses in an harmful way. Our purpose is only to help researchers to improve their security evaluation.
+
+(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 will be submitted as supplementary material, and the instructions for reproducing the experiments are described in Sect. 4   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We describe the experimental protocol in Sect. 4   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   
+(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] The resourced used for the experiments are listed in Sect. 4
+
+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 cited all the existing assets used for the experiments.   
+(b) Did you mention the license of the assets? [Yes] We cited the authors of the assets, and we provide the list of external assets along with the code.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We provide the code for computing the metrics as supplementary material.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] All the assets we used are publicly available.   
+(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]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/JdQ2-DTaGF/JdQ2-DTaGF_content_list.json

@@ -0,0 +1,1050 @@
+[
+    {
+        "type": "text",
+        "text": "Indicators of Attack Failure: Debugging and Improving Optimization of Adversarial Examples ",
+        "text_level": 1,
+        "bbox": [
+            197,
+            122,
+            800,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Evaluating robustness of machine-learning models to adversarial examples is a   \n2 challenging problem. Many defenses have been shown to provide a false sense of   \n3 security by causing gradient-based attacks to fail, and they have been broken under   \n4 more rigorous evaluations. Although guidelines and best practices have been sug  \n5 gested to improve current adversarial robustness evaluations, the lack of automatic   \n6 testing and debugging tools makes it difficult to apply these recommendations in   \n7 a systematic manner. In this work, we overcome these limitations by (i) defining   \n8 a set of quantitative indicators which unveil common failures in the optimization   \n9 of gradient-based attacks, and (ii) proposing specific mitigation strategies within   \n10 a systematic evaluation protocol. Our extensive experimental analysis shows that   \n11 the proposed indicators of failure can be used to visualize, debug and improve   \n12 current adversarial robustness evaluations, providing a first concrete step towards   \n13 automatizing and systematizing current adversarial robustness evaluations. ",
+        "bbox": [
+            148,
+            348,
+            766,
+            529
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "14 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            553,
+            312,
+            570
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "15 Neural networks are now deployed in settings where it is important that they behave reliably and   \n16 robustly [19, 15, 33, 3]. Unfortunately, these systems are vulnerable to adversarial examples [29, 4],   \n17 i.e., inputs intentionally crafted to mislead machine-learning classifiers at test time. These attacks   \n18 are especially important in settings where classifiers have security-critical consequences, including   \n19 autonomous driving, automated medical diagnoses, and cybersecurity-related tasks such as spam and   \n20 malware detection, web-page ranking and network protocol verification [27, 18, 26, 2, 28, 15].   \n21 This vulnerability has caused a strong reaction from the community, with many proposed defenses [33,   \n22 22, 31, 25]. Early defenses often argued robustness by showing the defense could prevent prior   \n23 attacks, but not attacks tailored to that particular defense. As a result, most of these defenses have   \n24 turned out to only provide a false sense of security, i.e., to be broken when targeted by an adaptive   \n25 attack that tailors the attack strategy to the particular defense [11, 1]. More recent work has tried to   \n26 evaluate using such adaptive attacks. Unfortunately, even this has proven difficult; recent work has   \n27 shown that 13 published defenses proposed in the last year are ineffective despite almost all of them   \n28 containing an analysis to adaptive attacks [30].   \n29 The reason why adversarial example defense evaluations are incomplete comes down to the difficulty   \n30 of performing an adaptive attack, and diagnosing when they go wrong. Adversarial examples are   \n31 typically generated through gradient descent: the adversary first constructs a loss function so that a   \n32 minimum for that function is an adversarial example. While gradient-based attacks are highly effective   \n33 at finding adversarial examples on undefended classifiers with smooth loss functions, many defenses   \n34 substantially hinder the attack optimization by obfuscating gradients or by exhibiting harder-to  \n35 optimize loss functions. In particular, most attempted defenses to adversarial examples only succeed   \n36 at increasing the difficulty of solving the minimization formulation, and not at actually increasing the ",
+        "bbox": [
+            147,
+            584,
+            825,
+            667
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            674,
+            825,
+            785
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            791,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Input : $_ { \\textbf { \\em x } }$ , the initial point; $y$ , the true class of the initial point; $n$ , the number of iterations; $\\alpha$ , the learning rate; $f$ , the target model; $\\Delta$ , the considered region. Output : $\\scriptstyle { \\pmb x } ^ { \\star }$ , the solution found by the algorithm 1 $\\mathbf { \\boldsymbol { x } } _ { 0 } \\gets$ initialize $( { \\pmb x } )$ $\\triangleright$ Initialize starting point 2 $\\hat { \\pmb { \\theta } } \\gets$ approximation(θ) . Approximate model parameters 3 $\\delta _ { 0 }  \\mathbf { 0 }$ . Initial δ 4 for $i \\in [ 1 , n ]$ do 5 $\\pmb { \\delta } ^ { \\prime }  \\pmb { \\delta } _ { i } - \\alpha \\nabla _ { \\pmb { x } _ { i } } L ( \\pmb { x } _ { 0 } + \\pmb { \\delta } _ { i } , y ; \\hat { \\pmb { \\theta } } )$ . Compute optimizer step 6 δi+1 ← apply-constraints(x0, δ0, ∆) . Apply constraints (if needed) 7 $\\delta ^ { \\star } \\gets \\mathsf { b e s t } ( \\delta _ { 0 } , . . . , \\delta _ { n } )$ . Choose best perturbation 8 return δ? ",
+        "bbox": [
+            160,
+            111,
+            815,
+            284
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "37 robustness of the underlying classifier (i.e., increasing the actual distance of the decision boundary   \n38 from the input sample) [10, 11, 1, 30]. Moreover, even though guidelines and best practices have   \n39 been suggested to improve current adversarial robustness evaluations, the lack of automatic testing   \n40 and debugging tools makes it difficult to apply these recommendations in a systematic manner. These   \n41 difficulties have perpetuated a constant cat-and-mouse game where defenders propose new schemes,   \n42 and attackers find that actually the defense was only increasing the difficulty of solving the underlying   \n43 minimization problem [5, 3].   \n44 This paper directly addresses these limitations by (i) developing quantitative indicators of failure,   \n45 i.e., metrics designed to help debug optimization of gradient-based attacks for generating adversarial   \n46 examples, and (ii) suggesting a systematic evaluation protocol to improve current robustness eval  \n47 uations by applying a sequence of specific mitigation strategies. In four case studies of published   \n48 defenses that have been shown to be ineffective against stronger adaptive attacks, we show (i) that   \n49 our indicators would have highlighted different failure modes in the original evaluations, and (ii) how   \n50 these failures could have been easily overcome by following our suggested mitigation strategies.   \n51 To summarize, we make the following contributions: (i) we introduce a unified attack framework   \n52 that captures the predominant styles of existing gradient-based attack methods, and allows us to   \n53 categorize the five main causes of failure that may arise during their optimization (Sect. 2); (ii) we   \n54 propose five indicators of attack failures (IoAF), i.e., metrics and principles that help understand why   \n55 and when gradient-based attack algorithms fail (Sect. 3); (iii) we empirically evaluate the utility of   \n56 our metrics on four recently-published defenses, showing how their robustness evaluations could   \n57 have been improved by monitoring the IoAF values and following our evaluation protocol (Sect. 4;   \n58 and (iv) we provide open-source code and data we used in this paper for reproducing resources. Our   \n59 code is available at https://github.com/ioaf-todo. 1 We conclude by discussing related work   \n60 (Sect. 5), along with the limitations of our work and future research directions (Sect. 6). ",
+        "bbox": [
+            147,
+            310,
+            825,
+            407
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            412,
+            825,
+            511
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            517,
+            825,
+            655
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "61 2 Adversarial Robustness: Gradient-based Attacks and Failures ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            672,
+            725,
+            690
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "62 We argue here that optimizing adversarial examples amounts to solving a multi-objective optimization: ",
+        "bbox": [
+            156,
+            704,
+            823,
+            719
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c210f542574a97a1c591aa55d96afab59370571aea843c8733c9e26bf6ecb20.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\delta \\in \\Delta } \\left( L ( \\boldsymbol { x } + \\delta , \\boldsymbol { y } ; \\boldsymbol { \\theta } ) , \\lVert \\delta \\rVert _ { p } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            722,
+            578,
+            746
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 where $\\pmb { x } \\in [ 0 , 1 ] ^ { d }$ is the input sample, $y \\in \\{ 1 , \\ldots , c \\}$ is either its label (for untargeted attacks) or   \n64 the label of the target class (for targeted attacks), and $\\delta \\in \\Delta$ is the perturbation optimized to have   \n65 the perturbed sample ${ \\pmb x } ^ { \\prime } = { \\pmb x } + { \\pmb \\delta }$ misclassified as desired, within the given input domain. The   \n66 target model is parameterized by $\\pmb \\theta$ . The given problem presents an inherent tradeoff: minimizing $L$   \namounts to finding an adversarial example with large misclassification confidence and perturbation   \n68 size, while minimizing $\\| \\delta \\| _ { p }$ penalizes larger perturbations (in the given $\\ell _ { p }$ norm) at the expense of   \n69 decreasing misclassification confidence.2 Typically the attacker loss $L$ is defined as the Cross-Entropy   \n70 (CE) loss, or the logit difference [11].   \n71 Multiobjective problems can be solved by establishing a different tradeoff between the given objectives   \n72 along the Pareto frontier, by either using soft- or hard-constraint reformulations. For example, Carlini  \n73 Wagner (CW) [11] is a soft-constraint attack, which reformulates the aforementioned multiobjective   \n74 problem as an unconstrained optimization: mi ${ \\bf \\psi } _ { 1 } \\| \\delta \\| _ { p } + c \\cdot \\operatorname* { m i n } ( L ( { \\pmb x } + \\delta , { \\pmb y } , { \\pmb \\theta } ) , - \\kappa )$ , where the   \n75 hyperparameters $\\kappa$ and $c$ tune the trade-off between misclassification confidence and perturbation   \n76 size. Hard-constraint reformulations instead aim to minimize one objective while constraining the   \n77 other. They include maximum-confidence attacks like Projected Gradient Descent (PGD) [17], which   \n78 is formulated as $\\begin{array} { r l } {  { \\operatorname* { m i n } _ { \\delta } L \\big ( \\pmb { x } + \\delta , \\pmb { y } ; \\pmb { \\theta } \\big ) } \\quad } & { { } } \\end{array}$ s.t. $\\| \\delta \\| _ { p } \\leq \\epsilon$ , and minimum-norm attacks like Brendel-Bethge   \n79 (BB) [6] and Decoupling-Direction-Norm (DDN) [24], which can be formulated as minδ $\\| \\delta \\| _ { p }$ s.t.   \n80 $L ( x + \\delta , y ; \\pmb \\theta ) \\le k$ . In these cases, $\\epsilon$ and $k$ upper bound the perturbation size and the misclassification   \n81 confidence, respectively, thereby optimizing a different tradeoff between these two quantities.   \n82 The aforementioned attacks often need to use an approximation $\\hat { \\pmb { \\theta } }$ of the target model, since the latter   \n83 may be either non-differentiable, or not sufficiently smooth [1], hindering the gradient-based attack   \n84 optimization process. In this case, once the attacker loss has been optimized on the surrogate model   \n85 $\\hat { \\pmb { \\theta } }$ , the attack is considered successful if it evades the target model $\\pmb \\theta$ .   \n86 Attack Algorithm. According to the previous discussion, even if different attacks minimize different   \n87 objectives or require different constraints, all of them can be seen as solutions to a common multiob  \n88 jective problem, based on gradient descent. Thus, their main steps can be summarized as detailed in   \n89 Algorithm 1. First, an initialization point (line 1) needs to be set, and this can be achieved by directly   \n90 using the input point $_ { \\textbf { \\em x } }$ , a randomly-perturbed version of it, or even a sample from the target class [6].   \n91 Then, if the target model $\\pmb { \\theta }$ is difficult to deal with, or it is non-differentiable, the attacker must chose   \n92 a surrogate model $\\hat { \\pmb { \\theta } }$ that approximates the real target $\\pmb \\theta$ (line 2). The attack then iteratively updates   \n93 the initial point searching for a better and better adversarial example (line 4), computing in each   \n94 iteration one (or more) gradient descent steps (line 5) using the initial point and the perturbation $\\delta _ { i }$   \n95 computed so far. Hence, the new perturbation $\\delta _ { i + 1 }$ is obtained by enforcing the constraints defined in   \n96 the problem (line 6), that can be updated accordingly to the chosen strategy [23, 24]. For maximum   \n97 confidence approaches, the attack can not exit the $\\Delta$ region, and samples are projected accordingly on   \n98 this ball when reaching the constraints. Similarly, we consider minimum distance attacks successful   \n99 only if they found adversarial examples inside the $\\Delta$ region. At the end of the iterations, the attacker   \n100 has collected all the perturbations along the iterations, formalized as the attack path. The final result   \n101 of the algorithm is the the best perturbation contained in the attack path, w.r.t. the loss they are   \n102 minimizing (line 7). ",
+        "bbox": [
+            155,
+            748,
+            825,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/8841d529fd55e6ac7ccd4b8c563e1264bc4f269eabd05b338d3bd9c198e225ab.jpg",
+        "image_caption": [
+            "Figure 1: The four attack failures that can be encountered during the optimization of an attack. The failed attack path is shown in gray, while the successful attack is displayed in black. The point $\\scriptstyle { \\mathbf { { \\mathit { x } } } } _ { 0 }$ is marked with the red dot, the returned point of the failed attack with a red cross, and the successful adversarial point with the green star. The top row shows the loss landscape, as $L ( { \\pmb x } + a { \\pmb v } _ { 1 } + b { \\pmb v } _ { 2 } , y _ { i } ; { \\pmb \\theta } )$ . ${ \\pmb v } _ { 1 }$ is the normalized direction $\\left( \\pmb { x } _ { n } - \\pmb { x } _ { 0 } \\right)$ , while $\\mathbf { \\boldsymbol { v } } _ { 2 }$ is a representative direction for the displayed case. In the second row we show the value of $L ( x + \\delta _ { i } , y _ { i } ; \\pmb { \\theta } )$ for the evaluated model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            94,
+            807,
+            310
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            449,
+            825,
+            602
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            609,
+            825,
+            667
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            674,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/42ce9a9a02498671eddc3a98f7835190352139579142f0e330db6a260351eb0e.jpg",
+        "image_caption": [
+            "Figure 2: Indicators of Attack Failures. The top row lists the four general failures encountered in gradient-based attacks. The second row lists the Indicators of Attack failures we propose, and the last row depicts possible mitigations that can be applied. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            89,
+            820,
+            266
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "103 2.1 Attack failures ",
+        "text_level": 1,
+        "bbox": [
+            145,
+            347,
+            316,
+            361
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "04 We can now isolate four failures that can be encountered while optimizing adversarial attacks using   \n05 Algorithm 1, and we bound each of them to specific steps of such procedure. ",
+        "bbox": [
+            155,
+            373,
+            826,
+            401
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$F _ { I }$ : Implementation Problems. If no adversarial examples are found by the attack, it might be possible that the used implementation include errors or bugs. For example, we isolated a bug inside the procedure proposed by Madry et al. [17]. The attack as described returns the adversarial example only by looking at the last point of the attack path (line 7 of Algorithm 2), as shown in Fig. 1a, but would not return an adversarial example if one was found during search and then passed over. ",
+        "bbox": [
+            171,
+            407,
+            823,
+            477
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "11 $F _ { 2 }$ : Non-converging attack. When performing gradient descent based attacks, a common problem   \n12 is that attacks do not converge to any local minimum, as shown in Fig. 1b. This problem can be   \n13 caused by either the setup of the attack, and in Algorithm 1, this is reflected on the values of $\\alpha$ and $n$   \n14 i.e. the step size of the attack, and the number of iterations. If $\\alpha$ is too small, the gradient update step   \n15 is not exploring the space (line 5 of Algorithm 1), while using too few iterations $n$ might cause an   \n16 early stopping of the attack (line 4 of Algorithm 1). An example of this failure can be found in the   \n17 evaluation of the defense proposed by Buckman et al. [7], where the authors only used 7 steps of   \n18 PGD for testing the robustness of their defense, or by the one proposed by Pang et al. [21], where   \n19 the defense has been evaluated with only 10 steps of PGD. Also, this failure might be triggered   \n20 either by a too-large step size, that lead the optimizer to keep overshooting the local minimum, or   \n21 the presence of gradient obfuscation techniques [31] that alter the gradients of the model to point to   \n22 random directions, leading the descent to fail.   \n23 $F _ { 3 }$ : Bad local optimum. Once the attack reached convergence, the computed point might not be   \n24 adversarial, since the optimizer has reached a region where it can not update anymore the adversarial   \n25 perturbation, as shown in Fig. 1c. There are few reasons that might lead to such failure. One of them   \n26 is again caused by the presence of gradient obfuscation, where the optimizer is unable to continue the   \n27 descent, since it arrived in a region where the norms of gradients are (nearly) zero (i.e. flat regions),   \n28 or again because the gradients are noisy, and the optimization lands on a bad local optimum (line 5   \n29 of Algorithm 1). An example of such failure is detected inside the defense proposed by Papernot   \n30 et al. [22], where the model is trained to have signal in correspondence of samples, and producing   \n31 regions with no gradient all around them. Another reason might be triggered by the choice of the   \n32 initialization point itself (line 1 of Algorithm 1), that leads the optimizer into a region where no   \n33 adversarial examples can be found. The latter has been detected by the analysis conducted by Tramèr   \n34 et al. [30] against the defense proposed by Pang et al. [21], where a different initialization point lead   \n35 the attack to find a better solution.   \n36 $F _ { 4 }$ : Non-adaptive attack. The loss function that the attacker optimizes does not match the actual loss   \n37 of the target system, and this is caused by a bad choice of the surrogate model (line 2 of Algorithm 1),   \n38 as shown in Fig. 1d. This issue manifests when either the attack is computed on an undefended   \n39 model, and later tested against the defense, or the target model is not differentiable and the surrogate   \n40 is not really approximating it. Since we consider both cases, we differ from the literature, where the   \n141 term non-adaptive has been used only for attacks that were not specifically designed to target a given   \n142 defense [30]. An examples of this failure is found in the defense proposed by Yu et al. [32], where the   \n143 attack has been computed against the undefended model, and then evaluated against the defense later.   \n144 To maximize the likelihood of creating successful attacks and hence avoiding such failures, current   \n145 recommendations [30] suggest to (i) select the strongest attacks against the model that is being tested;   \n146 (ii) state the precise threat model being considered; (iii) select the correct hyperparameters for the   \n147 attack being used; and (iv) compute charts to understand how the attacks behave by varying the size   \n148 of the perturbation. Indeed useful, such are only qualitative recommendations that require ad-hoc   \n149 inspection of each failed attack. ",
+        "bbox": [
+            150,
+            483,
+            825,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            656,
+            825,
+            835
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            92,
+            825,
+            133
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            138,
+            825,
+            223
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "150 3 Indicators of Attack Failure ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            265,
+            437,
+            281
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "151 In this section we describe our Indicators of Attack Failures, i.e. tests that help an analyst debug a   \n152 failing attack. Each of these tests outputs a value bounded between 0 and 1, where values towards 1   \n153 implies the presence of the failure described by the test. Informed by the results of the indicators,   \n154 we propose potential mitigations that can resolve the presence of the detected failure. An overview   \n155 of such approach can be appreciated in Fig. 2, where we connect failures with the indicators that   \n156 quantify them, along with possible mitigations.   \n157 $I _ { I }$ : Silent Success. This indicator is designed as a binary flag that   \n158 triggers when the attack is failing, but a legitimate adversarial exam  \n159 ple is found inside the attack path, as described by the implementa  \n160 tion problem failure $( F _ { I } )$ .   \n161 $I _ { 2 }$ : Break-point angle. This indicator is designed to quantify the   \n162 non-convergence of the attack $( F _ { 2 } )$ caused by the choice of too small   \n163 hyperparameters. We normalize the loss along the attack path and   \n164 the iteration, to fit the loss in the domain $[ 0 , 1 ] \\times [ 0 , 1 ]$ , and, ideally, a   \n165 well-converged loss should approximate a triangle in that domain, as   \n166 shown in Fig. 3. To create that triangle, we connect the first and the   \n167 last point in the loss curve, and we conclude the shape by considering   \n168 the point of the loss curve that is further to such conjunction. We are   \n169 interested in the amplitude of the basis $\\beta$ angle, since it is the one   \n170 that characterizes the shape of the triangle: when $\\beta \\approx \\pi$ , the triangle is flat, implying that the loss is   \n171 still decreasing. For this reason, the indicator computes $1 - | c o s \\beta |$ , matching such intended behavior.   \n172 On the other hand, this indicator is close to 0 when the triangle is close to be right, hence $\\beta \\approx \\frac { \\pi } { 2 }$ .   \n173 $I _ { 3 }$ : Increasing loss. This indicator is designed to quantify either the   \n174 non-convergence of the attack $( F _ { 2 } )$ p, or the inability of converging   \n175 to a good local optimum $( F _ { 3 } )$ 1, both caused by the presence of noisy   \n176 gradients, where the loss of the attack is increasing while optimizing.   \n177 To characterize such behavior, we normalize the loss of the attack   \n178 and the iterations as we did in $I _ { 2 }$ , and we extract from it only the   \n179 portions where it increases, and we compute its area, as shown in   \n180 βFig. 4. When this indicator is close to 1, the values of the loss are   \n181 pp3fluctuating around its maximum value, difficult to be decreased by   \n182 the optimizer. ",
+        "bbox": [
+            140,
+            309,
+            825,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            398,
+            616,
+            455
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            462,
+            614,
+            585
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/6f7704ee1baf89a3a6bdd31160d349635bab6ed45706f8adc62cde14c4bbc380.jpg",
+        "image_caption": [
+            "Figure 3: $I _ { 2 }$ indicator. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            633,
+            420,
+            820,
+            540
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            585,
+            823,
+            627
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            632,
+            614,
+            772
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/3fe340e2e78952e0f7ed896a8dd07272dfa35f3706c1f9c19020b45f089c22e1.jpg",
+        "image_caption": [
+            "Figure 4: $I _ { 3 }$ indicator. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            630,
+            655,
+            821,
+            779
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$I _ { 4 }$ : Zero gradients. This indicator is designed to quantify the bad-local optimum failure $( F _ { 3 } )$ , caused by the absence of gradient information. For this reason, we compute how many times, along the attack path, the gradients of the loss function are zero: ",
+        "bbox": [
+            163,
+            779,
+            616,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\begin{array} { r } { \\frac { 1 } { n + 1 } \\sum _ { i = 0 } ^ { n } \\mathbb { 1 } _ { \\| \\nabla _ { \\pmb { x } + \\delta _ { i } } L \\| = 0 } } \\end{array}$ . This indicator is close to 1 when most of the norms of the gradient are 0, causing the attack step to fail. ",
+        "bbox": [
+            166,
+            834,
+            826,
+            863
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "189 $I _ { 5 }$ : Non-transferability. This indicator is designed to quantify the non-adaptive failure $( F _ { 4 } )$ , by   \n190 measuring if the optimized attack fails against the real target model, while succeeding against the   \n191 surrogate one. If the attack transfers successfully, the indicator is set to 0, otherwise it is set to 1. ",
+        "bbox": [
+            145,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "192 3.1 Mitigate the Failures of Security Evaluations ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            92,
+            524,
+            106
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "93 Once the robust accuracy of a model has been computed, the attacker should now check the feedback   \n94 of the indicators and mitigate accordingly the detected failures.   \n5 $M _ { I }$ : Fix the implementation. If $I _ { I }$ is active, the attack is considered failed, but there exists an   \n96 adversarial point inside the computed path that satisfies the attack objective. Hence, the resulting   \n7 robust accuracy must be lowered to reflect this patch accordingly. Also, the attacker would want to   \n98 run again their evaluations using another library, or a patched version of the same attack. ",
+        "bbox": [
+            156,
+            117,
+            825,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            153,
+            152,
+            825,
+            207
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$M _ { 2 }$ : Tune the hyperparameters. If $I _ { 2 }$ activates, it means that the optimization can be improved, and hence both the step size and iteration hyperparameters can be increased. Otherwise, if $I _ { 3 }$ activates, the attack should consider a smaller step size, since the loss might be overshooting local minima. ",
+        "bbox": [
+            160,
+            208,
+            823,
+            250
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "202 $M _ { 3 }$ : Use a different loss function. If $I _ { 3 }$ activates, and the decrement of the step size did not work,   \n203 the attack should change the loss to be optimized [30], preferring one that has a smoother behavior. If   \n204 $I _ { 4 }$ activates, the attack should consider loss functions that do not saturate (e.g. avoid the softmax) [9],   \n205 or also increase the step size of the attack to avoid regions with zero gradients. ",
+        "bbox": [
+            147,
+            250,
+            826,
+            304
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$M _ { 4 }$ : Consider different restarts for the attack. If $I _ { 3 }$ or $I _ { 4 }$ activates, the attack might also consider to repeat the experiments with more initialization points and restarts, as the failure could be the result of added randomness or an unlucky initialization. ",
+        "bbox": [
+            163,
+            304,
+            821,
+            345
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "209 $M _ { 5 }$ : Perform adaptive attacks. Lastly, if none of the above applied, the attack might be optimizing   \n210 against a bad surrogate model. If $I _ { 5 }$ is active, the attack should be repeated by changing the surrogate   \n211 to better approximate the target, or include the defense inside the attack itself [30]. This step implies   \n212 repeating the evaluation, as the change of the surrogate might trigger other previously-fixed failures.   \n213 When attacks fail even after the application of recommended mitigations, it would be easy to assume   \n214 that the evaluated defense is strong against adversarial attacks. However, the only thing known is   \n215 that baseline attacks, properly tested, are not working against the defense. Hence, the designer of the   \n216 defense should try as hard as possible to break the proposed defense with further investigations [12],   \n217 and by performing sanity checks, e.g., ensuring that the robust accuracy drops to $0 \\%$ when the   \n218 perturbation size is unbounded, or by trying different attack strategies, e.g., using gradient-free   \n219 attacks or attacks designed by reversing the defense mechanism. ",
+        "bbox": [
+            142,
+            345,
+            825,
+            401
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            406,
+            825,
+            503
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            526,
+            312,
+            542
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We now exhibit the results of our experiments, by showing the correlation between the feedback of our indicators, and the false sense of security given by badly-evaluated defenses. ",
+        "bbox": [
+            166,
+            559,
+            823,
+            588
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "223 Experimental setup. We run our attacks on an Intel\rR $\\mathbf { X e o n } ^ { \\textregistered }$ CPU E5-2670 v3, with 48 cores, 126   \n224 GB of RAM, and equipped with an Nvidia Quadro M6000 with $2 4 \\mathrm { G B }$ of memory. All the attacks   \n225 and models have been wrapped and run by using the SecML library [20]. We select four defenses that   \n226 have been reported as failing, and we show that our indicators would have detected such evaluation   \n227 errors. For each of them, we set the hyperparameters for the attack as done in the original evaluation,   \n228 in order to collect similar results.   \n229 $k$ -Winners-Take-All $( k W T A )$ , the defense proposed by Xiao et al. [31] uses only the top- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ outputs   \n230 from each layer, generating many discontinuities in the loss landscape, and hence resulting in the   \n231 non-converging failure due to noisy gradients $( F _ { 2 } )$ . We use the implementation provided by Tramèr   \n232 et al. [30], trained on CIFAR10, and we test its robustness by attacking it with $\\ell _ { \\infty }$ -PGD [17] with a   \n233 step size of $\\alpha = 0 . 0 0 3$ , maximum perturbation $\\epsilon = 8 / 2 5 5$ and 50 iterations, with 5 restarts for each   \n234 attack, scoring a robust accuracy of $58 \\%$ on 100 samples.   \n235 Distillation, the defense proposed by Papernot et al. [22], works by training a model to have zero   \n236 gradients around the training points, leading gradient-based attacks towards bad local optimum $( F _ { 3 } )$ .   \n237 We re-implemented such defense, by training a distilled classifier on the MNIST dataset to mimic the   \n238 original evaluation. Then, we apply $\\ell _ { \\infty }$ -PGD [17], with step size $\\alpha = 0 . 0 1$ , maximum perturbation   \n239 $\\epsilon = 0 . 3$ for 50 iterations on 100 samples, resulting in a robust accuracy of ${ 9 4 , 2 \\% }$ .   \n240 Ensemble diversity, the defense proposed by Pang et al. [21] is composed with different neural   \n241 networks, trained with a regularizer that encourages diversity. We adopt the implementation provided   \n242 by Tramèr et al. [30]. Then, following its original evaluation, we apply $\\ell _ { \\infty }$ -PGD [17], with step size   \n243 $\\alpha = 0 . 0 0 1$ , maximum perturbation $\\epsilon = 0 . 0 1$ for 10 iterations on 100 samples, resulting in a robust   \n244 accuracy of $38 \\%$ . ",
+        "bbox": [
+            147,
+            593,
+            825,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            676,
+            825,
+            760
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            760,
+            826,
+            828
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            829,
+            825,
+            898
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "245 Turning a Weakness into a Strenght (TWS), the defense proposed by Yu et al. [32], applies a mechanism ",
+        "bbox": [
+            140,
+            897,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/006229905dd85d92f58aa7475901eb2d831ef2770caa646b047452cbc626d083.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Values of the Indicators of Attack Failures, computed for all the attacks against all the evaluated models. We denote the attacks that apply also the mitigations as $\\mathrm { P G D ^ { \\star } }$ . "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>Attack</td><td>I</td><td>I</td><td>I3</td><td>I4</td><td>I5</td><td>I</td><td>RA</td></tr><tr><td rowspan=\"3\">k-WTA[31]</td><td>PGD</td><td>0.33</td><td>0.43</td><td>0.77</td><td>1</td><td>1</td><td>0.306</td><td>58,2%</td></tr><tr><td>APGD</td><td>=</td><td>0.310</td><td>0.33</td><td></td><td></td><td>0.128</td><td>36,4%</td></tr><tr><td>PGD*</td><td>0.07</td><td>0.48</td><td>0.55</td><td>1</td><td>=</td><td>0.220</td><td>6,4%</td></tr><tr><td rowspan=\"3\">Distillation [22]</td><td>PGD</td><td>1</td><td>0.98</td><td>1</td><td>0.97</td><td>-</td><td>0.39</td><td>94.2%</td></tr><tr><td>APGD</td><td>1</td><td>0.4</td><td>0.21</td><td>1</td><td></td><td>0.122</td><td>00.4%</td></tr><tr><td>PGD*</td><td>1</td><td>0.04</td><td>1</td><td>1</td><td>-</td><td>0.008</td><td>0%</td></tr><tr><td rowspan=\"3\">Ensemble Div. [21]</td><td>PGD</td><td>1</td><td>0.76</td><td>=</td><td></td><td></td><td>0.152</td><td>38%</td></tr><tr><td>APGD</td><td>1</td><td>0.370</td><td>0.14</td><td></td><td></td><td>0.102</td><td>0%</td></tr><tr><td>PGD*</td><td>0.08</td><td>0.17</td><td>0.15</td><td>-</td><td>-</td><td>0.080</td><td>9 %</td></tr><tr><td rowspan=\"3\">TWS [32]</td><td>PGD</td><td>-</td><td>0.49</td><td>0.07</td><td>1</td><td>0.37</td><td>0.186</td><td>35%</td></tr><tr><td>APGD</td><td>1</td><td>0.41</td><td>0.09</td><td></td><td>1</td><td>0.10</td><td>0%</td></tr><tr><td>PGD*</td><td>=</td><td>0.37</td><td>0.10</td><td>=</td><td>=</td><td>0.094</td><td>0%</td></tr></table>",
+        "bbox": [
+            207,
+            87,
+            790,
+            270
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "246 for detecting the presence of adversarial examples on top of an undefended model, measuring how   \n247 much the decision changes locally around a sample. Even if the authors also apply other rejection   \n248 mechanisms, we take into account only the described one, as we wish to show that attacks optimized   \n249 neglecting such term will trigger the non-adaptive attack failure $( F _ { 4 } )$ . We apply this defended on   \n250 a WideResNet model trained on CIFAR10, provided by RobustBench [14]. We attack this model   \n251 with $\\ell _ { \\infty }$ -PGD [17], with step size $\\alpha = 0 . 1$ , maximum perturbation $\\epsilon = 0 . 3$ for 50 iterations on 100   \n252 samples, and then we query the defended model with all the computed adversarial examples. While   \n253 the attacks works against the standard model, some of them are rejected by the defense, resulting   \n254 in a robust accuracy of $3 5 \\%$ , highlighted by the trigger of the $I _ { 5 }$ indicator. In this case, we consider   \n255 an attack unsuccessful if the original sample is not misclassified and the adversarial point is either   \n256 belonging to the same class, or it is labeled as rejected.   \n257 Each of these attacks have been executed with 5 random restarts. We also attack all these models with   \n258 the version of AutoPGD (APGD) [13] that uses the difference of logit (DLR) as a loss to optimize.   \n259 This strategy will take care to automatically tune its hyperparameters while optimizing, reducing   \n260 possible errors that occur while deciding the values of step size, and iterations. Lastly, we compute   \n261 attacks that take into account all the mitigations we prescribed, and they will be analyzed further on   \n262 in the paper. ",
+        "bbox": [
+            138,
+            345,
+            825,
+            497
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            498,
+            825,
+            580
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Identifying failures. We want now to understand if our indicators are correlated with faults of the security evaluations of defenses. We collect the results of all the attacks against the selected targets, and we compute our indicators, by listing their values in Table 1, along with their mean score. With a glance, it is possible to grasp that out hypothesis is right: the detection of a failure is linked with higher values for the robust accuracy, and also the opposite. Each original evaluation is characterized by high values of one or more indicator, while the opposite happens for stronger attacks. For instance, APGD automatically tunes its hyperparameter while optimizing, hence it is able to apply some mitigations directly during the attack. To gain a quantitative evaluation of out hypothesis, we compute both the p-value and the correlation between the average score of the indicators and the robust accuracy, depicting this result in Fig. 5. Both p-value and correlation suggest a strong connection between these analyzed quantities, confirming our initial belief. ",
+        "bbox": [
+            165,
+            587,
+            576,
+            835
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/40f88aa3e9ff8ef8fa182b6e26b8c0119d17034475be78670da1e05d15bfe319.jpg",
+        "image_caption": [
+            "Figure 5: Evaluation of our metrics for different models. Robust accuracy vs. average value of the indicators, for the initial evaluation (denoted with $\\ ' _ { 0 } '$ ), with the evaluation after-mitigation (denoted with ’ $\\times \\overrightarrow { }$ ), and with APGD (denoted with $\\overrightarrow { } \\star \\overrightarrow { }$ ) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            598,
+            613,
+            812,
+            777
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Mitigating failures. We can now use our indicators to improve the quality of the security evaluations, and we apply the following pipeline: (i) we test the defense with a set of points with the original attack strategy proposed by the author of the defense; (ii) we select the failure cases and inspect the ",
+        "bbox": [
+            171,
+            842,
+            575,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/3503c12feb43c1dc23c05e062131a37a3e8493291bdf0cb8f27cdee18a24ff95.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: Robust accuracies $\\overline { { ( \\% ) } }$ after patching the security evaluations with the prescribed mitigations. "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>Initial</td><td>M1</td><td>M2</td><td>M3</td><td>M4</td><td>M5</td><td>Final</td></tr><tr><td>k-WTA [31]</td><td>58.2%</td><td>36.4%</td><td>36.4%</td><td>6.4%</td><td>6.4%</td><td>6.4%</td><td>6.4%</td></tr><tr><td>Distillation [22]</td><td>94.2%</td><td>94.2%</td><td>94.2%</td><td>94.2%</td><td>94.2%</td><td>0.4%</td><td>0.4%</td></tr><tr><td>Ensemble Diversity [21]</td><td>38.0%</td><td>38.0%</td><td>36.0%</td><td>36.0%</td><td>29.0%</td><td>9.0%</td><td>9.0%</td></tr><tr><td>TWS [32]</td><td>35.0%</td><td>35.0%</td><td>35.0%</td><td>35.0%</td><td>35.0%</td><td>0.0%</td><td>0.0%</td></tr></table>",
+        "bbox": [
+            197,
+            87,
+            810,
+            165
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "286 feedback of our indicators per-sample; (iii) for each cause of failure, we apply the specific remediation   \n287 suggested by the metric; and (iv) we show that the attack now succeeds, thus reducing the robust   \n288 accuracy of the target model, and also the values of the indicators. ",
+        "bbox": [
+            145,
+            226,
+            825,
+            268
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "9 We report all the results of this process in Table 2, where each row shows the original robust accuracy, and how it is decreased, mitigation after mitigation. Also, all the individual values of each indicator computed on these patched attacks can be found in Table 1, marked as $\\mathrm { P G D ^ { \\star } }$ . ",
+        "bbox": [
+            158,
+            275,
+            825,
+            316
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Mitigating $k$ -WTA failures. For many failing attacks, the $I I$ indicator triggers, implying that the attack found an adversarial example inside the path. We then apply mitigation $M _ { I }$ , and we lower accordingly the robust accuracy of the model to $3 6 { , } 4 \\%$ . We then analyze the feedback of the $I _ { 3 }$ indicator, the one that detects the presence of noisy gradients. We apply mitigation $M _ { 3 }$ , and we change the loss of the attack as described by Tramèr et al. [30]. This loss is computed by averaging the gradient of each single point of the attack path with the information of the surrounding ones. The resulting direction is then able to correctly descent toward a minimum. We run $\\ell _ { \\infty }$ -PGD with the same parameters, but smoothing the gradients by averaging 100 neighboring points from a normal distribution $\\mathcal { N } ( \\mu = \\pmb { x } _ { i } , \\sigma = 0 . 0 3 1 )$ , where $x _ { i }$ is a point in the attack path. After such mitigation, the robust accuracy drops to $6 , 4 \\%$ , and so follows the indicator (Fig. 6a). ",
+        "bbox": [
+            166,
+            323,
+            825,
+            462
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "302 Mitigating Distillation failures. All the attacks fail because of the absence of gradient information,   \n303 leading the attack to a bad local optimum $( F _ { 3 } )$ , and such is highlighted by the feedback of the $I _ { 3 }$   \n304 indicator. We apply mitigation $M _ { 3 }$ , and we change the loss optimized during the attack, following the   \n305 strategy applied by Carlini et al. [9], that computes the loss of the attack on the logit of the model   \n306 rather than the final softmax layer. We repeat the PGD attack with such fix, and the robust accuracy   \n307 drops to $0 \\%$ , along with the indicator $I _ { 3 }$ (Fig. 6b).   \n308 Mitigating Ensemble diversity failures. Firstly, the $I _ { I }$ indicator highlighted the presence of $F _ { I }$ ,   \n309 implying that some failing attacks are due to the implementation itself. We apply mitigation $M _ { I }$ , and   \n310 the robust accuracy decreases to $36 \\%$ . Also, $I _ { 2 }$ indicator is active, implying that the loss of of failing   \n311 attacks could be optimized more. For this reason, we apply mitigation $M _ { 2 }$ , and we increase the step   \n312 size to 0.05 and the iterations to 50. This patch is enough for lowering the robust accuracy to $9 \\%$   \n313 (Fig. 6c).   \n314 Mitigating TWS failures. The detector is rejecting adversarial attacks successfully computed on the   \n315 undefended model, triggering the $I _ { 5 }$ indicator. Hence we apply mitigation $M _ { 5 }$ , and we adapt the attack   \n316 to consider also the rejection class. This version of PGD minimizes the usual loss function of the   \n317 attacker, but it also minimizes the score of the rejection class when encountered, allowing it to evade   \n318 the rejection. We run such attack, and we obtain a new robust accuracy of $0 \\%$ (Fig. 6d). ",
+        "bbox": [
+            142,
+            468,
+            825,
+            551
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            558,
+            825,
+            640
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            647,
+            825,
+            717
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "319 5 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            747,
+            320,
+            765
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "320 Other systematic analysis on robustness evaluations. There have been a number of prior papers   \n321 evaluating the robustness of particular defense schemes [10, 1, 30]. These papers focus on under  \n322 standing whether the robustness claims of particular defenses are true, often by performing one-off   \n323 attacks or by proposing new general attack approaches that can be used to break future defenses. In   \n324 contrast our goal is not to break any particular defense, but rather to help researchers understand   \n325 when their evaluation may have gone wrong. In this way our paper is related to Carlini et al. [12]   \n326 that systematizes various suggestions from the literature for how to ensure that adversarial robust  \n327 ness evaluations are performed thoroughly. We imagine that our tests could be included in future   \n328 recommendations for robustness evaluations. ",
+        "bbox": [
+            147,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0d4ee15b4cc7ac30f4546d995c930ae7c165872eed98319cda18c9eb8c18c627.jpg",
+        "image_caption": [
+            "Figure 6: The values of our indicators and the success rate (SR) of the attack, before (semi-transparent colored area) and after (solid colored area) fixing the failures, computed for the analyzed models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            823,
+            266
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Benchmarks. Related to this work, there are a number of attack benchmarks that have been constructed. Instead of measuring the robustness of individual schemes as the prior papers do, these benchmarks aim to provide a complete evaluation framework that can be applied to any future defense as well. Ling et. al [16] proposed DEEPSEC, a benchmark that tests several attacks against a wide range of defenses. However, this framework was shown to be flawed by several implementation issues and problems in the configuration of the attacks [8]. Croce et al. [14] propose RobustBench [14], that accepts state-of-the-art models as submissions, and it tests their robust accuracy by applying AutoAttack [13]. However, this benchmark suite only works on CIFAR-trained models, and it is not able to determine which are the possible causes of such scored performance. ",
+        "bbox": [
+            163,
+            333,
+            825,
+            459
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "338 Hence, these benchmark would benefit from our indicators, since they might provide useful insight   \n339 that can be autonomously computed. Here we imagine that our framework could be used to help   \n340 these tools automatically detect when their evaluations are incomplete, so that they could warn the   \n341 operator that there was a potential error that should be investigated. ",
+        "bbox": [
+            142,
+            464,
+            825,
+            520
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "342 6 Contributions, Limitations and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            545,
+            580,
+            563
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "343 We propose the Indicators of Attack Failures (IoAF), quantitative tests that help the debugging of   \n344 faulty-conducted security evaluations, and we propose a pipeline for mitigating their issues, leading to   \n345 a fairer evaluation. We select defenses that have been previously shown to be weak against adversarial   \n346 attacks, and we evaluate them with the lens of our indicators, showing that we could have detected   \n347 their misconduct in advance. We empirically prove that these test are correlated with wrongly high   \n348 robust accuracy, while they drop when attacks are successful.   \n349 On top of these contributions, we acknowledge some limitations in our methodology. We do not   \n350 provide a fully-autonomous way for deciding how to turn an attack into its adaptive version against   \n351 a particular defense (e.g. gradient obfuscation), but we provide quantitative tools for helping the   \n352 decision among all the possible solutions that the attacker could come up with. Another limitation   \n353 lurks in the choice of the attack itself, since some unknown-and-adaptive attack could behave very   \n354 differently w.r.t. standard one, triggering some indicator in the process. However, these tests can be   \n355 patched accordingly to take care of these newly-proposed patched attacks, and still being used as   \n356 debugging tools. Lastly, as already discussed in Sect. 3, if the evaluated defense is not triggering any   \n357 indicators it does not imply it is secure, but rather it forces the application of other sanity checks [12].   \n358 We believe some part of this last process can be automatized with additional indicators, however we   \n359 leave this as a future work.   \n360 We hope that future work will include our indicators during the evaluation phase of new methods, in   \n361 order to identify when attacks are failing for known reasons, and thus contributing to the creation of   \n362 better defense mechanisms. Also, this work pose a preliminary step towards the creation of interactive   \n363 dashboards that can be inspected as a web application. Finally, it would be insightful to attach   \n364 our pipeline of indicators and mitigations to already-available benchmarks (i.e. RobustBench [14]),   \n365 possibly detecting other failures in security evaluations we did not covered in our experiments. ",
+        "bbox": [
+            140,
+            579,
+            825,
+            662
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            670,
+            825,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References [1] A. Athalye, N. Carlini, and D. A. Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In ICML, volume 80 of JMLR Workshop and Conference Proceedings, pages 274–283. JMLR.org, 2018. [2] M. Barreno, B. Nelson, A. Joseph, and J. Tygar. The security of machine learning. Machine Learning, 81:121–148, 2010. [3] B. Biggio and F. Roli. Wild patterns: Ten years after the rise of adversarial machine learning. Pattern Recognition, 84:317–331, 2018. [4] B. Biggio, I. Corona, D. Maiorca, B. Nelson, N. Šrndic, P. Laskov, G. Giacinto, and F. Roli. ´ Evasion attacks against machine learning at test time. In H. Blockeel, K. Kersting, S. Nijssen, and F. Železný, editors, Machine Learning and Knowledge Discovery in Databases (ECML PKDD), Part III, volume 8190 of LNCS, pages 387–402. Springer Berlin Heidelberg, 2013. [5] B. Biggio, G. Fumera, and F. Roli. Security evaluation of pattern classifiers under attack. IEEE Transactions on Knowledge and Data Engineering, 26(4):984–996, April 2014. ISSN 1041-4347. [6] W. Brendel, J. Rauber, M. Kümmerer, I. Ustyuzhaninov, and M. Bethge. Accurate, reliable and fast robustness evaluation, 2019. [7] J. Buckman, A. Roy, C. Raffel, and I. Goodfellow. Thermometer encoding: One hot way to resist adversarial examples. In International Conference on Learning Representations, 2018. [8] N. Carlini. A critique of the deepsec platform for security analysis of deep learning models, 2019. [9] N. Carlini and D. Wagner. Defensive distillation is not robust to adversarial examples, 2016. [10] N. Carlini and D. A. Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. In B. M. Thuraisingham, B. Biggio, D. M. Freeman, B. Miller, and A. Sinha, editors, 10th ACM Workshop on Artificial Intelligence and Security, AISec ’17, pages 3–14, New York, NY, USA, 2017. ACM.   \n392 [11] N. Carlini and D. A. Wagner. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy, pages 39–57. IEEE Computer Society, 2017.   \n394 [12] N. Carlini, A. Athalye, N. Papernot, W. Brendel, J. Rauber, D. Tsipras, I. Goodfellow, A. Madry, and A. Kurakin. On evaluating adversarial robustness, 2019.   \n396 [13] F. Croce and M. Hein. Reliable evaluation of adversarial robustness with an ensemble of diverse parameter-free attacks. In ICML, 2020.   \n398 [14] F. Croce, M. Andriushchenko, V. Sehwag, N. Flammarion, M. Chiang, P. Mittal, and M. Hein. Robustbench: a standardized adversarial robustness benchmark. arXiv preprint arXiv:2010.09670, 2020.   \n401 [15] S. G. Finlayson, J. D. Bowers, J. Ito, J. L. Zittrain, A. L. Beam, and I. S. Kohane. Adversarial attacks on medical machine learning. Science, 363(6433):1287–1289, 2019.   \n403 [16] X. Ling, S. Ji, J. Zou, J. Wang, C. Wu, B. Li, and T. Wang. Deepsec: A uniform platform for security analysis of deep learning model. In 2019 IEEE Symposium on Security and Privacy $( S P )$ , pages 673–690, 2019. doi: 10.1109/SP.2019.00023.   \n406 [17] A. Madry, A. Makelov, L. Schmidt, D. Tsipras, and A. Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.   \n408 [18] A. McCallum and K. Nigam. A comparison of event models for naive bayes text classification. In Proc. AAAI Workshop on learning for text categorization, pages 41–48, 1998.   \n410 [19] P. McDaniel, N. Papernot, and Z. B. Celik. Machine learning in adversarial settings. IEEE Security & Privacy, 14(3):68–72, May 2016. ",
+        "bbox": [
+            145,
+            80,
+            830,
+            920
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[20] M. Melis, A. Demontis, M. Pintor, A. Sotgiu, and B. Biggio. secml: A python library for secure and explainable machine learning. arXiv preprint arXiv:1912.10013, 2019. [21] T. Pang, K. Xu, C. Du, N. Chen, and J. Zhu. Improving adversarial robustness via promoting ensemble diversity. In K. Chaudhuri and R. Salakhutdinov, editors, Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pages 4970–4979. PMLR, 09–15 Jun 2019. URL http://proceedings.mlr. press/v97/pang19a.html. [22] N. Papernot, P. McDaniel, X. Wu, S. Jha, and A. Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In 2016 IEEE Symposium on Security and Privacy (SP), pages 582–597, May 2016. doi: 10.1109/SP.2016.41. [23] M. Pintor, F. Roli, W. Brendel, and B. Biggio. Fast minimum-norm adversarial attacks through adaptive norm constraints, 2021. [24] J. Rony, L. G. Hafemann, L. S. Oliveira, I. B. Ayed, R. Sabourin, and E. Granger. Decoupling direction and norm for efficient gradient-based l2 adversarial attacks and defenses, 2019. [25] K. Roth, Y. Kilcher, and T. Hofmann. The odds are odd: A statistical test for detecting adversarial examples. In International Conference on Machine Learning, pages 5498–5507. PMLR, 2019. [26] B. I. Rubinstein, B. Nelson, L. Huang, A. D. Joseph, S.-h. Lau, S. Rao, N. Taft, and J. D. Tygar. Antidote: understanding and defending against poisoning of anomaly detectors. In Proceedings of the 9th ACM SIGCOMM Internet Measurement Conference, IMC ’09, pages 1–14, New York, NY, USA, 2009. ACM. [27] M. Sahami, S. Dumais, D. Heckerman, and E. Horvitz. A bayesian approach to filtering junk e-mail. AAAI Technical Report WS-98-05, Madison, Wisconsin, 1998. [28] C. Smutz and A. Stavrou. Malicious pdf detection using metadata and structural features. In Proceedings of the 28th Annual Computer Security Applications Conference, ACSAC ’12, pages 239–248, New York, NY, USA, 2012. ACM. [29] C. Szegedy, W. Zaremba, I. Sutskever, J. Bruna, D. Erhan, I. Goodfellow, and R. Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations, 2014. URL http://arxiv.org/abs/1312.6199. [30] F. Tramer, N. Carlini, W. Brendel, and A. Madry. On adaptive attacks to adversarial example defenses. Advances in Neural Information Processing Systems, 33, 2020. [31] C. Xiao, P. Zhong, and C. Zheng. Resisting adversarial attacks by $k$ -winners-take-all. 2020. [32] T. Yu, S. Hu, C. Guo, W. Chao, and K. Weinberger. A new defense against adversarial images: Turning a weakness into a strength. In Proceedings of the 33rd Conference on Neural Information Processing Systems (NeurIPS 2019), Oct. 2019. 47 [33] X. Yuan, P. He, Q. Zhu, and X. Li. Adversarial examples: Attacks and defenses for deep learning. IEEE Transactions on Neural Networks and Learning Systems, 30(9):2805–2824, 2019. doi: 10.1109/TNNLS.2018.2886017. ",
+        "bbox": [
+            153,
+            92,
+            828,
+            748
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            168,
+            765,
+            253,
+            781
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            791,
+            339,
+            805
+        ],
+        "page_idx": 10
+    },
+    {
+        "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] We discuss the limitations in Sect. 6   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] In Sect. 6, we specified that the aim of our work is not to break defenses in an harmful way. Our purpose is only to help researchers to improve their security evaluation. ",
+        "bbox": [
+            238,
+            809,
+            825,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            235,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            123,
+            493,
+            138
+        ],
+        "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": [
+            236,
+            142,
+            738,
+            174
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            179,
+            393,
+            193
+        ],
+        "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 will be submitted as supplementary material, and the instructions for reproducing the experiments are described in Sect. 4   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We describe the experimental protocol in Sect. 4   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   \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] The resourced used for the experiments are listed in Sect. 4 ",
+        "bbox": [
+            238,
+            196,
+            825,
+            356
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            209,
+            361,
+            823,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We cited all the existing assets used for the experiments.   \n(b) Did you mention the license of the assets? [Yes] We cited the authors of the assets, and we provide the list of external assets along with the code.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We provide the code for computing the metrics as supplementary material.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] All the assets we used are publicly available.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            380,
+            825,
+            529
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            532,
+            705,
+            547
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            551,
+            825,
+            641
+        ],
+        "page_idx": 11
+    }
+]

parse/train/OKrNPg3xR3T/OKrNPg3xR3T.md

@@ -0,0 +1,274 @@
+# Mastering Atari Games with Limited Data
+
+Weirui $\mathbf { Y e ^ { * } }$ Shaohuai Liu∗ Thanard Kurutach† Pieter Abbeel† Yang Gao∗‡ ∗Tsinghua University, †UC Berkeley, ‡ Shanghai Qi Zhi Institute
+
+# Abstract
+
+Reinforcement learning has achieved great success in many applications. However, sample efficiency remains a key challenge, with prominent methods requiring millions (or even billions) of environment steps to train. Recently, there has been significant progress in sample efficient image-based RL algorithms; however, consistent human-level performance on the Atari game benchmark remains an elusive goal. We propose a sample efficient model-based visual RL algorithm built on MuZero, which we name EfficientZero. Our method achieves $1 9 0 . 4 \%$ mean human performance and $1 1 6 . 0 \%$ median performance on the Atari 100k benchmark with only two hours of real-time game experience and outperforms the state SAC in some tasks on the DMControl $1 0 0 \mathrm { k }$ benchmark. This is the first time an algorithm achieves super-human performance on Atari games with such little data. EfficientZero’s performance is also close to DQN’s performance at 200 million frames while we consume 500 times less data. EfficientZero’s low sample complexity and high performance can bring RL closer to real-world applicability. We implement our algorithm in an easy-to-understand manner and it is available at https://github.com/YeWR/EfficientZero. We hope it will accelerate the research of MCTS-based RL algorithms in the wider community.
+
+![](images/f98dec42a45f80d9891aae47ec142d8d3011715700cf3b3945241f3407eaf192.jpg)  
+Figure 1: Our proposed method EfficientZero is $170 \%$ and $180 \%$ better than the previous SoTA performance in mean and median human normalized score and is the first to outperform the average human performance on the Atari $1 0 0 \mathrm { k }$ benchmark. The high sample efficiency and performance of EfficientZero can bring RL closer to the real-world applications.
+
+# 1 Introduction
+
+Reinforcement learning has achieved great success on many challenging problems. Notable work includes DQN [24], AlphaGo [33] and OpenAI Five [5]. However, most of these works come at the cost of a large number of environmental interactions. For example, AlphaZero [34] needs to play 21 million games at training time. On the contrary, a professional human player can only play around 5 games per day, meaning it would take a human player 11,500 years to achieve the same amount of experience. The sample complexity might be less of an issue when applying RL algorithms in simulation and games. However, when it comes to real-world problems, such as robotic manipulation, healthcare, and advertisement recommendation systems, achieving high performance while maintaining low sample complexity is the key to viability.
+
+People have made a lot of progress in sample efficient RL in the past years [8, 10, 35, 22, 21, 32, 18]. Among them, model-based methods have attracted a lot of attention, since both the data from real environments and the “imagined data” from the model can be used to train the policy, making these methods particularly sample-efficient [8, 10]. However, most of the successes are in state-based environments. In image-based environments, some model-based methods such as MuZero [27] and Dreamer V2 [14] achieve super-human performance, but they are not sample efficient; other methods such as SimPLe [18] is quite efficient but achieve inferior performance (0.144 human normalized median scores). Recently, data-augmented and self-supervised methods applied to modelfree methods have achieved more success in the data-efficient regime [32]. However, they still fail to achieve the levels which can be expected of a human.
+
+Therefore, for improving the sample efficiency as well as keeping superior performance, we find the following three components are essential to the model-based visual RL agent: a self-supervised environment model, a mechanism to alleviate the model compounding error, and a method to correct the off-policy issue. In this work, we propose EfficientZero, a model-based RL algorithm that achieves high performance with limited data. Our proposed method is built on MuZero. We make three critical changes: (1) use self-supervised learning to learn a temporally consistent environment model, (2) learn the value prefix in an end-to-end manner, thus helping to alleviate the compounding error in the model, (3) use the learned model to correct off-policy value targets.
+
+As illustrated as Figure 1, our model achieves state-of-the-art performance on the widely used Atari [4] 100k benchmark and it achieves super-human performance with only 2 hours of real-time gameplay. More specifically, our model achieves $1 9 0 . 4 \%$ mean human normalized performance and $1 1 6 . 0 \%$ median human normalized performance. As a reference, DQN [24] achieves $220 \%$ mean human normalized performance, and $96 \%$ median human normalized performance, at the cost of 500 times more data (200 million frames). To further verify the effectiveness of EfficientZero, we conduct experiments on some simulated robotics environments of the DeepMind Control (DMControl) suite. It achieves state-of-the-art performance and outperforms the state SAC which directly learns from the ground truth states. Our sample efficient and high-performance algorithm opens the possibility of having more impact on many real-world problems.
+
+# 2 Related Work
+
+# 2.1 Sample Efficient Reinforcement Learning
+
+Sample efficiency has attracted significant work in the past. In RL with image inputs, model-based approaches [13, 12] which model the world with both a stochastic and a deterministic component, have achieved promising results for simulated robotic control. Kaiser et al. [18] propose to use an action-conditioned video prediction model, along with a policy learning algorithm. It achieves the first strong performance on Atari games with as little as $4 0 0 \mathrm { k }$ frames. However, Kielak [19] and van Hasselt et al. [39] argue that this is not necessary to achieve strong results with model-based methods, and they show that when tuned appropriately, Rainbow [16] can achieve comparable results.
+
+Recent advances in self-supervised learning, such as SimCLR [6], MoCo [15], SimSiam [7] and BYOL [11] have inspired representation learning in image-based RL. Srinivas et al. [35] propose to use contrastive learning in RL algorithms and their work achieves strong performance on image-based continuous and discrete control tasks. Later, Laskin et al. [22] and Kostrikov et al. [21] find that contrastive learning is not necessary, but with data augmentations alone, they can achieve better performance. Schwarzer et al. [32] propose a temporal consistency loss, which is combined with data augmentations and achieves state-of-the-art performance. Notably, our self-supervised consistency loss is quite similar to Schwarzer et al. [32], except we use SimSiam [6] while they use BYOL [11] as the base self-supervised learning framework. However, Schwarzer et al. [32] only apply the learned representations in a model-free manner, while we combine the learned model with model-based exploration and policy improvement, thus leading to more efficient use of the environment model.
+
+Despite the recent progress in the sample-efficient RL, today’s RL algorithms are still well behind human performance when the amount of data is limited. Although traditional model-based RL is considered more sample efficient than model-free ones, current model-free methods dominate in terms of performance for image-input settings. In this paper, we propose a model-based RL algorithm that for the first time, achieves super-human performance on Atari games with limited data.
+
+# 2.2 Reinforcement Learning with MCTS
+
+Temporal difference learning [24, 38, 40, 16] and policy gradient based methods [25, 23, 29, 31] are two types of popular reinforcement learning algorithms. Recently, Silver et al. [33] propose to use MCTS as a policy improvement operator and has achieved great success in many board games, such as Go, Chess, and Shogi [34]. Later, the algorithm is adapted to learn the world model at the same time [27]. It has also been extended to deal with continuous action spaces [17] and offline data [28]. These MCTS RL algorithms are a hybrid of model-based learning and model-free learning.
+
+However, most of them are trained with a lot of environmental samples. Our method is built on top of MuZero [27], and we demonstrate that our method can achieve higher sample efficiency while still achieving competitive performance on the Atari $1 0 0 \mathrm { k }$ benchmark. de Vries et al. [9] have studied the potential of using auxiliary loss similar to our self-supervised consistency loss. However, they only test on two low dimensional state-based environments and find the auxiliary loss has mixed effects on the performance. On the contrary, we find that the consistency loss is critical in most environments with high dimensional observations and limited data.
+
+# 2.3 Multi-Step Value Estimation
+
+In Q-learning [41], the target Q vaincorporating multiple steps of re s computed bys at once, i.e. $z _ { t } = \bar { \sum _ { i = 0 } ^ { k - 1 } } \gamma ^ { i } \bar { u } _ { t + i } \stackrel {  } { + } \gamma ^ { k } v _ { t + k }$ people fi, where $u _ { t + i }$ atis $v _ { t + k }$ the value target $z _ { t }$ leads to faster convergence [24, 16]. However, the use of multi-step value has off-policy issues, since $u _ { t + i }$ are not generated by the current policy. In practice, this issue is usually ignored when there is a large amount of data since the data can be thought as approximately on-policy. $\mathrm { T D } ( \lambda )$ [36] and GAE [30] improve the value estimation by better trading off the bias and the variance, but they do not deal with the off-policy issue. Recently, image input model-based algorithms such as Kaiser et al. [18] and Hafner et al. [12] use model imaginary rollouts to avoid the off-policy issue. However, this approach has the risk of model exploitation. Asadi et al. [2] proposed a multi-step model to combat the compounding error. Our proposed model-based off-policy correction method starts from the rewards in the real-world experience and uses model-based value estimate to bootstrap. Our approach balances between the off-policy issue and model exploitation.
+
+# 3 Background
+
+# 3.1 MuZero
+
+Our method is built on top of the MuZero Reanalyze [27] algorithm. For brevity, we refer to it as MuZero throughout the paper. MuZero is a policy learning method based on the Monte-Carlo Tree Search (MCTS) algorithm. The MCTS algorithm operates with an environment model, a prior policy function, and a value function. The environment model is represented as the reward function $\mathcal { R }$ and the dynamic function $\mathcal { G }$ : $r _ { t } = \mathcal { R } ( s _ { t } , a _ { t } )$ , $\hat { s } _ { t + 1 } = \mathcal G ( s _ { t } , a _ { t } )$ , which are needed when MCTS expands a new node. In MuZero, the environment model is learned. Thus the reward and the next state are approximated. Besides, the predicted policy $p _ { t } =$ acts as a search prior over actions of a node. It helps the MCTS focus on more promising actions when expanding the node. MCTS also needs a value function $\mathcal { V } ( s _ { t } )$ that measures the expected return of the node $s _ { t }$ , which provides a long-term evaluation of the tree’s leaf node without further search. MCTS will output an action visit distribution $\pi _ { t }$ over the root node, which is potentially a better policy, compared to the current neural network. Thus, the MCTS algorithm can be thought of as a policy improvement operator.
+
+In practice, the environment model, policy function, and value function operate on a hidden abstract state $s _ { t }$ , both for computational efficiency and ease of environment modeling. The abstract state is extracted by a representation function $\mathcal { H }$ on observations $o _ { t }$ : $s _ { t } = \mathcal { H } ( o _ { t } )$ . All of the mentioned models above are usually represented as neural networks. During training, the algorithm collects roll-out data in the environment using MCTS, resulting in potentially higher quality data than the current neural network policy. The data is stored in a replay buffer. The optimizer minimizes the following loss on the data sampled from the replay buffer:
+
+$$
+\mathcal { L } ( u _ { t } , r _ { t } ) + \lambda _ { 1 } \mathcal { L } ( \pi _ { t } , p _ { t } ) + \lambda _ { 2 } \mathcal { L } ( z _ { t } , v _ { t } )
+$$
+
+Here, visit c $u _ { t }$ is the reward from the ennt distribution of the MCT $r _ { t } = \mathcal { R } ( s _ { t } , a _ { t } )$ is the predted policy, $\pi _ { t }$ $p _ { t } = \mathcal { P } ( s _ { t } )$ $\begin{array} { r } { z _ { t } = \sum _ { i = 0 } ^ { k - 1 } \gamma ^ { i } u _ { t + i } + \gamma ^ { k } v _ { t + k } } \end{array}$ $v _ { t } = \mathcal { V } ( s _ { t } )$   
+$\mathcal { R }$ , policy function $\mathcal { P }$ , value function $\nu$ , the representation function $\mathcal { H }$ and the dynamics function $\mathcal { G }$   
+are trainable neural networks. It is worth noting that MuZero does not explicitly learn the environment   
+model. Instead, it solely relies on the reward, value, and policy prediction to learn the model.
+
+# 3.2 Monte-Carlo Tree Search
+
+Monte-Carlo Tree Search [1, 33, 34, 14], or MCTS, is a heuristic search algorithm. In our setup, MCTS is used to find an action policy that is better than the current neural network policy.
+
+More specifically, MCTS needs an environment model, including the reward function and the nextstate function. It also needs a value function and a policy function, which act as heuristics for the tree search. MCTS operates by expanding a search tree from the current node. It saves computation by selectively expanding a few nodes. In order to find a high-quality decision, the tree expansion process has to balance between exploration versus exploitation, i.e. balance between expanding a node that is promising with many visits versus expanding a node with lower performance but fewer visits. MCTS employs the UCT [26, 20] rule, i.e. UCB [3] on trees. At every node expansion step, UCT will select a node as follows [14]:
+
+$$
+a ^ { k } = \arg \operatorname* { m a x } _ { a } \left\{ Q ( s , a ) + P ( s , a ) { \frac { \sqrt { \sum _ { b } N ( s , b ) } } { 1 + N ( s , a ) } } \left( c _ { 1 } + \log \left( { \frac { \sum _ { b } N ( s , b ) + c _ { 2 } + 1 } { c _ { 2 } } } \right) \right) \right\}
+$$
+
+where, $Q ( s , a )$ is the current estimate of the Q-value, $P ( s , a )$ is the current neural network policy for selecting this action, helping the MCTS prioritize exploring promising part of the tree. During training time, $P ( s , a )$ is usually perturbed by noises to allow explorations. $N ( s , a )$ denotes how many times this state-action pair is visited in the tree search, and $N ( s , b )$ denote that of $a$ ’s siblings. Thus this term will encourage the search to visit the nodes whose siblings are visited often, but itself less visited. Finally, the last term gives a weights to the previous terms.
+
+After expanding the nodes for a pre-defined number of times, the MCTS will return how many times each action under the root node is visited, as the improved policy to the root node. Thus, MCTS can be considered as a policy improvement operator in the RL setting.
+
+# 4 EfficientZero
+
+Model-based algorithms have achieved great success in sample-efficient learning from lowdimensional states. However, current visual model-based algorithms either require large amounts of training data or exhibit inferior performance to model-free algorithms in data-limited settings [32]. Many previous works even suspect whether model-based algorithms can really offer data efficiency when using image observations [39]. We provide a positive answer here. We propose the EfficientZero, a model-based algorithm built on the MCTS, that achieves super-human performance on the $1 0 0 \mathrm { k }$ Atari benchmark, outperforming the previous SoTA to a large degree.
+
+When directly running MCTS-based RL algorithms such as MuZero, we find that they do not perform well on the limited-data benchmark. Through our ablations, we confirm the following three issues which pose challenges to algorithms like MuZero in data-limited settings.
+
+Lack of supervision on environment model. First, the learned model in the environment dynamics is only trained through the reward, value and policy functions. However, the reward is only a scalar signal and in many scenarios, the reward will be sparse. Value functions are trained with bootstrapping, and thus are noisy. Policy functions are trained with the search process. None of the reward, value and policy losses can provide enough training signals to learn the environment model.
+
+Hardness to deal with aleatoric uncertainty. Second, we find that even with enough data, the predicted rewards still have large prediction errors. This is caused by the aleatoric uncertainty of the underlying environment. For example, the environment is hard to model. The reward prediction errors will accumulate when expanding the MCTS tree to a large depth, resulting in sub-optimal performance in exploration and evaluation.
+
+Off-policy issues of multi-step value. Lastly, when computing the value target, MuZero uses the multi-step reward observed in the environment. Although this allows the reward to be propagated to the value function faster, we find that it suffers from severe off-policy issues and hinders convergence in the limited data scenario.
+
+To address the above issues, we propose the following three critical modifications, which can greatly improve performance when samples are limited.
+
+# 4.1 Self-Supervised Consistency Loss
+
+In previous MCTS RL algorithms, the environment model is either given or only trained with rewards, values, and policies, which cannot provide sufficient training signals due to their scalar nature. The problem is more severe when the reward is sparse or the bootstrapped value is not accurate. The MCTS policy improvement operator heavily relies on the environment model. Thus, it is vital to have an accurate one.
+
+We notice that the output $\hat { s } _ { t + 1 }$ from the dynamic function $\mathcal { G }$ should be the same as $s _ { t + 1 }$ , i.e. the output of the representation function $\mathcal { H }$ with input of the next observation $o _ { t + 1 }$ (Fig. 2). This can help to supervise the predicted next state $\hat { s } _ { t + 1 }$ using the actual $s _ { t + 1 }$ , which is a tensor with at least a few hundred dimensions. This provides $\hat { s } _ { t + 1 }$ with much more training signals than the default scalar reward and value.
+
+![](images/1809716351b1a577cd6cb75c1c6b7ac67defbf923e012a36a9df23ee7e459946.jpg)  
+Figure 2: The self-supervised consistency loss.
+
+More specifically, we adopt the recently proposed SimSiam [7] self-supervised framework. SimSiam [7] is a self-supervised method that takes two augmentation views of the same image and pulls the output of the second branch close to that of the first branch, where the first branch is an encoder network without gradient, and the second branch is the same encoder network with the gradient and a predictor head. The predictor head can simply be a two-layer MLP.
+
+Note that SimSiam only learns the representation of individual images, and is not aware of how different images are connected. The learned image representations of SimSiam might not be a good candidate for learning the environment transition function, since adjacent observations might be encoded to very different representation encodings. We propose a self-supervised method that learns the transition function, along with the image representation function in an end-to-end manner. Figure 2 shows our method. Since we aim to learn the transition between adjacent observations, we pull $o _ { t }$ and $o _ { t + 1 }$ close to each other. The transition function is applied after the representation of $o _ { t }$ , such that $s _ { t }$ is transformed to $\hat { s } _ { t + 1 }$ , which now represents the same entity as the other branch. Then both of $s _ { t + 1 }$ and $\hat { s } _ { t + 1 }$ go through a common projector network. Since $s _ { t + 1 }$ is potentially a more accurate description of $o _ { t + 1 }$ compared to $\hat { s } _ { t + 1 }$ , we make the $o _ { t + 1 }$ branch as the target branch. It is common in self-supervised learning that the second or the third layer from the last is chosen as the features for some reason. Here, we choose the outputs from the representation network or the dynamics network as the hidden states rather than those from the projector or the predictor.
+
+The two adjacent observations provide two views of the same entity. In practice, we find that applying augmentations to observations such as a random small shift of 0-4 pixels on the image helps to further improve the learned representation quality [35, 32]. We also unroll the dynamic function recurrently for 5 further steps and also pull $\hat { s } _ { t + k }$ close to $s _ { t + k }$ $k = 1 , . . . , 5 )$ ). Please see the Appendix for more implementation details.
+
+# 4.2 End-To-End Prediction of the Value Prefix
+
+In model-based learning, the agent needs to predict the future states conditioned on the current state and a series of hypothetical actions. The longer the prediction, the harder to predict it accurately, due to the compounding error in the recurrent rollouts. This is called the state aliasing problem. The environment model plays an important role in MCTS. The state aliasing problem harms the MCTS expansion, which will result in sub-optimal exploration as well as sub-optimal action search.
+
+Predicting the reward from an aliased state is a hard problem. For example, as shown in Figure 3, the right agent loses the ball. If we only see the first observation, along with future actions, it is very hard both for an agent and a human to predict at which exact future timestep the player would lose a point. However, it is easy to predict the agent will miss the ball after a sufficient number of timesteps if he does not
+
+![](images/85e06f9eaa5501aeec5eec3408712340c7d81a97b5313a5d633a2b0134511504.jpg)  
+Figure 3: A sample trajectory from the Atari Pong game. In this case, the right player didn’t move and missed the ball.
+
+move. In practice, a human will never try to predict the exact step that he loses the point but will imagine over a longer horizon and thus get a more confident prediction.
+
+Inspired by this intuition, we propose an end-to-end method to predict the value prefix. We notice that the predicted reward is always used in the estimation of the Q-value $Q ( s , a )$ in UCT of Equation 2
+
+$$
+Q ( s _ { t } , a ) = \sum _ { i = 0 } ^ { k - 1 } \gamma ^ { i } r _ { t + i } + \gamma ^ { k } v _ { t + k }
+$$
+
+$r _ { t + i }$ is the reward predicted from unrolled state as the value prefix, since it is used as a prefix i $\hat { s } _ { t + i }$ . W later name the sum of rewards-value computation. $\sum _ { i = 0 } ^ { k - 1 } \gamma ^ { i } r _ { t + i }$ $\mathrm { Q }$
+
+We propose to predict value prefix from the unrolled states $( s _ { t } , \hat { s } _ { t + 1 } , \cdot \cdot \cdot , \hat { s } _ { t + k - 1 } )$ in an end-to-end manner, i.e. value-prefix $= f ( s _ { t } , \hat { s } _ { t + 1 } , \cdot \cdot \cdot , \hat { s } _ { t + k - 1 } )$ . Here $f$ is some neural network architecture that takes in a variable number of inputs and outputs a scalar. We choose the LSTM in our experiment. During the training time, the LSTM is supervised at every time step, since the value prefix can be computed whenever a new state comes in. This per-step rich supervision allows the LSTM can be trained well even with limited data. Compared with the naive per step reward prediction and summation approach, the end-to-end value prefix prediction is more accurate, because it can automatically handle the intermediate state aliasing problem. See Experiment Section 5.3 for empirical evaluations. As a result, it helps the MCTS to explore better, and thus increases the performance. See the Appendix for architectural details.
+
+# 4.3 Model-Based Off-Policy Correction
+
+In MCTS RL algorithms, the value function fits the value of the current neural network policy. However, in practice as MuZero Reanalyze doetrajectory from the replay buffer and computing: $\begin{array} { r } { z _ { t } = \sum _ { i = 0 } ^ { k - 1 } \gamma ^ { i } \dot { u _ { t + i } } + \gamma ^ { k } \dot { v _ { t + k } } } \end{array}$ ted by sampling a. This value target suffers from off-policy issues, since the trajectory is rolled out using an older policy, and thus the value target is no longer accurate. When data is limited, we have to reuse the data sampled from a much older policy, thus exaggerating the inaccurate value target issue.
+
+In previous model-free settings, there is no straightforward approach to fix this issue. On the contrary, since we have a model of the environment, we can use the model to imagine an "online experience". More specifically, we propose to use rewards of a dynamic horizon $l$ from the old trajectory, where $l < k$ and $l$ should be smaller if the trajectory is older. This reduces the policy divergence by fewer rollout steps. Further, we redo an MCTS search with the current policy on the last state $s _ { t + l }$ and compute the empirical mean value at the root node. This effectively corrects the off policy issue using imagined rollouts with current policy and reduces the increased bias caused by setting $l$ less than $k$ . Formally, we propose to use the following value target:
+
+$$
+z _ { t } = \sum _ { i = 0 } ^ { l - 1 } \gamma ^ { i } u _ { t + i } + \gamma ^ { l } \nu _ { t + l } ^ { \mathrm { M C T S } }
+$$
+
+where $l < = k$ and the older the sampled trajectory, the smaller the $l$ . $\nu ^ { \mathrm { M C T S } } ( \mathbf { s } _ { t + l } )$ is the root value of the MCTS tree expanded from $s _ { t + l }$ with the current policy, as MuZero non-Reanalyze does. See the Appendix for how to choose $l$ . In practice, the computation cost of the correction is two times on the reanalyzed side. However, the training will not be affected due to the parallel implementation.
+
+# 5 Experiments
+
+In this section, we aim to evaluate the sample efficiency of the proposed algorithm. Here, the sample efficiency is measured by the performance of each algorithm at a common, small amount of environment transitions, i.e. the better the performance, the higher the sample efficiency. More specifically, we use the Atari 100k benchmark. Intuitively, this benchmark asks the agent to learn to play Atari games within two hours of real-world game time. Additionally, we conduct some ablation studies to investigate and analyze each component on Atari 100k. To further show the sample efficiency, we apply EfficientZero to some simulated robotics environments on the DMControl $1 0 0 \mathrm { k }$ benchmark, which contains the same $1 0 0 \mathrm { k }$ environment steps.
+
+# 5.1 Environments
+
+Atari 100k Atari $1 0 0 \mathrm { k }$ was first proposed by the SimPLe [18] method, and is now used by many sample-efficient RL works, such as Srinivas et al. [35], Laskin et al. [22], Kostrikov et al. [21], Schwarzer et al. [32]. The benchmark contains 26 Atari games, and the diverse set of games can effectively measure the performance of different algorithms. The benchmark allows the agent to interact with 100 thousand environment steps, i.e. 400 thousand frames due to a frameskip of 4, with each environment. $1 0 0 \mathrm { k }$ steps roughly correspond to 2 hours of real-time gameplay, which is far less than the usual RL settings. For example, DQN [24] uses 200 million frames, which is around 925 hours of real-time gameplay. Note that the human player’s performance is tested after allowing the human to get familiar with the game after 2 hours as well. We report the raw performance on each game, as well as the mean and median of the human normalized score. The human normalized score is defined as: $\left( \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 } } \right) / ( \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 } } )$ .
+
+We compare our method to the following baselines. (1) SimPLe [18], a model-based RL algorithm that learns an action conditional video prediction model and trains PPO within the learned environment. (2) OTRainbow [19], which tunes the hyper-parameters of the Rainbow [16] method to achieve higher sample efficiency. (3) CURL [35], which uses contrastive learning as a side task to improve the image representation quality. (4) DrQ [21], which adds data augmentations to the input images while learning the original RL objective. (5) SPR [32], the previous SoTA in Atari $1 0 0 \mathrm { k }$ which proposes to augment the Rainbow [16] agent with data augmentations as well as a multi-step consistency loss using BYOL-style self-supervision. (6) MuZero [27] with our implementations and the same hyper-parameters as EfficientZero. (7) Random Agent (8) Human performance.
+
+DeepMind Control 100k Tassa et al. [37] propose the DMControl suite, which includes some challenging visual robotics tasks with continuous action space. And some works [12, 35] have benchmarked for the sample efficiency on the DMControl $1 0 0 \mathrm { k }$ which contains $1 0 0 \mathrm { k }$ environment steps data. Since the MCTS-based methods cannot deal with tasks with continuous action space, we discretize each dimension into 5 discrete slots in MuZero [27] and EfficientZero. To avoid the dimension explosion, we evaluate EfficientZero in three low-dimensional tasks.
+
+We compare our method to the following baselines. (1) Pixel SAC, which applies SAC directly to pixels. (2) SAC-AE [42], which combines the SAC and an auto-encoder to handle image-based inputs. (3) State SAC, which applies SAC directly to ground truth low dimensional states rather than the pixels. (4) Dreamer [12], which learns a world model and is trained in dreamed scenarios. (5) CURL [35], the previous SoTA in DMControl 100k. (6) MuZero [27] with action discretizations.
+
+# 5.2 Results
+
+Table 1 shows the results of EfficientZero on the Atari $1 0 0 \mathrm { k }$ benchmark. Normalizing our score with the score of human players, EfficientZero achieves a mean score of 1.904 and a median score of 1.160. As a reference, DQN [24] achieves a mean and median performance of 2.20 and 0.959 on these 26 games. However, it is trained with 500 times more data (200 million frames). For the first time, an agent trained with only 2 hours of game data can outperform the human player in terms of the mean and median performance. Among all games, our method outperforms the human in 14 out of 26 games. Compared with the previous state-of-the-art method (SPR [32]), we are $170 \%$ and $180 \%$ better in terms of mean and median score respectively.
+
+Apart from the Atari games, EffcientZero achieves remarkable results in the simulated tasks with continuous action space. As shown in Table 2, EffcientZero outperforms CURL, the previous SoTA, to a considerable degree and keeps a smaller variance but MuZero cannot work well here. Notably, EfficientZero achieves comparable results to the state SAC, which consumes the ground truth states as input and is considered as the oracles.
+
+Table 1: Scores achieved on the Atari $1 0 0 \mathrm { k }$ benchmark (32 seeds). EfficientZero achieves superhuman performance with only 2 hours of real-time game play. Our method is $170 \%$ and $180 \%$ better than the previous SoTA performance, in mean and median human normalized score respectively.   
+
+<table><tr><td>Game</td><td>Random</td><td>Human</td><td>SimPLe</td><td>OTRainbow</td><td>CURL</td><td>DrQ</td><td>SPR</td><td>MuZero</td><td>Ours</td></tr><tr><td>Alien</td><td>227.8</td><td>7127.7</td><td>616.9</td><td>824.7</td><td>558.2</td><td>771.2</td><td>801.5</td><td>530.0</td><td>1140.3</td></tr><tr><td>Amidar</td><td>5.8</td><td>1719.5</td><td>88.0</td><td>82.8</td><td>142.1</td><td>102.8</td><td>176.3</td><td>38.8</td><td>101.9</td></tr><tr><td>Assault</td><td>222.4</td><td>742.0</td><td>527.2</td><td>351.9</td><td>600.6</td><td>452.4</td><td>571.0</td><td>500.1</td><td>1407.3</td></tr><tr><td>Asterix</td><td>210.0</td><td>8503.3</td><td>1128.3</td><td>628.5</td><td>734.5</td><td>603.5</td><td>977.8</td><td>1734.0</td><td>16843.8</td></tr><tr><td>Bank Heist</td><td>14.2</td><td>753.1</td><td>34.2</td><td>182.1</td><td>131.6</td><td>168.9</td><td>380.9</td><td>192.5</td><td>361.9</td></tr><tr><td>BattleZone</td><td>2360.0</td><td>37187.5</td><td>5184.4</td><td>4060.6</td><td>14870.0</td><td>12954.0</td><td>16651.0</td><td>7687.5</td><td>17938.0</td></tr><tr><td>Boxing</td><td>0.1</td><td>12.1</td><td>9.1</td><td>2.5</td><td>1.2</td><td>6.0</td><td>35.8</td><td>15.1</td><td>44.1</td></tr><tr><td>Breakout</td><td>1.7</td><td>30.5</td><td>16.4</td><td>9.8</td><td>4.9</td><td>16.1</td><td>17.1</td><td>48.0</td><td>406.5</td></tr><tr><td>ChopperCmd</td><td>811.0</td><td>7387.8</td><td>1246.9</td><td>1033.3</td><td>1058.5</td><td>780.3</td><td>974.8</td><td>1350.0</td><td>1794.0</td></tr><tr><td>Crazy Climber</td><td>10780.5</td><td>35829.4</td><td>62583.6</td><td>21327.8</td><td>12146.5</td><td>20516.5</td><td>42923.6</td><td>56937.0</td><td>80125.3</td></tr><tr><td>Demon Attack</td><td>152.1</td><td>1971.0</td><td>208.1</td><td>711.8</td><td>817.6</td><td>1113.4</td><td>545.2</td><td>3527.0</td><td>13298.0</td></tr><tr><td>Freeway</td><td>0.0</td><td>29.6</td><td>20.3</td><td>25.0</td><td>26.7</td><td>9.8</td><td>24.4</td><td>21.8</td><td>21.8</td></tr><tr><td>Frostbite</td><td>65.2</td><td>4334.7</td><td>254.7</td><td>231.6</td><td>1181.3</td><td>331.1</td><td>1821.5</td><td>255.0</td><td>313.8</td></tr><tr><td>Gopher</td><td>257.6</td><td>2412.5</td><td>771.0</td><td>778.0</td><td>669.3</td><td>636.3</td><td>715.2</td><td>1256.0</td><td>3518.5</td></tr><tr><td>Hero</td><td>1027.0</td><td>30826.4</td><td>2656.6</td><td>6458.8</td><td>6279.3</td><td>3736.3</td><td>7019.2</td><td>3095.0</td><td>8530.1</td></tr><tr><td>Jamesbond</td><td>29.0</td><td>302.8</td><td>125.3</td><td>112.3</td><td>471.0</td><td>236.0</td><td>365.4</td><td>87.5</td><td>459.4</td></tr><tr><td>Kangaroo</td><td>52.0</td><td>3035.0</td><td>323.1</td><td>605.4</td><td>872.5</td><td>940.6</td><td>3276.4</td><td>62.5</td><td>962.0</td></tr><tr><td>Krull</td><td>1598.0</td><td>2665.5</td><td>4539.9</td><td>3277.9</td><td>4229.6</td><td>4018.1</td><td>3688.9</td><td>4890.8</td><td>6047.0</td></tr><tr><td>Kung Fu Master</td><td>258.5</td><td>22736.3</td><td>17257.2</td><td>5722.2</td><td>14307.8</td><td>9111.0</td><td>13192.7</td><td>18813.0</td><td>31112.5</td></tr><tr><td>Ms Pacman</td><td>307.3</td><td>6951.6</td><td>1480.0</td><td>941.9</td><td>1465.5</td><td>960.5</td><td>1313.2</td><td>1265.6</td><td>1387.0</td></tr><tr><td>Pong</td><td>-20.7</td><td>14.6</td><td>12.8</td><td>1.3</td><td>-16.5</td><td>-8.5</td><td>-5.9</td><td>-6.7</td><td>20.6</td></tr><tr><td>Private Eye</td><td>24.9</td><td>69571.3</td><td>58.3</td><td>100.0</td><td>218.4</td><td>-13.6</td><td>124.0</td><td>56.3</td><td>100.0</td></tr><tr><td>Qbert</td><td>163.9</td><td>13455.0</td><td>1288.8</td><td>509.3</td><td>1042.4</td><td>854.4</td><td>669.1</td><td>3952.0</td><td>15458.1</td></tr><tr><td>Road Runner</td><td>11.5</td><td>7845.0</td><td>5640.6</td><td>2696.7</td><td>5661.0</td><td>8895.1</td><td>14220.5</td><td>2500.0</td><td>18512.5</td></tr><tr><td>Seaquest</td><td>68.4</td><td>42054.7</td><td>683.3</td><td>286.9</td><td>384.5</td><td>301.2</td><td>583.1</td><td>208.0</td><td>1020.5</td></tr><tr><td>Up N Down</td><td>533.4</td><td>11693.2</td><td>3350.3</td><td>2847.6</td><td>2955.2</td><td>3180.8</td><td>28138.5</td><td>2896.9</td><td>16095.7</td></tr><tr><td>Normed Mean</td><td>0.000</td><td>1.000</td><td>0.443</td><td>0.264</td><td>0.381</td><td>0.357</td><td>0.704</td><td>0.562</td><td>1.904</td></tr><tr><td>Normed Median</td><td>0.000</td><td>1.000</td><td>0.144</td><td>0.204</td><td>0.175</td><td>0.268</td><td>0.415</td><td>0.227</td><td>1.160</td></tr></table>
+
+Table 2: Scores achieved by EfficientZero (mean & standard deviation for 10 seeds) and some baselines on some low-dimensional environments on the DMControl $1 0 0 \mathrm { k }$ benchmark. EfficientZero achieves state-of-art performance and comparable results to the state-based SAC.   
+
+<table><tr><td>Task</td><td>CURL</td><td>Dreamer</td><td>MuZero</td><td>SAC-AE</td><td>Pixel SAC</td><td>State SAC</td><td>EfficientZero</td></tr><tr><td>Cartpole,Swingup</td><td>582±146</td><td>326±27</td><td>218.5± 122</td><td>311±11</td><td>419±40</td><td>835±22</td><td>813±19</td></tr><tr><td>Reacher,Easy</td><td>538±233</td><td>314±155</td><td>493±145</td><td>274±14</td><td>145±30</td><td>746±25</td><td>952±34</td></tr><tr><td>Ball in cup, Catch</td><td>769±43</td><td>246±174</td><td>542±270</td><td>391±82</td><td>312±63</td><td>746±91</td><td>942±17</td></tr></table>
+
+# 5.3 Ablations
+
+In Section 4, we discuss three issues that prevent MuZero from achieving high performance when data is limited: (1) the lack of environment model supervision, (2) the state aliasing issue, and (3) the off-policy target value issue. We propose three corresponding approaches to fix those issues and demonstrate the usefulness of the combination of those approaches on a wide range of 26 Atari games. In this section, we will analyze each component individually.
+
+Each Component Firstly, we do an ablation study by removing the three components from our full model one at a time. As shown in Table 3, we find that removing any one of the three components will lead to a performance drop compared to our full model. Furthermore, the richer learning signals are the aspect Muzero lacks most in the low-data regime as the largest performance drop is from the version without consistency supervision. As for the performance in the high-data regime, We find that the temporal consistency can significantly accelerate the training. The value prefix seems to be helpful during the early learning process, but not as much in the later stage. The off-policy correction is not necessary as it is specifically designed under limited data.
+
+Table 3: Ablations of the self-supervised consistency, end-to-end value prefix and model-based off-policy correction. We remove one component at a time and evaluate the corresponding version on the 26 Atari games. Each component matters and the consistency one is the most significant. The detailed results are attached in the Appendix .
+
+![](images/4ecbcf3cc144e1cde8b6c22e795ea15b3351dea8d776da307c00886179a05801.jpg)  
+Figure 4: Evaluations of image reconstructions based on latent states extracted from the model with or without self-supervised consistency. The predicted next states with consistency can basically be reconstructed into observations while the ones without consistency cannot.
+
+Temporal Consistency As the version without self-supervised consistency cannot work well in most of the games, we attempt to dig into the reason for such phenomenon. We design a decoder $\mathcal { D }$ to reconstruct the original observations, taking the latent states as inputs. Specifically, the architecture of $\mathcal { D }$ and the $\mathcal { H }$ are symmetrical, which means that all the convolutional layers are replaced by deconvolutional layers in $\mathcal { D }$ and the order of the layers are reversed in $\mathcal { D }$ . Therefore, $\mathcal { H }$ is an encoder to obtain state $s _ { t }$ from observation $o _ { t }$ and $\mathcal { D }$ tries to decode the $o _ { t }$ from $s _ { t }$ . In this ablation, we freeze all parameters of the trained EfficientZero network with or without consistency respectively and the reconstructed results are shown in different columns of Figure 4. We regard the decoder as a tool to visualize the current states and unrolled states, shown in different rows of Figure 4. Here we note that $\mathcal { M } _ { \mathrm { c o n } }$ is the trained EfficientZero model with consistency and $\mathcal { M } _ { \mathrm { n o n } }$ is the one without consistency.
+
+As shown in Figure 4, in terms of the current state $s _ { t }$ , the observation is reconstructed well enough in the two versions. However, it is remarkable that the the decoder given $\mathcal { M } _ { \mathrm { n o n } }$ can not reconstruct images from the unrolled predicted states $\hat { s } _ { t + k }$ while the one given $\mathcal { M } _ { \mathrm { c o n } }$ can reconstruct the basic observations.
+
+To sum up, there are some distributional shifts between the latent states from the representation network and the states from the dynamics function without consistency. The consistency component can reduce the shift and provide more supervision for training the dynamics network.
+
+Value Prefix We further validate our assumptions in the end-to-end learning of value prefix, i.e. the state aliasing problem will cause difficulty in predicting the reward, and end-to-end learning of value prefix can alleviate this phenomenon.
+
+To fairly compare directly predicting the reward versus end-to-end learning of the value prefix, we need to control for the dataset that both methods are trained on. Since during the RL training, the dataset distribution is determined by the method, we opt to load a half-trained Pong model and rollout total 100k steps as the common static dataset. We split this dataset into a training set and a validation set. Then we run both the direct reward prediction and the value prefix method on the training split.
+
+As shown in Figure 5, we find that the direct reward prediction method has lower losses on the training set. However, the value prefix’s validation error is much smaller when unrolled for 5 steps. This shows that the value prefix method avoids overfitting the hard reward prediction problem, and thus it can reduce the state aliasing problem, reaching a better generalization performance.
+
+![](images/4d23ee87506b65df4a9420948f07fb6598dc58edfaab7310c37175b84f3385c9.jpg)  
+Figure 5: Training and validation losses of direct reward prediction method and the value prefix method.
+
+# Off-Policy Correction To prove
+
+the effectiveness of the off-policy correction component, we compare the error between the target values and the ground truth values with or without off-policy correction. Specifically, the ground truth values are estimated by Monte Carlo sampling.
+
+We train a model for the game UpNDown with total 100k training steps, and collect the trajectories at different training stages respectively (20k, 40k, ..., 100k steps). Then we calculate the ground truth values with the final model. We choose the trajectories at the same stage (20k) and use the final model to evaluate the target values with or without off-policy correction, following the Equation 4. We evaluate the L1 error of the target values and the ground truth, as shown in Table 4. The error of unrolled next 5 states means the average error of the unrolled 1-5 states with dynamics network from current states. The error is smaller in both current states and the unrolled states with off-policy correction. Thus, the correction component does reduce the bias caused by the off-policy issue.
+
+Table 4: Ablations of the off-policy correction: L1 error of the target values versus the ground truth values. Take UpNDown as an example.   
+
+<table><tr><td>States</td><td>Current state </td><td>Unrolled next 5 states (Avg.）All states (Avg.)</td><td></td></tr><tr><td>Value error without correction</td><td>0.765</td><td>0.636</td><td>0.657</td></tr><tr><td>Value error with correction</td><td>0.533</td><td>0.576</td><td>0.569</td></tr></table>
+
+Furthermore, we also ablate the value error of the trajectories at distinct stages in Table 5. We can find that the value error becomes smaller as the trajectories are fresher. This indicates that the off-policy issue is severe due to the staleness of the data. More significantly, the off-policy correction can provide more accurate target value estimation for the trajectories at distinct time-steps as all the errors with correction shown in the table are smaller than those without correction at the same stage.
+
+Table 5: Ablations of the off-policy correction: Average L1 error of the values of the trajectories at distinct stages. Take UpNDown as an example.   
+
+<table><tr><td>Stages of trajectories</td><td>20k</td><td>40k</td><td>60k</td><td>80k</td><td>100k</td></tr><tr><td>Value error without correction</td><td>0.657</td><td>0.697</td><td>0.628</td><td>0.574</td><td>0.441</td></tr><tr><td>Value error with correction</td><td>0.569</td><td>0.552</td><td>0.537</td><td>0.488</td><td>0.397</td></tr></table>
+
+# 6 Discussion
+
+In this paper, we propose a sample-efficient model-based method EfficientZero. It achieves superhuman performance on the Atari games with as little as 2 hours of the gameplay experience and state-of-the-art performance on some DMControl tasks. Apart from the full results, we do detailed ablation studies to examine the effectiveness of the proposed components. This work is one step towards running RL in the physical world with complex sensory inputs. In the future, we plan to extend it to more directions, such as a better design for the continuous action space. And we also plan to study the acceleration of MCTS and how to combine this framework with life-long learning.
+
+# Acknowledgments and Disclosure of Funding
+
+This work is supported by the Ministry of Science and Technology of the People’s Republic of China, the 2030 Innovation Megaprojects “Program on New Generation Artificial Intelligence” (Grant No. 2021AAA0150000).
+
+# References
+
+[1] Bruce Abramson. The expected-outcome model of two-player games. Morgan Kaufmann, 2014.   
+[2] Kavosh Asadi, Dipendra Misra, Seungchan Kim, and Michel L Littman. Combating the compounding-error problem with a multi-step model. arXiv preprint arXiv:1905.13320, 2019.   
+[3] Peter Auer, Nicolo Cesa-Bianchi, and Paul Fischer. Finite-time analysis of the multiarmed bandit problem. Machine learning, 47(2):235–256, 2002.   
+[4] Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013.   
+[5] Christopher Berner, Greg Brockman, Brooke Chan, Vicki Cheung, Przemysław D˛ebiak, Christy Dennison, David Farhi, Quirin Fischer, Shariq Hashme, Chris Hesse, et al. Dota 2 with large scale deep reinforcement learning. arXiv preprint arXiv:1912.06680, 2019.   
+[6] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In International conference on machine learning, pages 1597–1607. PMLR, 2020.   
+[7] Xinlei Chen and Kaiming He. Exploring simple siamese representation learning. arXiv preprint arXiv:2011.10566, 2020.   
+[8] Kurtland Chua, Roberto Calandra, Rowan McAllister, and Sergey Levine. Deep reinforcement learning in a handful of trials using probabilistic dynamics models. arXiv preprint arXiv:1805.12114, 2018.   
+[9] Joery A de Vries, Ken S Voskuil, Thomas M Moerland, and Aske Plaat. Visualizing muzero models. arXiv preprint arXiv:2102.12924, 2021.   
+[10] Marc Deisenroth and Carl E Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In Proceedings of the 28th International Conference on machine learning (ICML-11), pages 465–472. Citeseer, 2011.   
+[11] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020.   
+[12] Danijar Hafner, Timothy Lillicrap, Jimmy Ba, and Mohammad Norouzi. Dream to control: Learning behaviors by latent imagination. arXiv preprint arXiv:1912.01603, 2019.   
+[13] Danijar Hafner, Timothy Lillicrap, Ian Fischer, Ruben Villegas, David Ha, Honglak Lee, and James Davidson. Learning latent dynamics for planning from pixels. In International Conference on Machine Learning, pages 2555–2565. PMLR, 2019.   
+[14] Danijar Hafner, Timothy Lillicrap, Mohammad Norouzi, and Jimmy Ba. Mastering atari with discrete world models. arXiv preprint arXiv:2010.02193, 2020.   
+[15] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9729–9738, 2020.
+
+[16] Matteo Hessel, Joseph Modayil, Hado Van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Dan Horgan, Bilal Piot, Mohammad Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018.
+
+[17] Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Mohammadamin Barekatain, Simon Schmitt, and David Silver. Learning and planning in complex action spaces. arXiv preprint arXiv:2104.06303, 2021.
+
+[18] Lukasz Kaiser, Mohammad Babaeizadeh, Piotr Milos, Blazej Osinski, Roy H Campbell, Konrad Czechowski, Dumitru Erhan, Chelsea Finn, Piotr Kozakowski, Sergey Levine, et al. Modelbased reinforcement learning for atari. arXiv preprint arXiv:1903.00374, 2019.
+
+[19] Kacper Kielak. Do recent advancements in model-based deep reinforcement learning really improve data efficiency? arXiv preprint arXiv:2003.10181, 2020.
+
+[20] Levente Kocsis and Csaba Szepesvári. Bandit based monte-carlo planning. In European conference on machine learning, pages 282–293. Springer, 2006.
+
+[21] Ilya Kostrikov, Denis Yarats, and Rob Fergus. Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. arXiv preprint arXiv:2004.13649, 2020.
+
+[22] Michael Laskin, Kimin Lee, Adam Stooke, Lerrel Pinto, Pieter Abbeel, and Aravind Srinivas. Reinforcement learning with augmented data. arXiv preprint arXiv:2004.14990, 2020.
+
+[23] 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.
+
+[24] 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.
+
+[25] 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, pages 1928–1937. PMLR, 2016.
+
+[26] Christopher D Rosin. Multi-armed bandits with episode context. Annals of Mathematics and Artificial Intelligence, 61(3):203–230, 2011.
+
+[27] Julian Schrittwieser, Ioannis Antonoglou, Thomas Hubert, Karen Simonyan, Laurent Sifre, Simon Schmitt, Arthur Guez, Edward Lockhart, Demis Hassabis, Thore Graepel, et al. Mastering atari, go, chess and shogi by planning with a learned model. Nature, 588(7839):604–609, 2020.
+
+[28] Julian Schrittwieser, Thomas Hubert, Amol Mandhane, Mohammadamin Barekatain, Ioannis Antonoglou, and David Silver. Online and offline reinforcement learning by planning with a learned model. arXiv preprint arXiv:2104.06294, 2021.
+
+[29] John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International conference on machine learning, pages 1889–1897. PMLR, 2015.
+
+[30] John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. arXiv preprint arXiv:1506.02438, 2015.
+
+[31] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+[32] Max Schwarzer, Ankesh Anand, Rishab Goel, R Devon Hjelm, Aaron Courville, and Philip Bachman. Data-efficient reinforcement learning with self-predictive representations.
+
+[33] David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016.   
+[34] David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. nature, 550(7676):354–359, 2017.   
+[35] Aravind Srinivas, Michael Laskin, and Pieter Abbeel. Curl: Contrastive unsupervised representations for reinforcement learning. arXiv preprint arXiv:2004.04136, 2020.   
+[36] Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.   
+[37] Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, et al. Deepmind control suite. arXiv preprint arXiv:1801.00690, 2018.   
+[38] Hado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double q-learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 30, 2016.   
+[39] Hado van Hasselt, Matteo Hessel, and John Aslanides. When to use parametric models in reinforcement learning? arXiv preprint arXiv:1906.05243, 2019.   
+[40] Ziyu Wang, Tom Schaul, Matteo Hessel, Hado Hasselt, Marc Lanctot, and Nando Freitas. Dueling network architectures for deep reinforcement learning. In International conference on machine learning, pages 1995–2003. PMLR, 2016.   
+[41] Christopher John Cornish Hellaby Watkins. Learning from delayed rewards. 1989.   
+[42] Denis Yarats, Amy Zhang, Ilya Kostrikov, Brandon Amos, Joelle Pineau, and Rob Fergus. Improving sample efficiency in model-free reinforcement learning from images. arXiv preprint arXiv:1910.01741, 2019.

parse/train/OKrNPg3xR3T/OKrNPg3xR3T_content_list.json

@@ -0,0 +1,1401 @@
+[
+    {
+        "type": "text",
+        "text": "Mastering Atari Games with Limited Data ",
+        "text_level": 1,
+        "bbox": [
+            238,
+            122,
+            758,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Weirui $\\mathbf { Y e ^ { * } }$ Shaohuai Liu∗ Thanard Kurutach† Pieter Abbeel† Yang Gao∗‡ ∗Tsinghua University, †UC Berkeley, ‡ Shanghai Qi Zhi Institute ",
+        "bbox": [
+            218,
+            199,
+            774,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            265,
+            535,
+            282
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning has achieved great success in many applications. However, sample efficiency remains a key challenge, with prominent methods requiring millions (or even billions) of environment steps to train. Recently, there has been significant progress in sample efficient image-based RL algorithms; however, consistent human-level performance on the Atari game benchmark remains an elusive goal. We propose a sample efficient model-based visual RL algorithm built on MuZero, which we name EfficientZero. Our method achieves $1 9 0 . 4 \\%$ mean human performance and $1 1 6 . 0 \\%$ median performance on the Atari 100k benchmark with only two hours of real-time game experience and outperforms the state SAC in some tasks on the DMControl $1 0 0 \\mathrm { k }$ benchmark. This is the first time an algorithm achieves super-human performance on Atari games with such little data. EfficientZero’s performance is also close to DQN’s performance at 200 million frames while we consume 500 times less data. EfficientZero’s low sample complexity and high performance can bring RL closer to real-world applicability. We implement our algorithm in an easy-to-understand manner and it is available at https://github.com/YeWR/EfficientZero. We hope it will accelerate the research of MCTS-based RL algorithms in the wider community. ",
+        "bbox": [
+            232,
+            299,
+            766,
+            534
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/f98dec42a45f80d9891aae47ec142d8d3011715700cf3b3945241f3407eaf192.jpg",
+        "image_caption": [
+            "Figure 1: Our proposed method EfficientZero is $170 \\%$ and $180 \\%$ better than the previous SoTA performance in mean and median human normalized score and is the first to outperform the average human performance on the Atari $1 0 0 \\mathrm { k }$ benchmark. The high sample efficiency and performance of EfficientZero can bring RL closer to the real-world applications. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            546,
+            761,
+            642
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            729,
+            310,
+            747
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning has achieved great success on many challenging problems. Notable work includes DQN [24], AlphaGo [33] and OpenAI Five [5]. However, most of these works come at the cost of a large number of environmental interactions. For example, AlphaZero [34] needs to play 21 million games at training time. On the contrary, a professional human player can only play around 5 games per day, meaning it would take a human player 11,500 years to achieve the same amount of experience. The sample complexity might be less of an issue when applying RL algorithms in simulation and games. However, when it comes to real-world problems, such as robotic manipulation, healthcare, and advertisement recommendation systems, achieving high performance while maintaining low sample complexity is the key to viability. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            859
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "People have made a lot of progress in sample efficient RL in the past years [8, 10, 35, 22, 21, 32, 18]. Among them, model-based methods have attracted a lot of attention, since both the data from real environments and the “imagined data” from the model can be used to train the policy, making these methods particularly sample-efficient [8, 10]. However, most of the successes are in state-based environments. In image-based environments, some model-based methods such as MuZero [27] and Dreamer V2 [14] achieve super-human performance, but they are not sample efficient; other methods such as SimPLe [18] is quite efficient but achieve inferior performance (0.144 human normalized median scores). Recently, data-augmented and self-supervised methods applied to modelfree methods have achieved more success in the data-efficient regime [32]. However, they still fail to achieve the levels which can be expected of a human. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Therefore, for improving the sample efficiency as well as keeping superior performance, we find the following three components are essential to the model-based visual RL agent: a self-supervised environment model, a mechanism to alleviate the model compounding error, and a method to correct the off-policy issue. In this work, we propose EfficientZero, a model-based RL algorithm that achieves high performance with limited data. Our proposed method is built on MuZero. We make three critical changes: (1) use self-supervised learning to learn a temporally consistent environment model, (2) learn the value prefix in an end-to-end manner, thus helping to alleviate the compounding error in the model, (3) use the learned model to correct off-policy value targets. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            381
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As illustrated as Figure 1, our model achieves state-of-the-art performance on the widely used Atari [4] 100k benchmark and it achieves super-human performance with only 2 hours of real-time gameplay. More specifically, our model achieves $1 9 0 . 4 \\%$ mean human normalized performance and $1 1 6 . 0 \\%$ median human normalized performance. As a reference, DQN [24] achieves $220 \\%$ mean human normalized performance, and $96 \\%$ median human normalized performance, at the cost of 500 times more data (200 million frames). To further verify the effectiveness of EfficientZero, we conduct experiments on some simulated robotics environments of the DeepMind Control (DMControl) suite. It achieves state-of-the-art performance and outperforms the state SAC which directly learns from the ground truth states. Our sample efficient and high-performance algorithm opens the possibility of having more impact on many real-world problems. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            526
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            547,
+            321,
+            564
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Sample Efficient Reinforcement Learning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            580,
+            501,
+            595
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Sample efficiency has attracted significant work in the past. In RL with image inputs, model-based approaches [13, 12] which model the world with both a stochastic and a deterministic component, have achieved promising results for simulated robotic control. Kaiser et al. [18] propose to use an action-conditioned video prediction model, along with a policy learning algorithm. It achieves the first strong performance on Atari games with as little as $4 0 0 \\mathrm { k }$ frames. However, Kielak [19] and van Hasselt et al. [39] argue that this is not necessary to achieve strong results with model-based methods, and they show that when tuned appropriately, Rainbow [16] can achieve comparable results. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            704
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recent advances in self-supervised learning, such as SimCLR [6], MoCo [15], SimSiam [7] and BYOL [11] have inspired representation learning in image-based RL. Srinivas et al. [35] propose to use contrastive learning in RL algorithms and their work achieves strong performance on image-based continuous and discrete control tasks. Later, Laskin et al. [22] and Kostrikov et al. [21] find that contrastive learning is not necessary, but with data augmentations alone, they can achieve better performance. Schwarzer et al. [32] propose a temporal consistency loss, which is combined with data augmentations and achieves state-of-the-art performance. Notably, our self-supervised consistency loss is quite similar to Schwarzer et al. [32], except we use SimSiam [6] while they use BYOL [11] as the base self-supervised learning framework. However, Schwarzer et al. [32] only apply the learned representations in a model-free manner, while we combine the learned model with model-based exploration and policy improvement, thus leading to more efficient use of the environment model. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Despite the recent progress in the sample-efficient RL, today’s RL algorithms are still well behind human performance when the amount of data is limited. Although traditional model-based RL is considered more sample efficient than model-free ones, current model-free methods dominate in terms of performance for image-input settings. In this paper, we propose a model-based RL algorithm that for the first time, achieves super-human performance on Atari games with limited data. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Reinforcement Learning with MCTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            137,
+            468,
+            152
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Temporal difference learning [24, 38, 40, 16] and policy gradient based methods [25, 23, 29, 31] are two types of popular reinforcement learning algorithms. Recently, Silver et al. [33] propose to use MCTS as a policy improvement operator and has achieved great success in many board games, such as Go, Chess, and Shogi [34]. Later, the algorithm is adapted to learn the world model at the same time [27]. It has also been extended to deal with continuous action spaces [17] and offline data [28]. These MCTS RL algorithms are a hybrid of model-based learning and model-free learning. ",
+        "bbox": [
+            174,
+            162,
+            825,
+            246
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, most of them are trained with a lot of environmental samples. Our method is built on top of MuZero [27], and we demonstrate that our method can achieve higher sample efficiency while still achieving competitive performance on the Atari $1 0 0 \\mathrm { k }$ benchmark. de Vries et al. [9] have studied the potential of using auxiliary loss similar to our self-supervised consistency loss. However, they only test on two low dimensional state-based environments and find the auxiliary loss has mixed effects on the performance. On the contrary, we find that the consistency loss is critical in most environments with high dimensional observations and limited data. ",
+        "bbox": [
+            174,
+            253,
+            825,
+            349
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 Multi-Step Value Estimation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            367,
+            411,
+            382
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In Q-learning [41], the target Q vaincorporating multiple steps of re s computed bys at once, i.e. $z _ { t } = \\bar { \\sum _ { i = 0 } ^ { k - 1 } } \\gamma ^ { i } \\bar { u } _ { t + i } \\stackrel {  } { + } \\gamma ^ { k } v _ { t + k }$ people fi, where $u _ { t + i }$ atis $v _ { t + k }$ the value target $z _ { t }$ leads to faster convergence [24, 16]. However, the use of multi-step value has off-policy issues, since $u _ { t + i }$ are not generated by the current policy. In practice, this issue is usually ignored when there is a large amount of data since the data can be thought as approximately on-policy. $\\mathrm { T D } ( \\lambda )$ [36] and GAE [30] improve the value estimation by better trading off the bias and the variance, but they do not deal with the off-policy issue. Recently, image input model-based algorithms such as Kaiser et al. [18] and Hafner et al. [12] use model imaginary rollouts to avoid the off-policy issue. However, this approach has the risk of model exploitation. Asadi et al. [2] proposed a multi-step model to combat the compounding error. Our proposed model-based off-policy correction method starts from the rewards in the real-world experience and uses model-based value estimate to bootstrap. Our approach balances between the off-policy issue and model exploitation. ",
+        "bbox": [
+            173,
+            393,
+            826,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            597,
+            308,
+            614
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 MuZero ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            630,
+            269,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our method is built on top of the MuZero Reanalyze [27] algorithm. For brevity, we refer to it as MuZero throughout the paper. MuZero is a policy learning method based on the Monte-Carlo Tree Search (MCTS) algorithm. The MCTS algorithm operates with an environment model, a prior policy function, and a value function. The environment model is represented as the reward function $\\mathcal { R }$ and the dynamic function $\\mathcal { G }$ : $r _ { t } = \\mathcal { R } ( s _ { t } , a _ { t } )$ , $\\hat { s } _ { t + 1 } = \\mathcal G ( s _ { t } , a _ { t } )$ , which are needed when MCTS expands a new node. In MuZero, the environment model is learned. Thus the reward and the next state are approximated. Besides, the predicted policy $p _ { t } =$ acts as a search prior over actions of a node. It helps the MCTS focus on more promising actions when expanding the node. MCTS also needs a value function $\\mathcal { V } ( s _ { t } )$ that measures the expected return of the node $s _ { t }$ , which provides a long-term evaluation of the tree’s leaf node without further search. MCTS will output an action visit distribution $\\pi _ { t }$ over the root node, which is potentially a better policy, compared to the current neural network. Thus, the MCTS algorithm can be thought of as a policy improvement operator. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In practice, the environment model, policy function, and value function operate on a hidden abstract state $s _ { t }$ , both for computational efficiency and ease of environment modeling. The abstract state is extracted by a representation function $\\mathcal { H }$ on observations $o _ { t }$ : $s _ { t } = \\mathcal { H } ( o _ { t } )$ . All of the mentioned models above are usually represented as neural networks. During training, the algorithm collects roll-out data in the environment using MCTS, resulting in potentially higher quality data than the current neural network policy. The data is stored in a replay buffer. The optimizer minimizes the following loss on the data sampled from the replay buffer: ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            555,
+            106
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/79fdccf82c7c7f164e85d5e3a62a699fe45fa4126403e95cebc5b9cdd61a779e.jpg",
+        "text": "$$\n\\mathcal { L } ( u _ { t } , r _ { t } ) + \\lambda _ { 1 } \\mathcal { L } ( \\pi _ { t } , p _ { t } ) + \\lambda _ { 2 } \\mathcal { L } ( z _ { t } , v _ { t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            111,
+            627,
+            128
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, visit c $u _ { t }$ is the reward from the ennt distribution of the MCT $r _ { t } = \\mathcal { R } ( s _ { t } , a _ { t } )$ is the predted policy, $\\pi _ { t }$ $p _ { t } = \\mathcal { P } ( s _ { t } )$ $\\begin{array} { r } { z _ { t } = \\sum _ { i = 0 } ^ { k - 1 } \\gamma ^ { i } u _ { t + i } + \\gamma ^ { k } v _ { t + k } } \\end{array}$ $v _ { t } = \\mathcal { V } ( s _ { t } )$   \n$\\mathcal { R }$ , policy function $\\mathcal { P }$ , value function $\\nu$ , the representation function $\\mathcal { H }$ and the dynamics function $\\mathcal { G }$   \nare trainable neural networks. It is worth noting that MuZero does not explicitly learn the environment   \nmodel. Instead, it solely relies on the reward, value, and policy prediction to learn the model. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            222
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Monte-Carlo Tree Search ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            236,
+            390,
+            251
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Monte-Carlo Tree Search [1, 33, 34, 14], or MCTS, is a heuristic search algorithm. In our setup, MCTS is used to find an action policy that is better than the current neural network policy. ",
+        "bbox": [
+            174,
+            262,
+            823,
+            290
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "More specifically, MCTS needs an environment model, including the reward function and the nextstate function. It also needs a value function and a policy function, which act as heuristics for the tree search. MCTS operates by expanding a search tree from the current node. It saves computation by selectively expanding a few nodes. In order to find a high-quality decision, the tree expansion process has to balance between exploration versus exploitation, i.e. balance between expanding a node that is promising with many visits versus expanding a node with lower performance but fewer visits. MCTS employs the UCT [26, 20] rule, i.e. UCB [3] on trees. At every node expansion step, UCT will select a node as follows [14]: ",
+        "bbox": [
+            173,
+            295,
+            826,
+            409
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/758fb6e9a11dee53199730ba4b9619edb8d24314479edbcc23af529f7e9ce9f6.jpg",
+        "text": "$$\na ^ { k } = \\arg \\operatorname* { m a x } _ { a } \\left\\{ Q ( s , a ) + P ( s , a ) { \\frac { \\sqrt { \\sum _ { b } N ( s , b ) } } { 1 + N ( s , a ) } } \\left( c _ { 1 } + \\log \\left( { \\frac { \\sum _ { b } N ( s , b ) + c _ { 2 } + 1 } { c _ { 2 } } } \\right) \\right) \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            411,
+            784,
+            455
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where, $Q ( s , a )$ is the current estimate of the Q-value, $P ( s , a )$ is the current neural network policy for selecting this action, helping the MCTS prioritize exploring promising part of the tree. During training time, $P ( s , a )$ is usually perturbed by noises to allow explorations. $N ( s , a )$ denotes how many times this state-action pair is visited in the tree search, and $N ( s , b )$ denote that of $a$ ’s siblings. Thus this term will encourage the search to visit the nodes whose siblings are visited often, but itself less visited. Finally, the last term gives a weights to the previous terms. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            544
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After expanding the nodes for a pre-defined number of times, the MCTS will return how many times each action under the root node is visited, as the improved policy to the root node. Thus, MCTS can be considered as a policy improvement operator in the RL setting. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            592
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EfficientZero ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            609,
+            316,
+            627
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Model-based algorithms have achieved great success in sample-efficient learning from lowdimensional states. However, current visual model-based algorithms either require large amounts of training data or exhibit inferior performance to model-free algorithms in data-limited settings [32]. Many previous works even suspect whether model-based algorithms can really offer data efficiency when using image observations [39]. We provide a positive answer here. We propose the EfficientZero, a model-based algorithm built on the MCTS, that achieves super-human performance on the $1 0 0 \\mathrm { k }$ Atari benchmark, outperforming the previous SoTA to a large degree. ",
+        "bbox": [
+            174,
+            641,
+            826,
+            739
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When directly running MCTS-based RL algorithms such as MuZero, we find that they do not perform well on the limited-data benchmark. Through our ablations, we confirm the following three issues which pose challenges to algorithms like MuZero in data-limited settings. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            787
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Lack of supervision on environment model. First, the learned model in the environment dynamics is only trained through the reward, value and policy functions. However, the reward is only a scalar signal and in many scenarios, the reward will be sparse. Value functions are trained with bootstrapping, and thus are noisy. Policy functions are trained with the search process. None of the reward, value and policy losses can provide enough training signals to learn the environment model. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            863
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hardness to deal with aleatoric uncertainty. Second, we find that even with enough data, the predicted rewards still have large prediction errors. This is caused by the aleatoric uncertainty of the underlying environment. For example, the environment is hard to model. The reward prediction errors will accumulate when expanding the MCTS tree to a large depth, resulting in sub-optimal performance in exploration and evaluation. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Off-policy issues of multi-step value. Lastly, when computing the value target, MuZero uses the multi-step reward observed in the environment. Although this allows the reward to be propagated to the value function faster, we find that it suffers from severe off-policy issues and hinders convergence in the limited data scenario. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            181
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To address the above issues, we propose the following three critical modifications, which can greatly improve performance when samples are limited. ",
+        "bbox": [
+            174,
+            188,
+            823,
+            215
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Self-Supervised Consistency Loss ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            233,
+            444,
+            248
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In previous MCTS RL algorithms, the environment model is either given or only trained with rewards, values, and policies, which cannot provide sufficient training signals due to their scalar nature. The problem is more severe when the reward is sparse or the bootstrapped value is not accurate. The MCTS policy improvement operator heavily relies on the environment model. Thus, it is vital to have an accurate one. ",
+        "bbox": [
+            174,
+            260,
+            549,
+            369
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We notice that the output $\\hat { s } _ { t + 1 }$ from the dynamic function $\\mathcal { G }$ should be the same as $s _ { t + 1 }$ , i.e. the output of the representation function $\\mathcal { H }$ with input of the next observation $o _ { t + 1 }$ (Fig. 2). This can help to supervise the predicted next state $\\hat { s } _ { t + 1 }$ using the actual $s _ { t + 1 }$ , which is a tensor with at least a few hundred dimensions. This provides $\\hat { s } _ { t + 1 }$ with much more training signals than the default scalar reward and value. ",
+        "bbox": [
+            174,
+            377,
+            549,
+            487
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/1809716351b1a577cd6cb75c1c6b7ac67defbf923e012a36a9df23ee7e459946.jpg",
+        "image_caption": [
+            "Figure 2: The self-supervised consistency loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            571,
+            272,
+            821,
+            479
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "More specifically, we adopt the recently proposed SimSiam [7] self-supervised framework. SimSiam [7] is a self-supervised method that takes two augmentation views of the same image and pulls the output of the second branch close to that of the first branch, where the first branch is an encoder network without gradient, and the second branch is the same encoder network with the gradient and a predictor head. The predictor head can simply be a two-layer MLP. ",
+        "bbox": [
+            174,
+            494,
+            550,
+            536
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            536,
+            825,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that SimSiam only learns the representation of individual images, and is not aware of how different images are connected. The learned image representations of SimSiam might not be a good candidate for learning the environment transition function, since adjacent observations might be encoded to very different representation encodings. We propose a self-supervised method that learns the transition function, along with the image representation function in an end-to-end manner. Figure 2 shows our method. Since we aim to learn the transition between adjacent observations, we pull $o _ { t }$ and $o _ { t + 1 }$ close to each other. The transition function is applied after the representation of $o _ { t }$ , such that $s _ { t }$ is transformed to $\\hat { s } _ { t + 1 }$ , which now represents the same entity as the other branch. Then both of $s _ { t + 1 }$ and $\\hat { s } _ { t + 1 }$ go through a common projector network. Since $s _ { t + 1 }$ is potentially a more accurate description of $o _ { t + 1 }$ compared to $\\hat { s } _ { t + 1 }$ , we make the $o _ { t + 1 }$ branch as the target branch. It is common in self-supervised learning that the second or the third layer from the last is chosen as the features for some reason. Here, we choose the outputs from the representation network or the dynamics network as the hidden states rather than those from the projector or the predictor. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The two adjacent observations provide two views of the same entity. In practice, we find that applying augmentations to observations such as a random small shift of 0-4 pixels on the image helps to further improve the learned representation quality [35, 32]. We also unroll the dynamic function recurrently for 5 further steps and also pull $\\hat { s } _ { t + k }$ close to $s _ { t + k }$ $k = 1 , . . . , 5 )$ ). Please see the Appendix for more implementation details. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            839
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 End-To-End Prediction of the Value Prefix ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            857,
+            508,
+            872
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In model-based learning, the agent needs to predict the future states conditioned on the current state and a series of hypothetical actions. The longer the prediction, the harder to predict it accurately, due to the compounding error in the recurrent rollouts. This is called the state aliasing problem. The environment model plays an important role in MCTS. The state aliasing problem harms the MCTS expansion, which will result in sub-optimal exploration as well as sub-optimal action search. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            133
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Predicting the reward from an aliased state is a hard problem. For example, as shown in Figure 3, the right agent loses the ball. If we only see the first observation, along with future actions, it is very hard both for an agent and a human to predict at which exact future timestep the player would lose a point. However, it is easy to predict the agent will miss the ball after a sufficient number of timesteps if he does not ",
+        "bbox": [
+            174,
+            140,
+            485,
+            263
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/85e06f9eaa5501aeec5eec3408712340c7d81a97b5313a5d633a2b0134511504.jpg",
+        "image_caption": [
+            "Figure 3: A sample trajectory from the Atari Pong game. In this case, the right player didn’t move and missed the ball. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            498,
+            146,
+            820,
+            210
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "move. In practice, a human will never try to predict the exact step that he loses the point but will imagine over a longer horizon and thus get a more confident prediction. ",
+        "bbox": [
+            171,
+            263,
+            823,
+            292
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Inspired by this intuition, we propose an end-to-end method to predict the value prefix. We notice that the predicted reward is always used in the estimation of the Q-value $Q ( s , a )$ in UCT of Equation 2 ",
+        "bbox": [
+            173,
+            297,
+            823,
+            327
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/592a16d9d520acd314d92ba69f3329cfb384b80216706ea9e0053b032bbe17d8.jpg",
+        "text": "$$\nQ ( s _ { t } , a ) = \\sum _ { i = 0 } ^ { k - 1 } \\gamma ^ { i } r _ { t + i } + \\gamma ^ { k } v _ { t + k }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            332,
+            607,
+            376
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$r _ { t + i }$ is the reward predicted from unrolled state as the value prefix, since it is used as a prefix i $\\hat { s } _ { t + i }$ . W later name the sum of rewards-value computation. $\\sum _ { i = 0 } ^ { k - 1 } \\gamma ^ { i } r _ { t + i }$ $\\mathrm { Q }$ ",
+        "bbox": [
+            174,
+            380,
+            821,
+            411
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We propose to predict value prefix from the unrolled states $( s _ { t } , \\hat { s } _ { t + 1 } , \\cdot \\cdot \\cdot , \\hat { s } _ { t + k - 1 } )$ in an end-to-end manner, i.e. value-prefix $= f ( s _ { t } , \\hat { s } _ { t + 1 } , \\cdot \\cdot \\cdot , \\hat { s } _ { t + k - 1 } )$ . Here $f$ is some neural network architecture that takes in a variable number of inputs and outputs a scalar. We choose the LSTM in our experiment. During the training time, the LSTM is supervised at every time step, since the value prefix can be computed whenever a new state comes in. This per-step rich supervision allows the LSTM can be trained well even with limited data. Compared with the naive per step reward prediction and summation approach, the end-to-end value prefix prediction is more accurate, because it can automatically handle the intermediate state aliasing problem. See Experiment Section 5.3 for empirical evaluations. As a result, it helps the MCTS to explore better, and thus increases the performance. See the Appendix for architectural details. ",
+        "bbox": [
+            173,
+            416,
+            825,
+            556
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Model-Based Off-Policy Correction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            570,
+            460,
+            587
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In MCTS RL algorithms, the value function fits the value of the current neural network policy. However, in practice as MuZero Reanalyze doetrajectory from the replay buffer and computing: $\\begin{array} { r } { z _ { t } = \\sum _ { i = 0 } ^ { k - 1 } \\gamma ^ { i } \\dot { u _ { t + i } } + \\gamma ^ { k } \\dot { v _ { t + k } } } \\end{array}$ ted by sampling a. This value target suffers from off-policy issues, since the trajectory is rolled out using an older policy, and thus the value target is no longer accurate. When data is limited, we have to reuse the data sampled from a much older policy, thus exaggerating the inaccurate value target issue. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            684
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In previous model-free settings, there is no straightforward approach to fix this issue. On the contrary, since we have a model of the environment, we can use the model to imagine an \"online experience\". More specifically, we propose to use rewards of a dynamic horizon $l$ from the old trajectory, where $l < k$ and $l$ should be smaller if the trajectory is older. This reduces the policy divergence by fewer rollout steps. Further, we redo an MCTS search with the current policy on the last state $s _ { t + l }$ and compute the empirical mean value at the root node. This effectively corrects the off policy issue using imagined rollouts with current policy and reduces the increased bias caused by setting $l$ less than $k$ . Formally, we propose to use the following value target: ",
+        "bbox": [
+            173,
+            689,
+            826,
+            801
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/65637af9d626b74616bd0d282565a648e50a8fed76615148774c0afe6245a132.jpg",
+        "text": "$$\nz _ { t } = \\sum _ { i = 0 } ^ { l - 1 } \\gamma ^ { i } u _ { t + i } + \\gamma ^ { l } \\nu _ { t + l } ^ { \\mathrm { M C T S } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            805,
+            591,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $l < = k$ and the older the sampled trajectory, the smaller the $l$ . $\\nu ^ { \\mathrm { M C T S } } ( \\mathbf { s } _ { t + l } )$ is the root value of the MCTS tree expanded from $s _ { t + l }$ with the current policy, as MuZero non-Reanalyze does. See the Appendix for how to choose $l$ . In practice, the computation cost of the correction is two times on the reanalyzed side. However, the training will not be affected due to the parallel implementation. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            312,
+            107
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we aim to evaluate the sample efficiency of the proposed algorithm. Here, the sample efficiency is measured by the performance of each algorithm at a common, small amount of environment transitions, i.e. the better the performance, the higher the sample efficiency. More specifically, we use the Atari 100k benchmark. Intuitively, this benchmark asks the agent to learn to play Atari games within two hours of real-world game time. Additionally, we conduct some ablation studies to investigate and analyze each component on Atari 100k. To further show the sample efficiency, we apply EfficientZero to some simulated robotics environments on the DMControl $1 0 0 \\mathrm { k }$ benchmark, which contains the same $1 0 0 \\mathrm { k }$ environment steps. ",
+        "bbox": [
+            174,
+            121,
+            825,
+            232
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Environments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            248,
+            310,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Atari 100k Atari $1 0 0 \\mathrm { k }$ was first proposed by the SimPLe [18] method, and is now used by many sample-efficient RL works, such as Srinivas et al. [35], Laskin et al. [22], Kostrikov et al. [21], Schwarzer et al. [32]. The benchmark contains 26 Atari games, and the diverse set of games can effectively measure the performance of different algorithms. The benchmark allows the agent to interact with 100 thousand environment steps, i.e. 400 thousand frames due to a frameskip of 4, with each environment. $1 0 0 \\mathrm { k }$ steps roughly correspond to 2 hours of real-time gameplay, which is far less than the usual RL settings. For example, DQN [24] uses 200 million frames, which is around 925 hours of real-time gameplay. Note that the human player’s performance is tested after allowing the human to get familiar with the game after 2 hours as well. We report the raw performance on each game, as well as the mean and median of the human normalized score. The human normalized score is defined as: $\\left( \\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 } } \\right) / ( \\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 } } )$ . ",
+        "bbox": [
+            174,
+            273,
+            825,
+            428
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare our method to the following baselines. (1) SimPLe [18], a model-based RL algorithm that learns an action conditional video prediction model and trains PPO within the learned environment. (2) OTRainbow [19], which tunes the hyper-parameters of the Rainbow [16] method to achieve higher sample efficiency. (3) CURL [35], which uses contrastive learning as a side task to improve the image representation quality. (4) DrQ [21], which adds data augmentations to the input images while learning the original RL objective. (5) SPR [32], the previous SoTA in Atari $1 0 0 \\mathrm { k }$ which proposes to augment the Rainbow [16] agent with data augmentations as well as a multi-step consistency loss using BYOL-style self-supervision. (6) MuZero [27] with our implementations and the same hyper-parameters as EfficientZero. (7) Random Agent (8) Human performance. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            558
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "DeepMind Control 100k Tassa et al. [37] propose the DMControl suite, which includes some challenging visual robotics tasks with continuous action space. And some works [12, 35] have benchmarked for the sample efficiency on the DMControl $1 0 0 \\mathrm { k }$ which contains $1 0 0 \\mathrm { k }$ environment steps data. Since the MCTS-based methods cannot deal with tasks with continuous action space, we discretize each dimension into 5 discrete slots in MuZero [27] and EfficientZero. To avoid the dimension explosion, we evaluate EfficientZero in three low-dimensional tasks. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            647
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare our method to the following baselines. (1) Pixel SAC, which applies SAC directly to pixels. (2) SAC-AE [42], which combines the SAC and an auto-encoder to handle image-based inputs. (3) State SAC, which applies SAC directly to ground truth low dimensional states rather than the pixels. (4) Dreamer [12], which learns a world model and is trained in dreamed scenarios. (5) CURL [35], the previous SoTA in DMControl 100k. (6) MuZero [27] with action discretizations. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            723
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            739,
+            264,
+            755
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows the results of EfficientZero on the Atari $1 0 0 \\mathrm { k }$ benchmark. Normalizing our score with the score of human players, EfficientZero achieves a mean score of 1.904 and a median score of 1.160. As a reference, DQN [24] achieves a mean and median performance of 2.20 and 0.959 on these 26 games. However, it is trained with 500 times more data (200 million frames). For the first time, an agent trained with only 2 hours of game data can outperform the human player in terms of the mean and median performance. Among all games, our method outperforms the human in 14 out of 26 games. Compared with the previous state-of-the-art method (SPR [32]), we are $170 \\%$ and $180 \\%$ better in terms of mean and median score respectively. ",
+        "bbox": [
+            174,
+            765,
+            825,
+            877
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Apart from the Atari games, EffcientZero achieves remarkable results in the simulated tasks with continuous action space. As shown in Table 2, EffcientZero outperforms CURL, the previous SoTA, to a considerable degree and keeps a smaller variance but MuZero cannot work well here. Notably, EfficientZero achieves comparable results to the state SAC, which consumes the ground truth states as input and is considered as the oracles. ",
+        "bbox": [
+            173,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/da1d1f3e52987782fd132411b1f9f22cf5fcb47ae49d944976a15eb72d56501c.jpg",
+        "table_caption": [
+            "Table 1: Scores achieved on the Atari $1 0 0 \\mathrm { k }$ benchmark (32 seeds). EfficientZero achieves superhuman performance with only 2 hours of real-time game play. Our method is $170 \\%$ and $180 \\%$ better than the previous SoTA performance, in mean and median human normalized score respectively. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Game</td><td>Random</td><td>Human</td><td>SimPLe</td><td>OTRainbow</td><td>CURL</td><td>DrQ</td><td>SPR</td><td>MuZero</td><td>Ours</td></tr><tr><td>Alien</td><td>227.8</td><td>7127.7</td><td>616.9</td><td>824.7</td><td>558.2</td><td>771.2</td><td>801.5</td><td>530.0</td><td>1140.3</td></tr><tr><td>Amidar</td><td>5.8</td><td>1719.5</td><td>88.0</td><td>82.8</td><td>142.1</td><td>102.8</td><td>176.3</td><td>38.8</td><td>101.9</td></tr><tr><td>Assault</td><td>222.4</td><td>742.0</td><td>527.2</td><td>351.9</td><td>600.6</td><td>452.4</td><td>571.0</td><td>500.1</td><td>1407.3</td></tr><tr><td>Asterix</td><td>210.0</td><td>8503.3</td><td>1128.3</td><td>628.5</td><td>734.5</td><td>603.5</td><td>977.8</td><td>1734.0</td><td>16843.8</td></tr><tr><td>Bank Heist</td><td>14.2</td><td>753.1</td><td>34.2</td><td>182.1</td><td>131.6</td><td>168.9</td><td>380.9</td><td>192.5</td><td>361.9</td></tr><tr><td>BattleZone</td><td>2360.0</td><td>37187.5</td><td>5184.4</td><td>4060.6</td><td>14870.0</td><td>12954.0</td><td>16651.0</td><td>7687.5</td><td>17938.0</td></tr><tr><td>Boxing</td><td>0.1</td><td>12.1</td><td>9.1</td><td>2.5</td><td>1.2</td><td>6.0</td><td>35.8</td><td>15.1</td><td>44.1</td></tr><tr><td>Breakout</td><td>1.7</td><td>30.5</td><td>16.4</td><td>9.8</td><td>4.9</td><td>16.1</td><td>17.1</td><td>48.0</td><td>406.5</td></tr><tr><td>ChopperCmd</td><td>811.0</td><td>7387.8</td><td>1246.9</td><td>1033.3</td><td>1058.5</td><td>780.3</td><td>974.8</td><td>1350.0</td><td>1794.0</td></tr><tr><td>Crazy Climber</td><td>10780.5</td><td>35829.4</td><td>62583.6</td><td>21327.8</td><td>12146.5</td><td>20516.5</td><td>42923.6</td><td>56937.0</td><td>80125.3</td></tr><tr><td>Demon Attack</td><td>152.1</td><td>1971.0</td><td>208.1</td><td>711.8</td><td>817.6</td><td>1113.4</td><td>545.2</td><td>3527.0</td><td>13298.0</td></tr><tr><td>Freeway</td><td>0.0</td><td>29.6</td><td>20.3</td><td>25.0</td><td>26.7</td><td>9.8</td><td>24.4</td><td>21.8</td><td>21.8</td></tr><tr><td>Frostbite</td><td>65.2</td><td>4334.7</td><td>254.7</td><td>231.6</td><td>1181.3</td><td>331.1</td><td>1821.5</td><td>255.0</td><td>313.8</td></tr><tr><td>Gopher</td><td>257.6</td><td>2412.5</td><td>771.0</td><td>778.0</td><td>669.3</td><td>636.3</td><td>715.2</td><td>1256.0</td><td>3518.5</td></tr><tr><td>Hero</td><td>1027.0</td><td>30826.4</td><td>2656.6</td><td>6458.8</td><td>6279.3</td><td>3736.3</td><td>7019.2</td><td>3095.0</td><td>8530.1</td></tr><tr><td>Jamesbond</td><td>29.0</td><td>302.8</td><td>125.3</td><td>112.3</td><td>471.0</td><td>236.0</td><td>365.4</td><td>87.5</td><td>459.4</td></tr><tr><td>Kangaroo</td><td>52.0</td><td>3035.0</td><td>323.1</td><td>605.4</td><td>872.5</td><td>940.6</td><td>3276.4</td><td>62.5</td><td>962.0</td></tr><tr><td>Krull</td><td>1598.0</td><td>2665.5</td><td>4539.9</td><td>3277.9</td><td>4229.6</td><td>4018.1</td><td>3688.9</td><td>4890.8</td><td>6047.0</td></tr><tr><td>Kung Fu Master</td><td>258.5</td><td>22736.3</td><td>17257.2</td><td>5722.2</td><td>14307.8</td><td>9111.0</td><td>13192.7</td><td>18813.0</td><td>31112.5</td></tr><tr><td>Ms Pacman</td><td>307.3</td><td>6951.6</td><td>1480.0</td><td>941.9</td><td>1465.5</td><td>960.5</td><td>1313.2</td><td>1265.6</td><td>1387.0</td></tr><tr><td>Pong</td><td>-20.7</td><td>14.6</td><td>12.8</td><td>1.3</td><td>-16.5</td><td>-8.5</td><td>-5.9</td><td>-6.7</td><td>20.6</td></tr><tr><td>Private Eye</td><td>24.9</td><td>69571.3</td><td>58.3</td><td>100.0</td><td>218.4</td><td>-13.6</td><td>124.0</td><td>56.3</td><td>100.0</td></tr><tr><td>Qbert</td><td>163.9</td><td>13455.0</td><td>1288.8</td><td>509.3</td><td>1042.4</td><td>854.4</td><td>669.1</td><td>3952.0</td><td>15458.1</td></tr><tr><td>Road Runner</td><td>11.5</td><td>7845.0</td><td>5640.6</td><td>2696.7</td><td>5661.0</td><td>8895.1</td><td>14220.5</td><td>2500.0</td><td>18512.5</td></tr><tr><td>Seaquest</td><td>68.4</td><td>42054.7</td><td>683.3</td><td>286.9</td><td>384.5</td><td>301.2</td><td>583.1</td><td>208.0</td><td>1020.5</td></tr><tr><td>Up N Down</td><td>533.4</td><td>11693.2</td><td>3350.3</td><td>2847.6</td><td>2955.2</td><td>3180.8</td><td>28138.5</td><td>2896.9</td><td>16095.7</td></tr><tr><td>Normed Mean</td><td>0.000</td><td>1.000</td><td>0.443</td><td>0.264</td><td>0.381</td><td>0.357</td><td>0.704</td><td>0.562</td><td>1.904</td></tr><tr><td>Normed Median</td><td>0.000</td><td>1.000</td><td>0.144</td><td>0.204</td><td>0.175</td><td>0.268</td><td>0.415</td><td>0.227</td><td>1.160</td></tr></table>",
+        "bbox": [
+            174,
+            200,
+            823,
+            531
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/2e15e0f22e6f4194587b076308fbaaa889644501d2fefa4aa600ce37f4cd78b9.jpg",
+        "table_caption": [
+            "Table 2: Scores achieved by EfficientZero (mean & standard deviation for 10 seeds) and some baselines on some low-dimensional environments on the DMControl $1 0 0 \\mathrm { k }$ benchmark. EfficientZero achieves state-of-art performance and comparable results to the state-based SAC. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>CURL</td><td>Dreamer</td><td>MuZero</td><td>SAC-AE</td><td>Pixel SAC</td><td>State SAC</td><td>EfficientZero</td></tr><tr><td>Cartpole,Swingup</td><td>582±146</td><td>326±27</td><td>218.5± 122</td><td>311±11</td><td>419±40</td><td>835±22</td><td>813±19</td></tr><tr><td>Reacher,Easy</td><td>538±233</td><td>314±155</td><td>493±145</td><td>274±14</td><td>145±30</td><td>746±25</td><td>952±34</td></tr><tr><td>Ball in cup, Catch</td><td>769±43</td><td>246±174</td><td>542±270</td><td>391±82</td><td>312±63</td><td>746±91</td><td>942±17</td></tr></table>",
+        "bbox": [
+            191,
+            612,
+            807,
+            670
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 Ablations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            699,
+            281,
+            713
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Section 4, we discuss three issues that prevent MuZero from achieving high performance when data is limited: (1) the lack of environment model supervision, (2) the state aliasing issue, and (3) the off-policy target value issue. We propose three corresponding approaches to fix those issues and demonstrate the usefulness of the combination of those approaches on a wide range of 26 Atari games. In this section, we will analyze each component individually. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            794
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Each Component Firstly, we do an ablation study by removing the three components from our full model one at a time. As shown in Table 3, we find that removing any one of the three components will lead to a performance drop compared to our full model. Furthermore, the richer learning signals are the aspect Muzero lacks most in the low-data regime as the largest performance drop is from the version without consistency supervision. As for the performance in the high-data regime, We find that the temporal consistency can significantly accelerate the training. The value prefix seems to be helpful during the early learning process, but not as much in the later stage. The off-policy correction is not necessary as it is specifically designed under limited data. ",
+        "bbox": [
+            173,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "",
+        "table_caption": [
+            "Table 3: Ablations of the self-supervised consistency, end-to-end value prefix and model-based off-policy correction. We remove one component at a time and evaluate the corresponding version on the 26 Atari games. Each component matters and the consistency one is the most significant. The detailed results are attached in the Appendix . "
+        ],
+        "table_footnote": [],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/4ecbcf3cc144e1cde8b6c22e795ea15b3351dea8d776da307c00886179a05801.jpg",
+        "image_caption": [
+            "Figure 4: Evaluations of image reconstructions based on latent states extracted from the model with or without self-supervised consistency. The predicted next states with consistency can basically be reconstructed into observations while the ones without consistency cannot. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            155,
+            759,
+            436
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Temporal Consistency As the version without self-supervised consistency cannot work well in most of the games, we attempt to dig into the reason for such phenomenon. We design a decoder $\\mathcal { D }$ to reconstruct the original observations, taking the latent states as inputs. Specifically, the architecture of $\\mathcal { D }$ and the $\\mathcal { H }$ are symmetrical, which means that all the convolutional layers are replaced by deconvolutional layers in $\\mathcal { D }$ and the order of the layers are reversed in $\\mathcal { D }$ . Therefore, $\\mathcal { H }$ is an encoder to obtain state $s _ { t }$ from observation $o _ { t }$ and $\\mathcal { D }$ tries to decode the $o _ { t }$ from $s _ { t }$ . In this ablation, we freeze all parameters of the trained EfficientZero network with or without consistency respectively and the reconstructed results are shown in different columns of Figure 4. We regard the decoder as a tool to visualize the current states and unrolled states, shown in different rows of Figure 4. Here we note that $\\mathcal { M } _ { \\mathrm { c o n } }$ is the trained EfficientZero model with consistency and $\\mathcal { M } _ { \\mathrm { n o n } }$ is the one without consistency. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            674
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 4, in terms of the current state $s _ { t }$ , the observation is reconstructed well enough in the two versions. However, it is remarkable that the the decoder given $\\mathcal { M } _ { \\mathrm { n o n } }$ can not reconstruct images from the unrolled predicted states $\\hat { s } _ { t + k }$ while the one given $\\mathcal { M } _ { \\mathrm { c o n } }$ can reconstruct the basic observations. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            736
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To sum up, there are some distributional shifts between the latent states from the representation network and the states from the dynamics function without consistency. The consistency component can reduce the shift and provide more supervision for training the dynamics network. ",
+        "bbox": [
+            176,
+            742,
+            821,
+            785
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Value Prefix We further validate our assumptions in the end-to-end learning of value prefix, i.e. the state aliasing problem will cause difficulty in predicting the reward, and end-to-end learning of value prefix can alleviate this phenomenon. ",
+        "bbox": [
+            176,
+            791,
+            821,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To fairly compare directly predicting the reward versus end-to-end learning of the value prefix, we need to control for the dataset that both methods are trained on. Since during the RL training, the dataset distribution is determined by the method, we opt to load a half-trained Pong model and rollout total 100k steps as the common static dataset. We split this dataset into a training set and a validation set. Then we run both the direct reward prediction and the value prefix method on the training split. ",
+        "bbox": [
+            174,
+            839,
+            823,
+            909
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 5, we find that the direct reward prediction method has lower losses on the training set. However, the value prefix’s validation error is much smaller when unrolled for 5 steps. This shows that the value prefix method avoids overfitting the hard reward prediction problem, and thus it can reduce the state aliasing problem, reaching a better generalization performance. ",
+        "bbox": [
+            174,
+            90,
+            388,
+            257
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/4d23ee87506b65df4a9420948f07fb6598dc58edfaab7310c37175b84f3385c9.jpg",
+        "image_caption": [
+            "Figure 5: Training and validation losses of direct reward prediction method and the value prefix method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            428,
+            89,
+            782,
+            219
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Off-Policy Correction To prove ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            263,
+            387,
+            277
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "the effectiveness of the off-policy correction component, we compare the error between the target values and the ground truth values with or without off-policy correction. Specifically, the ground truth values are estimated by Monte Carlo sampling. ",
+        "bbox": [
+            176,
+            279,
+            820,
+            319
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We train a model for the game UpNDown with total 100k training steps, and collect the trajectories at different training stages respectively (20k, 40k, ..., 100k steps). Then we calculate the ground truth values with the final model. We choose the trajectories at the same stage (20k) and use the final model to evaluate the target values with or without off-policy correction, following the Equation 4. We evaluate the L1 error of the target values and the ground truth, as shown in Table 4. The error of unrolled next 5 states means the average error of the unrolled 1-5 states with dynamics network from current states. The error is smaller in both current states and the unrolled states with off-policy correction. Thus, the correction component does reduce the bias caused by the off-policy issue. ",
+        "bbox": [
+            173,
+            325,
+            825,
+            436
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/904853bc1697d21aa01a8128f153a5f0eb94b968ea4401c0066c75d74d08e66f.jpg",
+        "table_caption": [
+            "Table 4: Ablations of the off-policy correction: L1 error of the target values versus the ground truth values. Take UpNDown as an example. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>States</td><td>Current state </td><td>Unrolled next 5 states (Avg.）All states (Avg.)</td><td></td></tr><tr><td>Value error without correction</td><td>0.765</td><td>0.636</td><td>0.657</td></tr><tr><td>Value error with correction</td><td>0.533</td><td>0.576</td><td>0.569</td></tr></table>",
+        "bbox": [
+            197,
+            491,
+            799,
+            546
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, we also ablate the value error of the trajectories at distinct stages in Table 5. We can find that the value error becomes smaller as the trajectories are fresher. This indicates that the off-policy issue is severe due to the staleness of the data. More significantly, the off-policy correction can provide more accurate target value estimation for the trajectories at distinct time-steps as all the errors with correction shown in the table are smaller than those without correction at the same stage. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            637
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/5f62a0378b41d769f138081e968c54d7cb0dbfc00b5f5c4292e858cb2b869d8b.jpg",
+        "table_caption": [
+            "Table 5: Ablations of the off-policy correction: Average L1 error of the values of the trajectories at distinct stages. Take UpNDown as an example. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Stages of trajectories</td><td>20k</td><td>40k</td><td>60k</td><td>80k</td><td>100k</td></tr><tr><td>Value error without correction</td><td>0.657</td><td>0.697</td><td>0.628</td><td>0.574</td><td>0.441</td></tr><tr><td>Value error with correction</td><td>0.569</td><td>0.552</td><td>0.537</td><td>0.488</td><td>0.397</td></tr></table>",
+        "bbox": [
+            264,
+            691,
+            728,
+            747
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            782,
+            294,
+            799
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a sample-efficient model-based method EfficientZero. It achieves superhuman performance on the Atari games with as little as 2 hours of the gameplay experience and state-of-the-art performance on some DMControl tasks. Apart from the full results, we do detailed ablation studies to examine the effectiveness of the proposed components. This work is one step towards running RL in the physical world with complex sensory inputs. In the future, we plan to extend it to more directions, such as a better design for the continuous action space. And we also plan to study the acceleration of MCTS and how to combine this framework with life-long learning. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work is supported by the Ministry of Science and Technology of the People’s Republic of China, the 2030 Innovation Megaprojects “Program on New Generation Artificial Intelligence” (Grant No. 2021AAA0150000). ",
+        "bbox": [
+            174,
+            121,
+            826,
+            162
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            185,
+            267,
+            200
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Bruce Abramson. The expected-outcome model of two-player games. Morgan Kaufmann, 2014.   \n[2] Kavosh Asadi, Dipendra Misra, Seungchan Kim, and Michel L Littman. Combating the compounding-error problem with a multi-step model. arXiv preprint arXiv:1905.13320, 2019.   \n[3] Peter Auer, Nicolo Cesa-Bianchi, and Paul Fischer. Finite-time analysis of the multiarmed bandit problem. Machine learning, 47(2):235–256, 2002.   \n[4] Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013.   \n[5] Christopher Berner, Greg Brockman, Brooke Chan, Vicki Cheung, Przemysław D˛ebiak, Christy Dennison, David Farhi, Quirin Fischer, Shariq Hashme, Chris Hesse, et al. Dota 2 with large scale deep reinforcement learning. arXiv preprint arXiv:1912.06680, 2019.   \n[6] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In International conference on machine learning, pages 1597–1607. PMLR, 2020.   \n[7] Xinlei Chen and Kaiming He. Exploring simple siamese representation learning. arXiv preprint arXiv:2011.10566, 2020.   \n[8] Kurtland Chua, Roberto Calandra, Rowan McAllister, and Sergey Levine. Deep reinforcement learning in a handful of trials using probabilistic dynamics models. arXiv preprint arXiv:1805.12114, 2018.   \n[9] Joery A de Vries, Ken S Voskuil, Thomas M Moerland, and Aske Plaat. Visualizing muzero models. arXiv preprint arXiv:2102.12924, 2021.   \n[10] Marc Deisenroth and Carl E Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In Proceedings of the 28th International Conference on machine learning (ICML-11), pages 465–472. Citeseer, 2011.   \n[11] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020.   \n[12] Danijar Hafner, Timothy Lillicrap, Jimmy Ba, and Mohammad Norouzi. Dream to control: Learning behaviors by latent imagination. arXiv preprint arXiv:1912.01603, 2019.   \n[13] Danijar Hafner, Timothy Lillicrap, Ian Fischer, Ruben Villegas, David Ha, Honglak Lee, and James Davidson. Learning latent dynamics for planning from pixels. In International Conference on Machine Learning, pages 2555–2565. PMLR, 2019.   \n[14] Danijar Hafner, Timothy Lillicrap, Mohammad Norouzi, and Jimmy Ba. Mastering atari with discrete world models. arXiv preprint arXiv:2010.02193, 2020.   \n[15] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9729–9738, 2020. ",
+        "bbox": [
+            171,
+            190,
+            828,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[16] Matteo Hessel, Joseph Modayil, Hado Van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Dan Horgan, Bilal Piot, Mohammad Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            147
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[17] Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Mohammadamin Barekatain, Simon Schmitt, and David Silver. Learning and planning in complex action spaces. arXiv preprint arXiv:2104.06303, 2021. ",
+        "bbox": [
+            173,
+            157,
+            823,
+            200
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[18] Lukasz Kaiser, Mohammad Babaeizadeh, Piotr Milos, Blazej Osinski, Roy H Campbell, Konrad Czechowski, Dumitru Erhan, Chelsea Finn, Piotr Kozakowski, Sergey Levine, et al. Modelbased reinforcement learning for atari. arXiv preprint arXiv:1903.00374, 2019. ",
+        "bbox": [
+            171,
+            210,
+            823,
+            253
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[19] Kacper Kielak. Do recent advancements in model-based deep reinforcement learning really improve data efficiency? arXiv preprint arXiv:2003.10181, 2020. ",
+        "bbox": [
+            171,
+            263,
+            825,
+            292
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] Levente Kocsis and Csaba Szepesvári. Bandit based monte-carlo planning. In European conference on machine learning, pages 282–293. Springer, 2006. ",
+        "bbox": [
+            171,
+            303,
+            823,
+            333
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] Ilya Kostrikov, Denis Yarats, and Rob Fergus. Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. arXiv preprint arXiv:2004.13649, 2020. ",
+        "bbox": [
+            173,
+            342,
+            825,
+            371
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Michael Laskin, Kimin Lee, Adam Stooke, Lerrel Pinto, Pieter Abbeel, and Aravind Srinivas. Reinforcement learning with augmented data. arXiv preprint arXiv:2004.14990, 2020. ",
+        "bbox": [
+            173,
+            381,
+            825,
+            410
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] 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. ",
+        "bbox": [
+            174,
+            420,
+            826,
+            463
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] 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. ",
+        "bbox": [
+            174,
+            472,
+            826,
+            516
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] 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, pages 1928–1937. PMLR, 2016. ",
+        "bbox": [
+            174,
+            525,
+            826,
+            582
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Christopher D Rosin. Multi-armed bandits with episode context. Annals of Mathematics and Artificial Intelligence, 61(3):203–230, 2011. ",
+        "bbox": [
+            171,
+            593,
+            825,
+            622
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Julian Schrittwieser, Ioannis Antonoglou, Thomas Hubert, Karen Simonyan, Laurent Sifre, Simon Schmitt, Arthur Guez, Edward Lockhart, Demis Hassabis, Thore Graepel, et al. Mastering atari, go, chess and shogi by planning with a learned model. Nature, 588(7839):604–609, 2020. ",
+        "bbox": [
+            174,
+            632,
+            826,
+            675
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Julian Schrittwieser, Thomas Hubert, Amol Mandhane, Mohammadamin Barekatain, Ioannis Antonoglou, and David Silver. Online and offline reinforcement learning by planning with a learned model. arXiv preprint arXiv:2104.06294, 2021. ",
+        "bbox": [
+            173,
+            684,
+            825,
+            727
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International conference on machine learning, pages 1889–1897. PMLR, 2015. ",
+        "bbox": [
+            173,
+            738,
+            825,
+            780
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. arXiv preprint arXiv:1506.02438, 2015. ",
+        "bbox": [
+            171,
+            790,
+            825,
+            833
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017. ",
+        "bbox": [
+            169,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Max Schwarzer, Ankesh Anand, Rishab Goel, R Devon Hjelm, Aaron Courville, and Philip Bachman. Data-efficient reinforcement learning with self-predictive representations. ",
+        "bbox": [
+            173,
+            882,
+            820,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016.   \n[34] David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. nature, 550(7676):354–359, 2017.   \n[35] Aravind Srinivas, Michael Laskin, and Pieter Abbeel. Curl: Contrastive unsupervised representations for reinforcement learning. arXiv preprint arXiv:2004.04136, 2020.   \n[36] Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.   \n[37] Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, et al. Deepmind control suite. arXiv preprint arXiv:1801.00690, 2018.   \n[38] Hado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double q-learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 30, 2016.   \n[39] Hado van Hasselt, Matteo Hessel, and John Aslanides. When to use parametric models in reinforcement learning? arXiv preprint arXiv:1906.05243, 2019.   \n[40] Ziyu Wang, Tom Schaul, Matteo Hessel, Hado Hasselt, Marc Lanctot, and Nando Freitas. Dueling network architectures for deep reinforcement learning. In International conference on machine learning, pages 1995–2003. PMLR, 2016.   \n[41] Christopher John Cornish Hellaby Watkins. Learning from delayed rewards. 1989.   \n[42] Denis Yarats, Amy Zhang, Ilya Kostrikov, Brandon Amos, Joelle Pineau, and Rob Fergus. Improving sample efficiency in model-free reinforcement learning from images. arXiv preprint arXiv:1910.01741, 2019. ",
+        "bbox": [
+            171,
+            88,
+            828,
+            531
+        ],
+        "page_idx": 12
+    }
+]

parse/train/S1cZsf-RW/S1cZsf-RW.md

@@ -0,0 +1,310 @@
+# WHAI: WEIBULL HYBRID AUTOENCODING INFERENCE FOR DEEP TOPIC MODELING
+
+Hao Zhang, Bo Chen∗ & Dandan Guo   
+National Laboraory of Radar Signal Processing,   
+Collaborative Innovation Center of Information Sensing and Understanding, Xidian University, Xi’an, China.   
+zhanghao_xidian@163.com bchen@mail.xidian.edu.cn gdd_xidian@126.com
+
+# Mingyuan Zhou
+
+McCombs School of Business, The University of Texas at Austin, Austin, TX 78712, USA. Mingyuan.Zhou@mccombs.utexas.edu
+
+# ABSTRACT
+
+To train an inference network jointly with a deep generative topic model, making it both scalable to big corpora and fast in out-of-sample prediction, we develop Weibull hybrid autoencoding inference (WHAI) for deep latent Dirichlet allocation, which infers posterior samples via a hybrid of stochastic-gradient MCMC and autoencoding variational Bayes. The generative network of WHAI has a hierarchy of gamma distributions, while the inference network of WHAI is a Weibull upward-downward variational autoencoder, which integrates a deterministicupward deep neural network, and a stochastic-downward deep generative model based on a hierarchy of Weibull distributions. The Weibull distribution can be used to well approximate a gamma distribution with an analytic Kullback-Leibler divergence, and has a simple reparameterization via the uniform noise, which help efficiently compute the gradients of the evidence lower bound with respect to the parameters of the inference network. The effectiveness and efficiency of WHAI are illustrated with experiments on big corpora.
+
+# 1 INTRODUCTION
+
+There is a surge of research interest in multilayer representation learning for documents. To analyze the term-document count matrix of a text corpus, Srivastava et al. (2013) extend the deep Boltzmann machine (DBM) with the replicated softmax topic model of Salakhutdinov & Hinton (2009) to infer a multilayer representation with binary hidden units, but its inference network is not trained to match the true posterior (Mnih & Gregor, 2014) and the higher-layer neurons learned by DBM are difficult to visualize. The deep Poisson factor models of Gan et al. (2015) are introduced to generalize Poisson factor analysis (Zhou et al., 2012), with a deep structure restricted to model binary topic usage patterns. Deep exponential families (DEF) of Ranganath et al. (2015) construct more general probabilistic deep networks with non-binary hidden units, in which a count matrix can be factorized under the Poisson likelihood, with the gamma distributed hidden units of adjacent layers linked via the gamma scale parameters. The Poisson gamma belief network (PGBN) (Zhou et al., 2015; 2016) also factorizes a count matrix under the Poisson likelihood, but factorizes the shape parameters of the gamma distributed hidden units of each layer into the product of a connection weight matrix and the gamma hidden units of the next layer, resulting in strong nonlinearity and readily interpretable multilayer latent representations.
+
+Those multilayer probabilistic models are often characterized by a top-down generative structure, with the distribution of a hidden layer typically acting as a prior for the layer below. Despite being able to infer a multilayer representation of a text corpus with scalable inference (Patterson &
+
+Teh, 2013; Ruiz et al., 2016; Cong et al., 2017a), they usually rely on an iterative procedure to infer the latent representation of a new document at the testing stage, regardless of whether variational inference or Markov chain Monte Carlo (MCMC) is used. The potential need of a large number of iterations per testing document makes them unattractive when real-time processing is desired. For example, one may need to rapidly extract the topic-proportion vector of a document and use it for downstream analysis, such as identifying key topics and retrieving related documents. A potential solution is to construct a variational autoencoder (VAE) that learns the parameters of an inference network (recognition model or encoder) jointly with those of the generative model (decoder) (Kingma & Welling, 2014; Rezende et al., 2014). However, most existing VAEs rely on Gaussian latent variables, with the neural networks (NNs) acting as nonlinear transforms between adjacent layers (Sonderby et al., 2016; Dai et al., 2016; Ishaan et al., 2017). A primary reason is that there is a simple reparameterization trick for Gaussian latent variables that allows efficiently computing the noisy gradients of the evidence lower bound (ELBO) with respect to the NN parameters. Unfortunately, Gaussian based distributions often fail to well approximate the posterior distributions of sparse, nonnegative, and skewed document latent representations. For example, Srivastava & Sutton (2017) propose autoencoding variational inference for topic models (AVITM), as shown in Fig. 2b, which utilizes the logistic-normal distribution to approximate the posterior of the latent representation of a document; even though the generative model is latent Dirichlet allocation (LDA) (Blei et al., 2003), a basic single-hidden-layer topic model, due to the insufficient ability of the logistic-normal distribution to model sparsity, AVITM has to rely on some heuristic to force the latent representation of a document to be sparse. Another common shortcoming of existing VAEs is that they often only provide a point estimate for the global parameters of the generative model, and hence their inference network is optimized to approximate the posteriors of the local parameters conditioning on the data and the point estimate, rather than a full posterior, of the global parameters. In addition, from the viewpoint of probabilistic modeling, the inference network of a VAE is often merely a shallow probabilistic model, whose parameters, though, are deterministically nonlinearly transformed from the observations via a non-probabilistic deep neural network.
+
+To address these shortcomings and move beyond Gaussian latent variable based deep models and inference procedures, we develop Weibull hybrid autoencoding inference (WHAI), a hybrid Bayesian inference for deep topic modeling that integrates both stochastic-gradient MCMC (Welling & Teh, 2011; Ma et al., 2015; Cong et al., 2017a) and a multilayer Weibull distribution based VAE. WHAI is related to a VAE in having both a decoder and encoder, but differs from a usual VAE in the following ways: 1) deep latent Dirichlet allocation (DLDA), a probabilistic deep topic model equipped with a gamma belief network, acts as the generative model; 2) inspired by the upward-downward Gibbs sampler of DLDA, as sketched in Fig. 2c, the inference network of WHAI uses a upwarddownward structure, as shown in Fig. 2a, to combine a non-probabilistic bottom-up deep NN and a probabilistic top-down deep generative model, with the \`th hidden layer of the generative model linked to both the $( \ell + 1 )$ th hidden layer of itself and the \`th hidden layer of the deep NN; 3) a hybrid of stochastic-gradient MCMC and autoencoding variational inference is employed to infer both the posterior distribution of the global parameters, represented as collected posterior MCMC samples, and a VAE that approximates the posterior distribution of the local parameters given the data and a posterior sample (rather than a point estimate) of the global parameters; 4) we use the Weibull distributions in the inference network to approximate gamma distributed conditional posteriors, exploiting the fact that the Weibull and gamma distributions have similar probability density functions (PDFs), the Kullback-Leibler (KL) divergence from the Weibull to gamma distributions is analytic, and a Weibull random variable can be efficiently reparameterized with a uniform noise.
+
+Note that we have also tried gamma hybrid autoencoding inference (GHAI), which directly uses the gamma distribution in the probabilistic top-down part of the inference network, while using rejection sampling variational inference (RSVI) of Naesseth et al. to approximately compute the gradient of the ELBO. While RSVI is a very general technique that can be applied to a wide variety of non-reparameterizable distributions, we find that for replacing the reparameterizable Weibull with non-reparameterizable gamma distributions in the inference network, the potential gains are overshadowed by the disadvantages of having to rely on an approximate reparameterization scheme guided by rejection sampling. In the experiments for deep topic modeling, we show that WHAI clearly outperforms GHAI, and both WHAI and GHAI outperform their counterparts that remove the top-down links of the inference network, referred to as WHAI-independent and GHAI-independent, respectively; WHAI is comparable to Gibbs sampling in terms performance, but is scalable to big training data via mini-batch stochastic-gradient based inference and is considerably fast in out-ofsample prediction via the use of an inference network.
+
+# 2 WHAI FOR MULTILAYER DOCUMENT REPRESENTATION
+
+Below we first describe the decoder and encoder of WHAI, and then provide a hybrid stochasticgradient MCMC and autoencoding variational inference that is fast in both training and testing.
+
+2.1 DOCUMENT DECODER: DEEP LATENT DIRICHLET ALLOCATION
+
+In order to capture the hierarchical document latent representation, WHAI uses the Poisson gamma belief network (PGBN) of Zhou et al. (2016), a deep probabilistic topic model, as the generative network (encoder). Choosing a deep generative model as its decoder distinguishes WHAI from both AVITM, which uses a “shallow” LDA as its decoder, and a conventional VAE, which often uses as its decoder a “shallow” (transformed) Gaussian distribution, whose parameters are deterministically nonlinearly transformed from the observation via “black-box” deep neural networks. With all the gamma latent variables marginalized out, as shown in Cong et al. (2017a), the PGBN can also be represented as deep LDA (DLDA). For simplicity, below we use DLDA to refer to both the PGBN and DLDA representations of the same underlying deep generative model, as briefly described below. Note the single-hidden-layer version of DLDA reduces to Poisson factor analysis of Zhou et al. (2012), which is closely related to LDA. Let us denote $\Phi ^ { ( 1 ) } \in \mathbb { R } _ { + } ^ { K _ { 0 } \times K _ { 1 } }$ and $\pmb { \theta } _ { n } ^ { ( 1 ) } \in \mathbb { R } _ { + } ^ { K _ { 1 } }$ as the factor loading and latent representation of the first hidden layer of DLDA, respectively, where $\mathbb { R } _ { + } = \{ x , x \geq \bar { 0 } \}$ and $K _ { 1 }$ is the number of topics (factors) of the first layer. We further restrict that the sum of each column of $\Phi ^ { ( 1 ) }$ is equal to one. To model high-dimensional multivariate sparse count vectors ${ \pmb x } _ { n } \in \mathbb { Z } ^ { K _ { 0 } }$ , where $\mathbb { Z } = \{ 0 , 1 , \ldots \}$ , under the Poisson likelihood, the DLDA generative model with $L$ hidden layers, from top to bottom, can be expressed as
+
+$$
+\begin{array} { r l } & { \pmb { \theta } _ { n } ^ { ( L ) } \sim \mathrm { G a m } \left( \boldsymbol { r } , c _ { n } ^ { ( L + 1 ) } \right) , \ldots , \pmb { \theta } _ { n } ^ { ( l ) } \sim \mathrm { G a m } \left( \Phi ^ { ( l + 1 ) } \pmb { \theta } _ { n } ^ { ( l + 1 ) } , c _ { n } ^ { ( l + 1 ) } \right) , \ldots , } \\ & { \pmb { \theta } _ { n } ^ { ( 1 ) } \sim \mathrm { G a m } \left( \Phi ^ { ( 2 ) } \pmb { \theta } _ { n } ^ { ( 2 ) } , c _ { n } ^ { ( 2 ) } \right) , \pmb { x } _ { n } \sim \mathrm { P o i s } \left( \Phi ^ { ( 1 ) } \pmb { \theta } _ { n } ^ { ( 1 ) } \right) . } \end{array}
+$$
+
+where the hidden units $\pmb { \theta } _ { n } ^ { ( l ) } \in \mathbb { R } _ { + } ^ { K _ { l } }$ of layer $l$ are factorized into the product of the factor loading $\Phi ^ { ( l ) } \in \mathbb { R } _ { + } ^ { K _ { l - 1 } \times K _ { l } }$ and hidden units of the next layer. It infers a multilayer data representation, and can visualize its topic $\phi _ { k } ^ { ( l ) }$ at hidden layer $l$ as $\left[ \prod _ { t = 1 } ^ { l - 1 } \Phi ^ { ( t ) } \right] \phi _ { k } ^ { ( l ) }$ , which tend to be very specific in the bottom layer and become increasingly more general when moving upward. The unsupervisedly extracted multilayer latent representations θ(l)n are well suited for additional downstream analysis, such as document classification and retrieval.
+
+The upward-downward Gibbs sampling for DLDA, as described in detail in Zhou et al. (2016), is sketched in Fig. 2c, where $\mathbf { Z } ^ { l }$ represent augmented latent counts that are sampled upward given the observations and model parameters. While having closed-form update equations, the Gibbs sampler requires processing all documents in each iteration and hence has limited scalability. Consequently, a topic-layer-adaptive stochastic gradient Riemannian (TLASGR) MCMC for DLDA, referred to as DLDA-TLASGR, is proposed to process big corpora (Cong et al., 2017a). Different from AVITM (Srivastava & Sutton, 2017) that models a probabilistic simplex with the expanded-natural representation (Patterson & Teh, 2013), DLDA-TLASGR uses a more elegant simplex constraint and increases the sampling efficiency via the use of the Fisher information matrix (FIM) (Cong et al., $2 0 1 7 \mathrm { a } ; \mathrm { b } )$ , with adaptive step-sizes for the topics of different layers. Specifically, suppose $\phi _ { k } ^ { ( l ) }$ is the $k$ th topic in layer $\ell$ with prior $\phi _ { k } ^ { ( l ) } \sim \mathrm { D i r i c h l e t } ( \eta _ { k } ^ { ( l ) } )$ , sampling it can be efficiently realized as
+
+$$
+( \phi _ { k } ) _ { t + 1 } = \left[ ( \phi _ { k } ) _ { t } + \frac { \varepsilon _ { t } } { M _ { k } } \left[ ( \rho \tilde { z } _ { : k } , + \eta _ { k } ^ { ( l ) } ) - ( \rho \tilde { z } _ { : k } , + \eta _ { k } ^ { ( l ) } V ) ( \phi _ { k } ) _ { t } \right] + \mathcal { N } \left( \mathbf { 0 } , \frac { 2 \varepsilon _ { t } } { M _ { k } } d i a g ( \phi _ { k } ) _ { t } \right) \right] _ { \angle } ,
+$$
+
+where $M _ { k }$ is calculated using the estimated FIM, both $\tilde { z } _ { : k }$ · and $\tilde { z } _ { \cdot k }$ · come from the augmented latent counts $\mathbf { Z }$ , and $[ \cdot ] _ { \angle }$ denotes a simplex constraint; more details about TLASGR-MCMC for DLDA can be found in Cong et al. (2017a) and are omitted here for brevity.
+
+![](images/0d09911f1fbd11599c0ebb05f9a5425c7239f489abb2456d083af570923e914c.jpg)  
+Figure 1: The $\mathrm { K L }$ divergence from the inferred Weibull distribution to the target gamma one as (a) Gamma(0.05, 1), (b) Gamma(0.5, 1), and (c) $\operatorname { G a m m a } ( 5 , 1 )$ . Subplot (d) shows the KL divergence as a function of the gamma shape parameter, where the gamma scale parameter is fixed at 1.
+
+Despite the attractive properties, neither the Gibbs sampler nor TLASGR-MCMC of DLDA can avoid taking a potentially large number of MCMC iterations to infer the latent representation of a testing document, which hinders real-time processing of the incoming documents and motivates us to construct an inference network with fast out-of-sample prediction, as described below.
+
+# 2.2 DOCUMENT ENCODER: WEIBULL UPWARD-DOWNWARD VARIATIONAL ENCODER
+
+A VAE uses an inference network to map the observations directly to their latent representations. However, their success so far is mostly restricted to Gaussian distributed latent variables, and does not generalize well to model sparse, nonnegative, and skewed latent document representations. To move beyond latent Gaussian models, below we propose Weibull upward-downward variational encoder (WUDVE) to efficiently produce a document’s multilayer latent representation under DLDA.
+
+Assuming the global parameters $\phi _ { k } ^ { ( l ) }$ of DLDA shown in (1) are given and the task is to infer the local parameters $\pmb { \theta } _ { n } ^ { ( l + 1 ) }$ , the usual strategy of mean-field variational Bayes (Jordan et al., 1999) is to maximize the ELBO that can be expressed as
+
+$$
+L = \sum _ { n = 1 } ^ { N } \mathbb { E } \left[ \ln p \left( x _ { n } \mid \Phi ^ { ( 1 ) } , \pmb { \theta } _ { n } ^ { ( 1 ) } \right) \right] - \sum _ { n = 1 } ^ { N } \sum _ { l = 1 } ^ { L } \mathbb { E } \left[ \ln \frac { q \left( \pmb { \theta } _ { n } ^ { ( l ) } \right) } { p \left( \pmb { \theta } _ { n } ^ { ( l ) } \mid \Phi ^ { ( l + 1 ) } , \pmb { \theta } _ { n } ^ { ( l + 1 ) } \right) } \right] ,
+$$
+
+where the expectations are taken with respect to (w.r.t.) a fully factorized distribution as
+
+$$
+q \left( \{ \pmb { \theta } _ { n } ^ { ( l ) } \} _ { n = 1 , l = 1 } ^ { N , L } \right) = \prod _ { n = 1 } ^ { N } \prod _ { l = 1 } ^ { L } q \left( \pmb { \theta } _ { n } ^ { ( l ) } \right) .
+$$
+
+Instead of using a conventional latent Gaussian based VAE, in order to model sparse and nonnegative latent document representation, it might be more appropriate to use a gamma distribution based inference network defined as $q ( \pmb { \theta } _ { n } | \bar { \bf x } _ { n } ) = \mathrm { G a m m a } \bar { ( } f _ { \bf W } ( \pmb { x } _ { n } ) , g _ { \bf W } ( \pmb { x } _ { n } ) \bar { ) }$ , where $f$ and $g$ are two related deep neural networks parameterized by W. However, it is hard to efficiently compute the gradient of the ELBO with respect to $\mathbf { W }$ , due to the difficulty to reparameterize a gamma distributed random variable (Kingma & Welling, 2014; Ruiz et al., 2016; Knowles, 2015), motivating us to identify a surrogate distribution that can not only well approximate the gamma distribution, but also be easily reparameterized. Below we show the Weibull distribution is an ideal choice.
+
+# 2.2.1 WEIBULL AND GAMMA DISTRIBUTIONS
+
+A main reason that we choose the Weibull distribution to construct the inference network is that the Weibull and gamma distributions have similar PDFs:
+
+Weibull PD $\mathsf { F } \colon P ( x \mid k , \lambda ) = \frac { k } { \lambda ^ { k } } x ^ { k - 1 } e ^ { ( x / \lambda ) ^ { k } } , \mathrm { G a m m a } \mathrm { P D F } \colon P ( x \mid \alpha , \beta ) = \frac { \beta ^ { \alpha } } { \Gamma ( \alpha ) } x ^ { \alpha - 1 } e ^ { - \beta x } ,$ where $x \in \mathbb { R } _ { + }$ . Another reason is due to a simple reparameterization for $x \sim { \mathrm { W e i b u l l } } ( k , \lambda )$ as
+
+$$
+x = \lambda ( - \ln ( 1 - \epsilon ) ) ^ { 1 / k } , \epsilon \sim \mathrm { U n i f o r m } ( 0 , 1 ) .
+$$
+
+Moreover, its KL-divergence from the gamma distribution has an analytic expression as
+
+$$
+\small \mathsf { \displaystyle { K L } } ( \mathbf { W e i b u l l } ( k , \lambda ) | | \mathbf { G a m m a } ( \alpha , \beta ) ) = \alpha \ln \lambda - \frac { \gamma \alpha } { k } - \ln k - \beta \lambda \Gamma \Big ( 1 + \frac { 1 } { k } \Big ) + \gamma + 1 + \alpha \ln \beta - \ln \Gamma ( \alpha ) .
+$$
+
+Minimizing this KL divergence, one can identify the two parameters of a Weibull distribution to approximate a given gamma one. As shown in Fig. 1, the inferred Weibull distribution in general quite accurately approximates the target gamma one, as long as the gamma shape parameter is neither too close to zero nor too large.
+
+# 2.2.2 UPWARD-DOWNWARD INFORMATION PROPAGATION
+
+For the DLDA upward-downward Gibbs sampler sketched in Fig. 2c, the corresponding Gibbs sampling update equation for $\pmb { \theta } _ { n } ^ { ( l ) }$ can be expressed as
+
+$$
+( \pmb { \theta } _ { n } ^ { ( l ) } | - ) \sim \mathrm { G a m m a } \left( \pmb { m } _ { n } ^ { ( l ) ( l + 1 ) } + \pmb { \Phi } ^ { ( l + 1 ) } \pmb { \theta } _ { n } ^ { ( l + 1 ) } , f ( p _ { n } ^ { ( l ) } , c _ { n } ^ { ( l + 1 ) } ) \right) ,
+$$
+
+where $m _ { n } ^ { ( l ) ( l + 1 ) }$ and $p _ { n } ^ { ( l ) }$ are latent random variables constituted by information upward propagated to layer $l$ , as described in detail in Zhou et al. (2016) and hence omitted here for brevity. It is clear from (5) that the conditional posterior of $\pmb { \theta } _ { n } ^ { ( l ) }$ is related to both the information at the higher (prior) layer, and that upward propagated to the current layer via a series of data augmentation and marginalization steps described in Zhou et al. (2016). Inspired by this instructive upwarddownward information propagation in Gibbs sampling, as shown in Fig. 2a, we construct WUDVE, the inference network of our model, as $\begin{array} { r } { q ( \pmb { \theta } _ { n } ^ { ( L ) } | \hat { \pmb { h } _ { n } ^ { ( L ) } } ) \bar { \prod } _ { l = 1 } ^ { L - 1 } q ( \pmb { \theta } _ { n } ^ { ( l ) } | \bar { \Phi ^ { ( l + 1 ) } } , \pmb { h } _ { n } ^ { ( l ) } , \pmb { \theta } _ { n } ^ { ( l + 1 ) } ) } \end{array}$ , where
+
+$$
+{ q ( \theta _ { n } ^ { ( l ) } | \Phi ^ { ( l + 1 ) } , h _ { n } ^ { ( l ) } , \theta _ { n } ^ { ( l + 1 ) } ) } = \mathrm { { W e i b u l l } } ( k _ { n } ^ { ( l ) } + \Phi ^ { ( l + 1 ) } \theta _ { n } ^ { ( l + 1 ) } , \lambda _ { n } ^ { ( l ) } ) .
+$$
+
+The Weibull distribution is used to approximate the gamma distributed conditional posterior, and its parameters $\pmb { k } _ { n } ^ { ( l ) } \in \mathbb { R } ^ { K _ { l } }$ and $\pmb { \lambda } _ { n } ^ { ( l ) } \in \mathbb { R } ^ { K _ { l } }$ are both deterministically transformed from the observation ${ \mathbf { \mathcal { x } } } _ { n }$ using the neural networks, as illustrated in Fig. 2a and specified as
+
+$$
+\begin{array} { r l } & { \mathbf { \boldsymbol { k } } _ { n } ^ { ( l ) } = \ln [ 1 + \exp ( \mathbf { \boldsymbol { W } } _ { 1 } ^ { ( l ) } \boldsymbol { h } _ { n } ^ { ( l ) } + \boldsymbol { b } _ { 1 } ^ { ( l ) } ) ] , } \\ & { \lambda _ { n } ^ { ( l ) } = \ln [ 1 + \exp ( \mathbf { \boldsymbol { W } } _ { 2 } ^ { ( l ) } \boldsymbol { h } _ { n } ^ { ( l ) } + \boldsymbol { b } _ { 2 } ^ { ( l ) } ) ] , } \\ & { \boldsymbol { h } _ { n } ^ { ( l ) } = \ln [ 1 + \exp ( \mathbf { \boldsymbol { W } } _ { 3 } ^ { ( l ) } \boldsymbol { h } _ { n } ^ { ( l - 1 ) } + \boldsymbol { b } _ { 3 } ^ { ( l ) } ) ] , } \end{array}
+$$
+
+where $\pmb { h } _ { n } ^ { ( 0 ) } = \log ( 1 + \pmb { x } _ { n } )$ , $\mathbf { W } _ { 1 } ^ { ( l ) } \in \mathbb { R } ^ { K _ { l } \times K _ { l } }$ , $\mathbf { W } _ { 2 } ^ { ( l ) } \in \mathbb { R } ^ { K _ { l } \times K _ { l } }$ , $\mathbf { W } _ { 3 } ^ { ( l ) } \in \mathbb { R } ^ { K _ { l } \times K _ { l - 1 } }$ , $b _ { 1 } ^ { ( l ) } \in \mathbb { R } ^ { K _ { l } }$ , $b _ { 2 } ^ { ( l ) } \in \mathbb { R } ^ { K _ { l } }$ , and $b _ { 3 } ^ { ( l ) } \in \mathbb { R } ^ { K _ { l } }$ . This upward-downward inference network is distinct from that of a usual VAE, where it is common that the inference network has a pure bottom-up structure and only interacts with the generative model via the ELBO (Kingma $\&$ Welling, 2014; Ishaan et al., 2017). Note that WUDVE no longer follows mean-field variational Bayes to make a fully factorized assumption as in (4).
+
+Comparing Figs. 2c and 2a show that in each iteration, both Gibbs sampling and WUDVE have not only an upward information propagation (orange arrows), but also a downward one (blue arrows), but their underlying implementations are distinct from each other. Gibbs sampling in Fig. 2c does not have an inference network and needs the local variables $\pmb { \theta } _ { n } ^ { ( l ) }$ to help perform stochastic upward information propagation, whereas WUDVE in Fig. 2a uses its non-probabilistic part to perform deterministic upward information propagation, without relying on the local variables $\pmb { \theta } _ { n } ^ { ( l ) }$ . It is also interesting to notice that the upward-downward structure of WUDVE, motivated by the upwarddownward Gibbs sampler of DLDA, is closely related to that used in the ladder VAE of Sonderby et al. (2016). However, to combine the bottom-up and top-down information, ladder VAE relies on some heuristic restricted to Gaussian latent variables.
+
+# 2.3 HYBRID MCMC/VAE INFERENCE
+
+In Section 2.1, we describe how to use TLASGR-MCMC of Cong et al. (2017a), a stochasticgradient MCMC algorithm for DLDA, to sample the global parameters $\{ \Phi ^ { ( l ) } \} _ { 1 , L }$ ; whereas in Section 2.2.2, we describe how to use WUDVE, an autoencoding variational inference network, to approximate the conditional posterior of the local parameters $\{ \pmb { \theta } _ { n } ^ { ( l ) } \} _ { 1 , L }$ given $\{ \Phi ^ { ( l ) } \} _ { 1 , L }$ and observation ${ \mathbf { \mathcal { x } } } _ { n }$ . Rather than merely finding a point estimate of the global parameters $\{ \Phi ^ { ( l ) } \} _ { 1 , L }$ we describe in Algorithm 1 how to combine TLASGR-MCMC and the proposed WUDVE into a hybrid MCMC/VAE inference algorithm, which infers posterior samples for both the global parameters $\{ \Phi ^ { ( l ) } \} _ { 1 , L }$ of the generative network, and the corresponding neural network parameters $\boldsymbol \Omega = \{ \mathbf { W } _ { 1 } ^ { ( l ) } , \boldsymbol { b } _ { 1 } ^ { ( l ) } , \mathbf { W } _ { 2 } ^ { ( l ) } , \boldsymbol { b } _ { 2 } ^ { ( l ) } , \mathbf { W } _ { 3 } ^ { ( l ) } , \boldsymbol { b } _ { 3 } ^ { ( l ) } \} _ { 1 , L }$ of the inference network. Being able to efficiently evaluating the gradient of the ELBO is important to the success of a variational inference algorithm (Hoffman et al., 2013; Paisley et al., 2012; Kingma & Welling, 2014; Mnih & Gregor, 2014; Ranganath et al., 2015; Ruiz et al., 2016; Rezende et al., 2014). An important step of Algorithm 1 is calculating the gradient of the ELBO in (3) with respect to the NN parameters $\pmb { \Omega }$ . Thanks to the choice of the Weibull distribution, the second term of the ELBO in (3) is analytic, and due to simple reparameterization of the Weibull distribution, the gradient of the first term of the ELBO with respect to $\pmb { \Omega }$ can be accurately evaluated, achieving satisfactory performance using even a single Monte Carlo sample, as shown in our experimental results. Thanks to the architecture of WUDVE, using the inference network, for a new mini-batch, we can directly find the conditional posteriors of $\{ \pmb { \theta } _ { n } ^ { ( l ) } \} _ { 1 , L }$ given $\{ \Phi ^ { ( l ) } \} _ { 1 , L }$ and the stochastically updated $\pmb { \Omega }$ , with which we can sample the local parameters and then use TLASGR-MCMC to stochastically update the global parameters $\{ \Phi ^ { ( l ) } \} _ { 1 , L }$ .
+
+![](images/73966c449ae8047e0d29c648b34143d5b8d901c36d3dc1c2bcde883bc02e567e.jpg)  
+Figure 2: (a-b): Inference (or encoder/recognition) and generative (or decoder) models for (a) WHAI and (b) AVITM; (c) the generative model and a sketch of the upward-downward Gibbs sampler of DLDA, where $\mathbf { Z } ^ { l }$ are augmented latent counts that are upward sampled in each Gibbs sampling iteration. Circles are stochastic variables and squares are deterministic variables. The orange and blue arrows denote the upward and downward information propagation respectively, and the red ones denote the data generation.
+
+# 2.4 VARIATIONS OF WHAI
+
+To clearly understand how each component contributes to the overall performance of WHAI, below we consider two different variations: GHAI and WAI. We first consider gamma hybrid autoencoding inference (GHAI). In WUDVE, the inference network for WHAI, we have a deterministic-upward and stochastic-downward structure, where the reparameterizable Weilbull distribution is used to connect adjacent stochastic layers. Although we choose to use the Weibull distribution for the reasons specified in Section 2.2.1, one may also choose some other distribution in the downward structure. For example, one may choose the gamma distribution and replace (6) with
+
+$$
+q ( \theta _ { n } ^ { ( l ) } | \Phi ^ { ( l + 1 ) } , \mathbf { h } _ { n } ^ { ( l ) } , \pmb { \theta } _ { n } ^ { ( l + 1 ) } ) = \mathrm { G a m m a } ( \pmb { k } _ { n } ^ { ( l ) } + \Phi ^ { ( l + 1 ) } \pmb { \theta } _ { n } ^ { ( l + 1 ) } , \pmb { \lambda } _ { n } ^ { ( l ) } ) .
+$$
+
+Even though the gamma distribution does not have a simple reparameteriation, one may use the RSVI of Naesseth et al. to define an approximate reparameterization procedure via rejection sampling. More specifically, following Naesseth et al., to generate a gamma random variable $z \sim \mathrm { G a m m a } ( \alpha , \beta )$ , one may first use the rejection sampler of Marsaglia & Tsang (2000) to generate $\tilde { z } \sim \mathrm { G a m m a } ( \alpha + B , 1 )$ , for which the proposal distribution is expressed as
+
+$$
+\tilde { z } = \left( \alpha + B - \frac { 1 } { 3 } \right) \left( 1 + \frac { \varepsilon } { \sqrt { 9 ( \alpha + B ) - 3 } } \right) ^ { 3 } , \mathrm { ~ } \varepsilon \sim \mathcal { N } ( 0 , 1 ) ,
+$$
+
+Set mini-batch size $m$ and the number of layer $L$   
+Initialize encoder parameter $\pmb { \Omega }$ and model parameter $\{ \Phi ^ { ( l ) } \} _ { 1 , L }$ .   
+for $i t e r = 1 , 2 , \cdots$ do Randomly select a mDraw random noise $m$ documents to form a subset m uniform distribution; $\mathbf { X } = \{ \pmb { x } _ { i } \} _ { 1 , m }$ ; $\left\{ \varepsilon _ { i } ^ { l } \right\} _ { i = 1 , l = 1 } ^ { m , L }$ Calculate $\nabla _ { \Omega } L \left( \Omega , \Phi ^ { \{ l \} } ; \mathbf { X } , \varepsilon _ { i } ^ { l } \right)$ according to (3), and update $\pmb { \Omega }$ ; Sample ${ \pmb \theta } _ { i } ^ { \{ l \} }$ from (6) via $\pmb { \Omega }$ to update topics $\{ \Phi ^ { ( l ) } \} _ { l = 1 } ^ { L }$ according to (2);   
+end for
+
+where $B$ is a pre-set integer to make the acceptance probability be close to 1; one then lets $z = \beta ^ { - 1 } \tilde { z } \prod _ { i = 1 } ^ { B } { u _ { i } } ^ { 1 / ( \alpha + i - 1 ) }$ , where $u _ { i } \sim \mathrm { U n i f o r m } ( 0 , 1 )$ . The gradients of the ELBO, however, could still suffer from relatively high variance, as how likely a proposed $\varepsilon$ will be accepted depends on the gamma distribution parameters, and $B$ extra uniform random variables $\{ u _ { i } \} _ { 1 , B }$ need to be introduced.
+
+To demonstrate the advantages of the proposed hybrid inference for WHAI, which infers posterior samples of the global parameters, including $\{ \Phi ^ { ( l ) } \} _ { 1 , L }$ and $\pmb { \Omega }$ , using TLASGR-MCMC, we also consider Weibull autoencoding inference (WAI) that has the same inference network as WHAI but infers $\{ \Phi ^ { ( l ) } \} _ { 1 , L }$ and $\pmb { \Omega }$ using stochastic gradient decent (SGD) (Kingma & Ba, 2015). Note that as argued in Mandt et al. (2017), SGD can also be used for approximate Bayesian inference. We will show in experiments that sampling the global parameters via TLASGR-MCMC provides improved performance in comparison to sampling them via SGD.
+
+To understand the importance of the stochastic-downward structure used in the inference network, and further understand the differences between using the Weibull distribution with simple reparameterization and using the gamma distribution with RSVI, we also consider DLDA-GHAI-Independent and DLDA-WHAI-Independent that remove the stochastic-downward connections of DLDA-GHAI and DLDAas Weilbull spec and fically, they define , respectively, and $q ( \pmb \theta _ { n } ^ { ( l ) } \mid \Phi ^ { ( l + 1 ) } , \pmb h _ { n } ^ { ( l ) } , \pmb \theta _ { n } ^ { ( l + 1 ) } )$ in (6) RSVI, (k(l)n , λ(l)n ) $\mathrm { G a m m a } ( \boldsymbol { k } _ { n } ^ { ( l ) } , \bar { \lambda } _ { n } ^ { ( l ) } )$
+
+# 3 EXPERIMENTAL RESULTS
+
+We compare the performance of different algorithms on 20Newsgroups (20News), Reuters Corpus Volume I (RCV1), and Wikipedia (Wiki). 20News consists of 18,845 documents with a vocabulary size of 2,000. RCV1 consists of 804,414 documents with a vocabulary size of 10,000. Wiki, with a vocabulary size of 7,702, consists of 10 million documents randomly downloaded from Wikipedia using the script provided for Hoffman et al. (2010). Similar to Cong et al. (2017a), we randomly select 100,000 documents for testing. To be consistent with previous settings (Gan et al., 2015; Henao et al., 2015; Cong et al., 2017a), no precautions are taken in the Wikipedia downloading script to prevent a testing document from being downloaded into a mini-batch for training. Our code is written in Theano (Theano Development Team, 2016).
+
+For comparison, we consider the deep Poisson factor analysis (DPFA) of Gan et al. (2015), DLDAGibbs of Zhou et al. (2016), DLDA-TLASGR of Cong et al. (2017a), and AVITM of Srivastava & Sutton (2017), using the code provided by the authors. Note that as shown in Cong et al. (2017a), DLDA-Gibbs and DLDA-TLASGR are state-of-the-art topic modeling algorithms that clearly outperform a large number of previously proposed ones, such as the replicated softmax of Salakhutdinov & Hinton (2009) and the nested Hierarchical Dirichlet process of Paisley et al. (2015).
+
+# 3.1 PER-HELDOUT-WORD PERPLEXITY
+
+Per-heldout-word perplexity is a widely-used performance measure. Similar to Wallach et al. (2009), Paisley et al. (2011), and Zhou et al. (2012), for each corpus, we randomly select $7 0 \%$ of the word
+
+Table 1: Comparison of per-heldout-word perplexity and testing time (average seconds per document) on three different datasets.   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Size</td><td colspan="3">Perplexity</td><td colspan="3">Test Time</td></tr><tr><td>20News</td><td>RCV1</td><td>Wiki</td><td>20News</td><td>RCV1</td><td>Wiki</td></tr><tr><td>DLDA-Gibbs</td><td>128-64-32</td><td>571</td><td>938</td><td>966</td><td>10.46</td><td>23.38</td><td>23.69</td></tr><tr><td>DLDA-Gibbs</td><td>128-64</td><td>573</td><td>942</td><td>968</td><td>8.73</td><td>18.50</td><td>19.79</td></tr><tr><td>DLDA-Gibbs</td><td>128</td><td>584</td><td>951</td><td>981</td><td>4.69</td><td>12.57</td><td>13.31</td></tr><tr><td>DLDA-TLASGR</td><td>128-64-32</td><td>579</td><td>950</td><td>978</td><td>10.46</td><td>23.38</td><td>23.69</td></tr><tr><td>DLDA-TLASGR</td><td>128-64</td><td>581</td><td>955</td><td>979</td><td>8.73</td><td>18.50</td><td>19.79</td></tr><tr><td>DLDA-TLASGR</td><td>128</td><td>590</td><td>963</td><td>993</td><td>4.69</td><td>12.57</td><td>13.31</td></tr><tr><td>DPFA</td><td>128-64-32</td><td>637</td><td>1041</td><td>1056</td><td>20.12</td><td>34.21</td><td>35.41</td></tr><tr><td>AVITM</td><td>128</td><td>654</td><td>1062</td><td>1088</td><td>0.23</td><td>0.68</td><td>0.80</td></tr><tr><td>DLDA-GHAI-Independent</td><td>128-64-32</td><td>613</td><td>970</td><td>999</td><td>0.62</td><td>1.22</td><td>1.47</td></tr><tr><td>DLDA-GHAI-Independent</td><td>128-64</td><td>614</td><td>970</td><td>1000</td><td>0.41</td><td>0.94</td><td>1.01</td></tr><tr><td>DLDA-GHAI-Independent</td><td>128</td><td>615</td><td>972</td><td>1003</td><td>0.22</td><td>0.69</td><td>0.80</td></tr><tr><td>DLDA-GHAI</td><td>128-64-32</td><td>604</td><td>963</td><td>994</td><td>0.66</td><td>1.25</td><td>1.49</td></tr><tr><td>DLDA-GHAI</td><td>128-64</td><td>608</td><td>965</td><td>997</td><td>0.44</td><td>0.96</td><td>1.05</td></tr><tr><td>DLDA-GHAI</td><td>128</td><td>615</td><td>972</td><td>1003</td><td>0.22</td><td>0.69</td><td>0.80</td></tr><tr><td>DLDA-WHAI-Independent</td><td>128-64-32</td><td>588</td><td>964</td><td>990</td><td>0.58</td><td>1.15</td><td>1.38</td></tr><tr><td>DLDA-WHAI-Independent</td><td>128-64</td><td>589</td><td>965</td><td>992</td><td>0.38</td><td>0.87</td><td>0.97</td></tr><tr><td>DLDA-WHAI-Independent</td><td>128</td><td>592</td><td>966</td><td>996</td><td>0.20</td><td>0.66</td><td>0.78</td></tr><tr><td>DLDA-WAI</td><td>128-64-32</td><td>581</td><td>954</td><td>984</td><td>0.63</td><td>1.20</td><td>1.43</td></tr><tr><td>DLDA-WAI</td><td>128-64</td><td>583</td><td>958</td><td>986</td><td>0.42</td><td>0.91</td><td>1.02</td></tr><tr><td>DLDA-WAI</td><td>128</td><td>593</td><td>967</td><td>999</td><td>0.20</td><td>0.66</td><td>0.78</td></tr><tr><td>DLDA-WHAI</td><td>128-64-32</td><td>581</td><td>953</td><td>980</td><td>0.63</td><td>1.20</td><td>1.43</td></tr><tr><td>DLDA-WHAI</td><td>128-64</td><td>582</td><td>957</td><td>982</td><td>0.42</td><td>0.91</td><td>1.02</td></tr><tr><td>DLDA-WHAI</td><td>128</td><td>591</td><td>965</td><td>996</td><td>0.20</td><td>0.66</td><td>0.78</td></tr></table>
+
+tokens from each document to form a training matrix $\mathbf { T }$ , holding out the remaining $3 0 \%$ to form a testing matrix $\mathbf { Y }$ . We use $\mathbf { T }$ to train the model and calculate the per-heldout-word perplexity as
+
+$$
+\exp \left\{ - \frac { 1 } { y . . } \sum _ { v = 1 } ^ { V } \sum _ { n = 1 } ^ { N } y _ { v n } \ln \frac { \sum _ { s = 1 } ^ { S } \sum _ { k = 1 } ^ { K ^ { 1 } } \phi _ { v k } ^ { ( 1 ) s } \theta _ { k n } ^ { ( 1 ) s } } { \sum _ { s = 1 } ^ { S } \sum _ { v = 1 } ^ { V } \sum _ { k = 1 } ^ { K ^ { 1 } } \phi _ { v k } ^ { ( 1 ) s } \theta _ { k n } ^ { ( 1 ) s } } \right\} ,
+$$
+
+where $S$ is the total number of collected samples and $\begin{array} { r } { y _ { \cdot \cdot } = \sum _ { v = 1 } ^ { V } \sum _ { n = 1 } ^ { N ^ { ' } } y _ { v n } } \end{array}$ PVv=1 PNn=1 yvn. For the proposed model, we set the mini-batch size as 200, and use as burn-in 2000 mini-batches for both 20News and RCV1 and 3500 for wiki. We collect 3000 samples after burn-in to calculate perplexity. The hyperparameters of WHAI are set as: $\eta ^ { ( l ) } = 1 / K _ { l }$ , $\mathbf r = \mathbf 1$ , and $c _ { n } ^ { ( l ) } = 1$ .
+
+Table 1 lists for various algorithms both the perplexity and the average run time per testing document given a single sample (estimate) of the global parameters. Clearly, given the same generative network structure, DLDA-Gibbs performs the best in terms of predicting heldout word tokens, which is not surprising as this batch algorithm can sample from the true posteriors given enough Gibbs sampling iterations. DLDA-TLASGR is a mini-batch algorithm that is much more scalable in training than DLDA-Gibbs, at the expense of slighted degraded performance in out-of-sample prediction. Both DLDA-WAI, using SGD to infer the global parameters, and DLDA-WHAI, using a stochasticgradient MCMC to infer the global parameters, slightly underperform DLDA-TLASGR; all minibatch based algorithms are scalable to a big training corpus, but due to the use of the WUDVE inference network, both DLDA-GHAI and DLDA-WHAI, as well as their variations, are considerably fast in processing a testing document. In terms of perplexity, all algorithms with DLDA as the generative model clearly outperform both DPFA of Gan et al. (2015) and AVITM of Srivastava & Sutton (2017), while in terms of the computational cost for testing, all algorithms with an inference network, such as AVITM, DLDA-GHAI, and DLDA-WHAI, clearly outperform these relying on an interactive procedure for out-of-sample prediction, including DPFA, DLDA-Gibbs, and DLDA-TLASGR. It is also clear that except for DLDA-GHAI-Independent and DLDA-WHAI-Independent that have no stochastic-downward components in their inference, all the other algorithms with DLDA as the generative model have a clear trend of improvement as the generative network becomes deeper, indicating the importance of having stochastic-downward information propagation during posterior inference; and DLDA-WHAI with a single hidden layer already clearly outperforms AVITM, indicating that using the Weibull distribution is more appropriate than using the logistic-normal distribution to model the document latent representation. Furthermore, thanks to the use of the stochastic gradient based TLASGR-MCMC rather than a simple SGD procedure, DLDA-WHAI consistently outperforms DLDA-WAI. Last but not least, while DLDA-GHAI that relies on RSVI to approximately reparameterize the gamma distributions clearly outperforms AVITM and DPFA, it clearly underperforms DLDA-WHAI that has simple reparameterizations for its Weibull distributions.
+
+![](images/955981f5a9a6a19435e98659db58a8cf4961d3af1af64054e83e10fbfe2cac1a.jpg)  
+Figure 3: Plot of per-heldout-word perplexity as a function of time for (a) 20News, (b) RCV1, and (c) Wiki. Except for AVITM that has a single hidden layer with 128 topics, all the other algorithms have the same network size of 128-64-32 for their deep generative models.
+
+Below we examine how various inference algorithms progress over time during training, evaluated with per-holdout-word perplexity. As clearly shown in Fig. 3, DLDA-WHAI outperforms DPFA and AVITM in providing lower perplexity as time progresses, which is not surprising as the DLDA multilayer generative model is good at document representation, while AVITM is only "deep" in the deterministic part of its inference network and DPFA is restricted to model binary topic usage patterns via its deep network. When DLDA is used as the generative model, in comparison to Gibbs sampling and TLASGR-MCMC on two large corpora, RCV1 and Wiki, the mini-batch based WHAI converges slightly slower than TLASGR-MCMC but much faster than Gibbs sampling; WHAI consistently outperforms WAI, which demonstrates the advantage of the hybrid MCMC/VAE inference; in addition, the RSVI based DLDA-GHAI clearly converges more slowly in time than DLDAWHAI. Note that for all three datasets, the perplexity of TLASGR decreases at a fast rate, followed by closely by WHAI, while that of Gibbs sampling decreases slowly, especially for RCV1 and Wiki, as shown in Figs. 3(b-c). This is expected as both RCV1 and Wiki are much larger corpora, for which a mini-batch based inference algorithm can already make significant progress in inferring the global model parameters, before a batch-learning Gibbs sampler finishes a single iteration that needs to go through all documents. We also notice that although AVITM is fast for testing via the use of a VAE, its representation power is limited due to not only the use of a shallow topic model, but also the use of a latent Gaussian based inference network that is not naturally suited to model document latent representation.
+
+# 3.2 TOPIC HIERARCHY AND MANIFOLD
+
+In addition to quantitative evaluations, we have also visually inspected the inferred topics at different layers and the inferred connection weights between the topics of adjacent layers. Distinct from many existing deep learning models that build nonlinearity via “black-box” neural networks, we can easily visualize the whole stochastic network, whose hidden units of layer $l - 1$ and those of layer $l$ are connected by $\phi _ { k ^ { \prime } k } ^ { ( l ) }$ that are sparse. In particular, we can understand the meaning of each hidden unit by projecting it back to the original data space via $\left[ \prod _ { t = 1 } ^ { l - 1 } \Phi ^ { ( t ) } \right] \phi _ { k } ^ { ( l ) }$ . We show in Fig. 4 a subnetwork, originating from units 16, 19, and 24 of the top hidden layer, taken from the generative network of size 128-64-32 inferred on Wiki. The semantic meaning of each topic and the connections between different topics are highly interpretable. We provide several additional topic hierarchies for Wiki in the Appendix.
+
+![](images/bccad350bd63987708ece31b4b2b19938e4233c4a86afecc64c2b7ac349fb130.jpg)  
+Figure 4: An example of hierarchical topics learned from Wiki by a three-hidden-layer WHAI of size 128-64-32.
+
+![](images/7e626e2fe3ebf5b77184c614514f6d59128963d957022bd06aefeaeb42ddca7a.jpg)  
+Figure 5: Learned topics on MNIST digits with a three-hidden-layer WHAI of size 128-64- 32. Shown in (a)-(c) are example topics for layers 1, 2 and 3, respectively, learned with a deterministic-upward-stochastic-downward encoder, and shown in (d)-(f) are the ones learned with a deterministic-upward encoder.
+
+To further illustrate the effectiveness of our multilayer representation in our model, we apply a threehidden-layer WHAI to MNIST digits and present the learned dictionary atoms. We use the Poisson likelihood directly to model the MNIST digit pixel values that are nonnegative integers ranging from 0 to 255. As shown in Figs. 5a-5c, it is clear that the factors at layers one to three represent localized points, strokes, and digit components, respectively, that cover increasingly larger spatial regions. This type of hierarchical visual representation is difficult to achieve with other types of deep neural networks (Srivastava et al., 2013; Kingma & Welling, 2014; Rezende et al., 2014; Sonderby et al., 2016).
+
+WUDVE, the inference network of WHAI, has a deterministic-upward-stochastic-downward structure, in contrast to a conventional VAE that often has a pure deterministic bottom-up structure. Here, we further visualize the importance of the stochastic-downward part of WUDVE through a simple experiment. We remove the stochastic-downward part of WUDVE shown in (6) and define the inference network as $q ( \pmb { \theta } _ { n } ^ { ( l ) } | \pmb { h } _ { n } ^ { ( l ) } ) = \mathrm { W e i b u l l } ( \pmb { k } _ { n } ^ { ( l ) } , \mathbf { \bar { \lambda } } _ { n } ^ { ( l ) } )$ , in other words, we ignore the top-down information. As shown in Figs. 5d-5f, although some latent structures are learned, the hierarchical relationships between adjacent layers almost all disappear, indicating the importance of having a stochastic-downward structure together with a deterministic-upward one in the inference network.
+
+![](images/41e8d3206488bfab34498ed7225ccad0d2037e4c9a389bf5f131769ee8de907b.jpg)  
+Figure 6: Latent space interpolations on the MNIST test set. Left and right columns correspond to the images generated frominterpolated linearly from $z _ { 1 } ^ { ( 3 ) }$ 3) and z(3)2 , a nd the others are generated from the latent representations $z _ { 1 } ^ { ( 3 ) }$ to z 2 $z _ { 2 } ^ { ( 3 ) }$
+
+As a sanity check for latent representation and overfitting, we shown in Fig. 6 the latent space interpolations between the test set examples on MNIST dataset, and provide related results in the Appendix for the 20News corpus. With the 3-layer model learned before, following Dumoulin et al. (2016), we sample pairs of test set examples x1 and x2 and project them into z(3)1 a nd z 2 . We then linearly interpolate between $z _ { 1 } ^ { ( 3 ) }$ and $z _ { 2 } ^ { ( 3 ) }$ , and pass the intermediary points through the generative model to generate the input-space interpolations. In Fig. 6, the left and right column are the digits generated from $z _ { 1 } ^ { ( 3 ) }$ and $\bar { z } _ { 2 } ^ { ( 3 ) }$ , while the middle ones are generated from the interpolation latent space. We observe a smooth transitions between pairs of example, and intermediary images remain interpretable. In other words, the latent space the model learned is on a manifold, indicating that WHAI has learned a generalizable latent feature representation rather than concentrating its probability mass exclusively around training examples.
+
+# 4 CONCLUSION
+
+To infer a hierarchical latent representations of a big corpus, we develop Weibull hybrid autoencoding inference (WHAI) for deep latent Dirichlet allocation (DLDA), a deep probabilistic topic model that factorizes the observed high-dimensional count vectors under the Poisson likelihood and models the latent representation under the gamma likelihood at multiple different layers. WHAI integrates topic-layer-adaptive stochastic gradient Riemannian (TLASGR) MCMC to update the global parameters given the posterior sample of a mini-batch’s local parameters, and a Weibull distribution based upward-downward variational autoencoder to infer the conditional posterior of the local parameters given the stochastically updated global parameters. The use of the Weibull distribution, which resembles the gamma distribution and has a simple reparameterization, makes one part of the evidence lower bound (ELBO) analytic, and makes it efficient to compute the gradient of the non-analytic part of the ELBO with respect to the parameters of the inference network. Moving beyond deep models and inference procedures based on Gaussian latent variables, WHAI provides posterior samples for both the global parameters of the generative model and these of the inference network, yields highly interpretable multilayer latent document representation, is scalable to a big training corpus due to the use of a stochastic-gradient MCMC, and is fast in out-of-sample prediction due to the use of an inference network. Compelling experimental results on big text corpora demonstrate the advantages of WHAI in both quantitative and qualitative analysis.
+
+# 5 ACKNOWLEDGE
+
+This work is partially supported by the Fund for Foreign Scholars in University Research and Teaching Programs (the 111 Project) (No. B18039), the Thousand Young Talent Program of China, NSFC (61771361) , NSFC for Distinguished Young Scholars (61525105), and Innovation Fund of International Exchange Program for Graduate Student of Xidian University.
+
+# REFERENCES
+
+David M Blei, Andrew $\mathrm { ~ Y ~ N ~ g ~ }$ , and Michael I Jordan. Latent Dirichlet allocation. Journal of Machine Learning Research, 3(Jan):993–1022, 2003.
+
+Yulai Cong, Bo Chen, Hongwei Liu, and Mingyuan Zhou. Deep latent Dirichlet allocation with topic-layer-adaptive stochastic gradient riemannian mcmc. In ICML, 2017a.
+
+Yulai Cong, Bo Chen, and Mingyuan Zhou. Fast simulation of hyperplane-truncated multivariate normal distributions. Bayesian Analysis, 2017b.
+
+Zhenwen Dai, Andreas C Damianou, Javier Gonzalez, and Neil D Lawrence. Variational autoencoded deep Gaussian processes. In ICLR, 2016.
+
+Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Alex Lamb, Martin Arjovsky, Olivier Mastropietro, and Aaron Courville. Adversarially learned inference. arXiv:1606.00704, 2016.
+
+Zhe Gan, Changyou Chen, Ricardo Henao, David Carlson, and Lawrence Carin. Scalable deep Poisson factor analysis for topic modeling. In ICML, pp. 1823–1832, 2015.
+
+Ricardo Henao, Zhe Gan, James Lu, and Lawrence Carin. Deep Poisson factor modeling. In NIPS, pp. 2800–2808, 2015.
+
+M. Hoffman, D. Blei, and F. Bach. Online learning for latent Dirichlet allocation. In NIPS, 2010.
+
+Matthew D Hoffman, David M Blei, Chong Wang, and John William Paisley. Stochastic variational inference. Journal of Machine Learning Research, 14(1):1303–1347, 2013.
+
+Gulrajani Ishaan, Kumar Kundan, Ahmed Faruk, Taiga Adrien, Ali, Visin Francesco, Vazquez David, and Courville Aaron. Pixelvae: A latent variable model for natural images. In ICLR, 2017.
+
+Michael I Jordan, Zoubin Ghahramani, Tommi S Jaakkola, and Lawrence K Saul. An introduction to variational methods for graphical models. Machine learning, 37(2):183–233, 1999.
+
+Diederik P Kingma and Jimmy Lei Ba. Adam: A method for stochastic optimization. In ICLR, 2015.
+
+Diederik P Kingma and Max Welling. Stochastic gradient VB and the variational auto-encoder. In ICLR, 2014.
+
+David A Knowles. Stochastic gradient variational Bayes for gamma approximating distributions. arXiv preprint arXiv:1509.01631, 2015.
+
+Y. Ma, T. Chen, and E. Fox. A complete recipe for stochastic gradient MCMC. In NIPS, pp. 2899–2907, 2015.
+
+Stephan Mandt, Matthew D Hoffman, and David M Blei. Stochastic gradient descent as approximate Bayesian inference. arXiv:1704.04289, to appear in Journal of Machine Learning Research, 2017.
+
+George Marsaglia and Wai Wan Tsang. A simple method for generating gamma variables. ACM Transactions on Mathematical Software (TOMS), 26(3):363–372, 2000.
+
+Andriy Mnih and Karol Gregor. Neural variational inference and learning in belief networks. In ICML, pp. 1791–1799, 2014.
+
+Christian Naesseth, Francisco Ruiz, Scott Linderman, and David Blei. Reparameterization gradients through acceptance-rejection sampling algorithms. In AISTATS.
+
+J. Paisley, C. Wang, and D. Blei. The discrete infinite logistic normal distribution for mixedmembership modeling. In AISTATS, 2011.
+
+J. Paisley, C. Wang, D. M. Blei, and M. I. Jordan. Nested hierarchical Dirichlet processes. IEEE Trans. Pattern Anal. Mach. Intell., 2015.
+
+John Paisley, David M Blei, and Michael I Jordan. Variational Bayesian inference with stochastic search. In Proceedings of the 29th International Coference on International Conference on Machine Learning, pp. 1363–1370. Omnipress, 2012.
+
+Sam Patterson and Yee Whye Teh. Stochastic gradient Riemannian Langevin dynamics on the probability simplex. In NIPS, pp. 3102–3110, 2013.
+
+Rajesh Ranganath, Linpeng Tang, Laurent Charlin, and David Blei. Deep exponential families. In AISTATS, pp. 762–771, 2015.
+
+Danilo J Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proceedings of the 31st International Conference on Machine Learning (ICML-14), pp. 1278–1286, 2014.
+
+Francisco JR Ruiz, Michalis K Titsias, and David M Blei. The generalized reparameterization gradient. In NIPS, pp. 460–468, 2016.
+
+Ruslan Salakhutdinov and Geoffrey E Hinton. Replicated softmax: an undirected topic model. In NIPS, pp. 1607–1614, 2009.
+
+Casper Kaae Sonderby, Tapani Raiko, Lars Maaloe, Soren Kaae Sonderby, and Ole Winther. Ladder variational autoencoders. In NIPS, pp. 3738–3746, 2016.
+
+Akash Srivastava and Charles Sutton. Autoencoding variational inference for topic models. In ICLR, 2017.
+
+Nitish Srivastava, Ruslan Salakhutdinov, and Geoffrey E Hinton. Modeling documents with deep Boltzmann machines. In Uncertainty in Artificial Intelligence, 2013.
+
+Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.02688, May 2016.
+
+H. M. Wallach, I. Murray, R. Salakhutdinov, and D. Mimno. Evaluation methods for topic models. In ICML, 2009.
+
+M. Welling and Y. W. Teh. Bayesian learning via stochastic gradient Langevin dynamics. In ICML, pp. 681–688, 2011.
+
+Mingyuan Zhou, Lauren Hannah, David B Dunson, and Lawrence Carin. Beta-negative binomial process and Poisson factor analysis. In AISTATS, pp. 1462–1471, 2012.
+
+Mingyuan Zhou, Yulai Cong, and Bo Chen. The Poisson gamma belief network. In NIPS, pp. 3043–3051, 2015.
+
+Mingyuan Zhou, Yulai Cong, and Bo Chen. Augmentable gamma belief networks. J. Mach. Learn. Res., 17(163):1–44, 2016.
+
+# A HIERARCHICAL TOPICS LEARNED FROM WIKI
+
+![](images/31fb4889ef8e222ae9e067ec6b3e84136e83c7905c10c2074b4db9ed02c250cf.jpg)  
+Figure 7: An example of hierarchical topics learned from Wiki by a three-hidden-layer WHAI of size 128-64-32.
+
+![](images/a0104ecb3b2534ea333b739a8e0e251361a9f984a87b4d7eb2584b82ec28eb83.jpg)  
+Figure 8: An example of hierarchical topics learned from Wiki by a four-hidden-layer WHAI of size 256-128-64-32.
+
+# B MANIFOLD ON DOCUMENTS
+
+# From a sci.medicine document to an eci.space one
+
+1. com, writes, article, edu, medical, pitt, pain, blood, disease, doctor, medicine, treatment, patients, health, ibm   
+2. com, writes, article, edu, space, medical, pitt, pain, blood, disease, doctor, data, treatment, patients, health   
+3. space, com, writes, article, edu, data, medical, launch, earth, states, blood, moon, disease, satellite, medicine,   
+4. space, data, com, writes, article, edu, launch, earth, states, moon, satellite, shuttle, nasa, price, lunar   
+5. space, data, launch, earth, states, moon, satellite, case, com, shuttle, price, nasa, price, lunar, writes,   
+6. space, data, launch, earth, states, moon, orbit, satellite, case, shuttle, price, nasa, system, lunar, spacecraft
+
+# From a alt.atheism document to a soc.religion.christian one
+
+1. god, just, want, moral, believe, religion, atheists, atheism, christian, make, atheist, good, say, bible, faith   
+2. god, just, want, believe, jesus, christian, atheists, bible, atheism faith, say, make, religious, christians, atheist   
+3. god, jesus, just, faith, believe, christian, bible, want, church, say, religion, moral, lord, world, writes   
+4. god, jesus, faith, just, bible, church, christ, believe, say, writes, lord, religion, world, want, sin 5. god, jesus, faith, church, christ, bible, christian, say, write, lord, believe, truth, world, human, holy   
+6. god, jesus, faith, church, christ, bible, writes, say, christian, lord, sin, human, father, spirit, truth
+
+# From a com.graphics document to a comp.sys.ibm.pc.hardware one
+
+1. image, color, windows, files, image, thanks, jpeg, gif, card, bit, window, win, help, colors, format 2. image, windows, color, files, card, images, jpeg, thanks, gif, bit, window, win, colors, monitor, program   
+3. windows, image, color, card, files, gov, writes, nasa, article, images, program, jpeg, vidio, display, monitor   
+4. windows, gov, writes, nasa, article, card, going, program, image, color, memory, files, software, know, screen   
+5. gov, windows, writes, nasa, article, going, dos, card, memory, know, display, says, screen, work, ram   
+6. gov, writes, nasa, windows, article, going, dos, program, card, memory, software, says, ram, work, running

parse/train/S1cZsf-RW/S1cZsf-RW_content_list.json

@@ -0,0 +1,1547 @@
+[
+    {
+        "type": "text",
+        "text": "WHAI: WEIBULL HYBRID AUTOENCODING INFERENCE FOR DEEP TOPIC MODELING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hao Zhang, Bo Chen∗ & Dandan Guo   \nNational Laboraory of Radar Signal Processing,   \nCollaborative Innovation Center of Information Sensing and Understanding, Xidian University, Xi’an, China.   \nzhanghao_xidian@163.com bchen@mail.xidian.edu.cn gdd_xidian@126.com ",
+        "bbox": [
+            184,
+            170,
+            683,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mingyuan Zhou ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            276,
+            299,
+            289
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "McCombs School of Business, The University of Texas at Austin, Austin, TX 78712, USA. Mingyuan.Zhou@mccombs.utexas.edu ",
+        "bbox": [
+            184,
+            290,
+            575,
+            330
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            367,
+            544,
+            382
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To train an inference network jointly with a deep generative topic model, making it both scalable to big corpora and fast in out-of-sample prediction, we develop Weibull hybrid autoencoding inference (WHAI) for deep latent Dirichlet allocation, which infers posterior samples via a hybrid of stochastic-gradient MCMC and autoencoding variational Bayes. The generative network of WHAI has a hierarchy of gamma distributions, while the inference network of WHAI is a Weibull upward-downward variational autoencoder, which integrates a deterministicupward deep neural network, and a stochastic-downward deep generative model based on a hierarchy of Weibull distributions. The Weibull distribution can be used to well approximate a gamma distribution with an analytic Kullback-Leibler divergence, and has a simple reparameterization via the uniform noise, which help efficiently compute the gradients of the evidence lower bound with respect to the parameters of the inference network. The effectiveness and efficiency of WHAI are illustrated with experiments on big corpora. ",
+        "bbox": [
+            233,
+            397,
+            764,
+            590
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            614,
+            336,
+            631
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There is a surge of research interest in multilayer representation learning for documents. To analyze the term-document count matrix of a text corpus, Srivastava et al. (2013) extend the deep Boltzmann machine (DBM) with the replicated softmax topic model of Salakhutdinov & Hinton (2009) to infer a multilayer representation with binary hidden units, but its inference network is not trained to match the true posterior (Mnih & Gregor, 2014) and the higher-layer neurons learned by DBM are difficult to visualize. The deep Poisson factor models of Gan et al. (2015) are introduced to generalize Poisson factor analysis (Zhou et al., 2012), with a deep structure restricted to model binary topic usage patterns. Deep exponential families (DEF) of Ranganath et al. (2015) construct more general probabilistic deep networks with non-binary hidden units, in which a count matrix can be factorized under the Poisson likelihood, with the gamma distributed hidden units of adjacent layers linked via the gamma scale parameters. The Poisson gamma belief network (PGBN) (Zhou et al., 2015; 2016) also factorizes a count matrix under the Poisson likelihood, but factorizes the shape parameters of the gamma distributed hidden units of each layer into the product of a connection weight matrix and the gamma hidden units of the next layer, resulting in strong nonlinearity and readily interpretable multilayer latent representations. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Those multilayer probabilistic models are often characterized by a top-down generative structure, with the distribution of a hidden layer typically acting as a prior for the layer below. Despite being able to infer a multilayer representation of a text corpus with scalable inference (Patterson & ",
+        "bbox": [
+            176,
+            861,
+            823,
+            904
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Teh, 2013; Ruiz et al., 2016; Cong et al., 2017a), they usually rely on an iterative procedure to infer the latent representation of a new document at the testing stage, regardless of whether variational inference or Markov chain Monte Carlo (MCMC) is used. The potential need of a large number of iterations per testing document makes them unattractive when real-time processing is desired. For example, one may need to rapidly extract the topic-proportion vector of a document and use it for downstream analysis, such as identifying key topics and retrieving related documents. A potential solution is to construct a variational autoencoder (VAE) that learns the parameters of an inference network (recognition model or encoder) jointly with those of the generative model (decoder) (Kingma & Welling, 2014; Rezende et al., 2014). However, most existing VAEs rely on Gaussian latent variables, with the neural networks (NNs) acting as nonlinear transforms between adjacent layers (Sonderby et al., 2016; Dai et al., 2016; Ishaan et al., 2017). A primary reason is that there is a simple reparameterization trick for Gaussian latent variables that allows efficiently computing the noisy gradients of the evidence lower bound (ELBO) with respect to the NN parameters. Unfortunately, Gaussian based distributions often fail to well approximate the posterior distributions of sparse, nonnegative, and skewed document latent representations. For example, Srivastava & Sutton (2017) propose autoencoding variational inference for topic models (AVITM), as shown in Fig. 2b, which utilizes the logistic-normal distribution to approximate the posterior of the latent representation of a document; even though the generative model is latent Dirichlet allocation (LDA) (Blei et al., 2003), a basic single-hidden-layer topic model, due to the insufficient ability of the logistic-normal distribution to model sparsity, AVITM has to rely on some heuristic to force the latent representation of a document to be sparse. Another common shortcoming of existing VAEs is that they often only provide a point estimate for the global parameters of the generative model, and hence their inference network is optimized to approximate the posteriors of the local parameters conditioning on the data and the point estimate, rather than a full posterior, of the global parameters. In addition, from the viewpoint of probabilistic modeling, the inference network of a VAE is often merely a shallow probabilistic model, whose parameters, though, are deterministically nonlinearly transformed from the observations via a non-probabilistic deep neural network. ",
+        "bbox": [
+            174,
+            104,
+            825,
+            478
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address these shortcomings and move beyond Gaussian latent variable based deep models and inference procedures, we develop Weibull hybrid autoencoding inference (WHAI), a hybrid Bayesian inference for deep topic modeling that integrates both stochastic-gradient MCMC (Welling & Teh, 2011; Ma et al., 2015; Cong et al., 2017a) and a multilayer Weibull distribution based VAE. WHAI is related to a VAE in having both a decoder and encoder, but differs from a usual VAE in the following ways: 1) deep latent Dirichlet allocation (DLDA), a probabilistic deep topic model equipped with a gamma belief network, acts as the generative model; 2) inspired by the upward-downward Gibbs sampler of DLDA, as sketched in Fig. 2c, the inference network of WHAI uses a upwarddownward structure, as shown in Fig. 2a, to combine a non-probabilistic bottom-up deep NN and a probabilistic top-down deep generative model, with the \\`th hidden layer of the generative model linked to both the $( \\ell + 1 )$ th hidden layer of itself and the \\`th hidden layer of the deep NN; 3) a hybrid of stochastic-gradient MCMC and autoencoding variational inference is employed to infer both the posterior distribution of the global parameters, represented as collected posterior MCMC samples, and a VAE that approximates the posterior distribution of the local parameters given the data and a posterior sample (rather than a point estimate) of the global parameters; 4) we use the Weibull distributions in the inference network to approximate gamma distributed conditional posteriors, exploiting the fact that the Weibull and gamma distributions have similar probability density functions (PDFs), the Kullback-Leibler (KL) divergence from the Weibull to gamma distributions is analytic, and a Weibull random variable can be efficiently reparameterized with a uniform noise. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            748
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Note that we have also tried gamma hybrid autoencoding inference (GHAI), which directly uses the gamma distribution in the probabilistic top-down part of the inference network, while using rejection sampling variational inference (RSVI) of Naesseth et al. to approximately compute the gradient of the ELBO. While RSVI is a very general technique that can be applied to a wide variety of non-reparameterizable distributions, we find that for replacing the reparameterizable Weibull with non-reparameterizable gamma distributions in the inference network, the potential gains are overshadowed by the disadvantages of having to rely on an approximate reparameterization scheme guided by rejection sampling. In the experiments for deep topic modeling, we show that WHAI clearly outperforms GHAI, and both WHAI and GHAI outperform their counterparts that remove the top-down links of the inference network, referred to as WHAI-independent and GHAI-independent, respectively; WHAI is comparable to Gibbs sampling in terms performance, but is scalable to big training data via mini-batch stochastic-gradient based inference and is considerably fast in out-ofsample prediction via the use of an inference network. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            909
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 WHAI FOR MULTILAYER DOCUMENT REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            155,
+            666,
+            170
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Below we first describe the decoder and encoder of WHAI, and then provide a hybrid stochasticgradient MCMC and autoencoding variational inference that is fast in both training and testing. ",
+        "bbox": [
+            174,
+            186,
+            823,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 DOCUMENT DECODER: DEEP LATENT DIRICHLET ALLOCATION ",
+        "bbox": [
+            176,
+            234,
+            665,
+            248
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order to capture the hierarchical document latent representation, WHAI uses the Poisson gamma belief network (PGBN) of Zhou et al. (2016), a deep probabilistic topic model, as the generative network (encoder). Choosing a deep generative model as its decoder distinguishes WHAI from both AVITM, which uses a “shallow” LDA as its decoder, and a conventional VAE, which often uses as its decoder a “shallow” (transformed) Gaussian distribution, whose parameters are deterministically nonlinearly transformed from the observation via “black-box” deep neural networks. With all the gamma latent variables marginalized out, as shown in Cong et al. (2017a), the PGBN can also be represented as deep LDA (DLDA). For simplicity, below we use DLDA to refer to both the PGBN and DLDA representations of the same underlying deep generative model, as briefly described below. Note the single-hidden-layer version of DLDA reduces to Poisson factor analysis of Zhou et al. (2012), which is closely related to LDA. Let us denote $\\Phi ^ { ( 1 ) } \\in \\mathbb { R } _ { + } ^ { K _ { 0 } \\times K _ { 1 } }$ and $\\pmb { \\theta } _ { n } ^ { ( 1 ) } \\in \\mathbb { R } _ { + } ^ { K _ { 1 } }$ as the factor loading and latent representation of the first hidden layer of DLDA, respectively, where $\\mathbb { R } _ { + } = \\{ x , x \\geq \\bar { 0 } \\}$ and $K _ { 1 }$ is the number of topics (factors) of the first layer. We further restrict that the sum of each column of $\\Phi ^ { ( 1 ) }$ is equal to one. To model high-dimensional multivariate sparse count vectors ${ \\pmb x } _ { n } \\in \\mathbb { Z } ^ { K _ { 0 } }$ , where $\\mathbb { Z } = \\{ 0 , 1 , \\ldots \\}$ , under the Poisson likelihood, the DLDA generative model with $L$ hidden layers, from top to bottom, can be expressed as ",
+        "bbox": [
+            173,
+            261,
+            825,
+            489
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b2b200e6515295c4687835a689505f736f730b38cb7185e93ee1e58d28c122da.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\pmb { \\theta } _ { n } ^ { ( L ) } \\sim \\mathrm { G a m } \\left( \\boldsymbol { r } , c _ { n } ^ { ( L + 1 ) } \\right) , \\ldots , \\pmb { \\theta } _ { n } ^ { ( l ) } \\sim \\mathrm { G a m } \\left( \\Phi ^ { ( l + 1 ) } \\pmb { \\theta } _ { n } ^ { ( l + 1 ) } , c _ { n } ^ { ( l + 1 ) } \\right) , \\ldots , } \\\\ & { \\pmb { \\theta } _ { n } ^ { ( 1 ) } \\sim \\mathrm { G a m } \\left( \\Phi ^ { ( 2 ) } \\pmb { \\theta } _ { n } ^ { ( 2 ) } , c _ { n } ^ { ( 2 ) } \\right) , \\pmb { x } _ { n } \\sim \\mathrm { P o i s } \\left( \\Phi ^ { ( 1 ) } \\pmb { \\theta } _ { n } ^ { ( 1 ) } \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            496,
+            740,
+            553
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the hidden units $\\pmb { \\theta } _ { n } ^ { ( l ) } \\in \\mathbb { R } _ { + } ^ { K _ { l } }$ of layer $l$ are factorized into the product of the factor loading $\\Phi ^ { ( l ) } \\in \\mathbb { R } _ { + } ^ { K _ { l - 1 } \\times K _ { l } }$ and hidden units of the next layer. It infers a multilayer data representation, and can visualize its topic $\\phi _ { k } ^ { ( l ) }$ at hidden layer $l$ as $\\left[ \\prod _ { t = 1 } ^ { l - 1 } \\Phi ^ { ( t ) } \\right] \\phi _ { k } ^ { ( l ) }$ , which tend to be very specific in the bottom layer and become increasingly more general when moving upward. The unsupervisedly extracted multilayer latent representations θ(l)n are well suited for additional downstream analysis, such as document classification and retrieval. ",
+        "bbox": [
+            173,
+            560,
+            826,
+            664
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The upward-downward Gibbs sampling for DLDA, as described in detail in Zhou et al. (2016), is sketched in Fig. 2c, where $\\mathbf { Z } ^ { l }$ represent augmented latent counts that are sampled upward given the observations and model parameters. While having closed-form update equations, the Gibbs sampler requires processing all documents in each iteration and hence has limited scalability. Consequently, a topic-layer-adaptive stochastic gradient Riemannian (TLASGR) MCMC for DLDA, referred to as DLDA-TLASGR, is proposed to process big corpora (Cong et al., 2017a). Different from AVITM (Srivastava & Sutton, 2017) that models a probabilistic simplex with the expanded-natural representation (Patterson & Teh, 2013), DLDA-TLASGR uses a more elegant simplex constraint and increases the sampling efficiency via the use of the Fisher information matrix (FIM) (Cong et al., $2 0 1 7 \\mathrm { a } ; \\mathrm { b } )$ , with adaptive step-sizes for the topics of different layers. Specifically, suppose $\\phi _ { k } ^ { ( l ) }$ is the $k$ th topic in layer $\\ell$ with prior $\\phi _ { k } ^ { ( l ) } \\sim \\mathrm { D i r i c h l e t } ( \\eta _ { k } ^ { ( l ) } )$ , sampling it can be efficiently realized as ",
+        "bbox": [
+            173,
+            669,
+            826,
+            834
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4b8e7c113737c4fe44d52ab50d8f56b4e7b886c674ff1539fc042c24cafeb585.jpg",
+        "text": "$$\n( \\phi _ { k } ) _ { t + 1 } = \\left[ ( \\phi _ { k } ) _ { t } + \\frac { \\varepsilon _ { t } } { M _ { k } } \\left[ ( \\rho \\tilde { z } _ { : k } , + \\eta _ { k } ^ { ( l ) } ) - ( \\rho \\tilde { z } _ { : k } , + \\eta _ { k } ^ { ( l ) } V ) ( \\phi _ { k } ) _ { t } \\right] + \\mathcal { N } \\left( \\mathbf { 0 } , \\frac { 2 \\varepsilon _ { t } } { M _ { k } } d i a g ( \\phi _ { k } ) _ { t } \\right) \\right] _ { \\angle } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            189,
+            842,
+            787,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $M _ { k }$ is calculated using the estimated FIM, both $\\tilde { z } _ { : k }$ · and $\\tilde { z } _ { \\cdot k }$ · come from the augmented latent counts $\\mathbf { Z }$ , and $[ \\cdot ] _ { \\angle }$ denotes a simplex constraint; more details about TLASGR-MCMC for DLDA can be found in Cong et al. (2017a) and are omitted here for brevity. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/0d09911f1fbd11599c0ebb05f9a5425c7239f489abb2456d083af570923e914c.jpg",
+        "image_caption": [
+            "Figure 1: The $\\mathrm { K L }$ divergence from the inferred Weibull distribution to the target gamma one as (a) Gamma(0.05, 1), (b) Gamma(0.5, 1), and (c) $\\operatorname { G a m m a } ( 5 , 1 )$ . Subplot (d) shows the KL divergence as a function of the gamma shape parameter, where the gamma scale parameter is fixed at 1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            108,
+            794,
+            236
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Despite the attractive properties, neither the Gibbs sampler nor TLASGR-MCMC of DLDA can avoid taking a potentially large number of MCMC iterations to infer the latent representation of a testing document, which hinders real-time processing of the incoming documents and motivates us to construct an inference network with fast out-of-sample prediction, as described below. ",
+        "bbox": [
+            174,
+            309,
+            825,
+            366
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 DOCUMENT ENCODER: WEIBULL UPWARD-DOWNWARD VARIATIONAL ENCODER ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            382,
+            771,
+            397
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A VAE uses an inference network to map the observations directly to their latent representations. However, their success so far is mostly restricted to Gaussian distributed latent variables, and does not generalize well to model sparse, nonnegative, and skewed latent document representations. To move beyond latent Gaussian models, below we propose Weibull upward-downward variational encoder (WUDVE) to efficiently produce a document’s multilayer latent representation under DLDA. ",
+        "bbox": [
+            173,
+            407,
+            825,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Assuming the global parameters $\\phi _ { k } ^ { ( l ) }$ of DLDA shown in (1) are given and the task is to infer the local parameters $\\pmb { \\theta } _ { n } ^ { ( l + 1 ) }$ , the usual strategy of mean-field variational Bayes (Jordan et al., 1999) is to maximize the ELBO that can be expressed as ",
+        "bbox": [
+            176,
+            486,
+            823,
+            535
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4249baa4bcfbea9fc14ef39d69b59df50d5f8d0f8ac1ab62054a136bed1281ac.jpg",
+        "text": "$$\nL = \\sum _ { n = 1 } ^ { N } \\mathbb { E } \\left[ \\ln p \\left( x _ { n } \\mid \\Phi ^ { ( 1 ) } , \\pmb { \\theta } _ { n } ^ { ( 1 ) } \\right) \\right] - \\sum _ { n = 1 } ^ { N } \\sum _ { l = 1 } ^ { L } \\mathbb { E } \\left[ \\ln \\frac { q \\left( \\pmb { \\theta } _ { n } ^ { ( l ) } \\right) } { p \\left( \\pmb { \\theta } _ { n } ^ { ( l ) } \\mid \\Phi ^ { ( l + 1 ) } , \\pmb { \\theta } _ { n } ^ { ( l + 1 ) } \\right) } \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            540,
+            763,
+            594
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the expectations are taken with respect to (w.r.t.) a fully factorized distribution as ",
+        "bbox": [
+            173,
+            599,
+            750,
+            614
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e28359cbf15274c059d542835d880af991738830e047cdf8320a948bf3c70e4f.jpg",
+        "text": "$$\nq \\left( \\{ \\pmb { \\theta } _ { n } ^ { ( l ) } \\} _ { n = 1 , l = 1 } ^ { N , L } \\right) = \\prod _ { n = 1 } ^ { N } \\prod _ { l = 1 } ^ { L } q \\left( \\pmb { \\theta } _ { n } ^ { ( l ) } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            619,
+            629,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Instead of using a conventional latent Gaussian based VAE, in order to model sparse and nonnegative latent document representation, it might be more appropriate to use a gamma distribution based inference network defined as $q ( \\pmb { \\theta } _ { n } | \\bar { \\bf x } _ { n } ) = \\mathrm { G a m m a } \\bar { ( } f _ { \\bf W } ( \\pmb { x } _ { n } ) , g _ { \\bf W } ( \\pmb { x } _ { n } ) \\bar { ) }$ , where $f$ and $g$ are two related deep neural networks parameterized by W. However, it is hard to efficiently compute the gradient of the ELBO with respect to $\\mathbf { W }$ , due to the difficulty to reparameterize a gamma distributed random variable (Kingma & Welling, 2014; Ruiz et al., 2016; Knowles, 2015), motivating us to identify a surrogate distribution that can not only well approximate the gamma distribution, but also be easily reparameterized. Below we show the Weibull distribution is an ideal choice. ",
+        "bbox": [
+            173,
+            669,
+            826,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2.1 WEIBULL AND GAMMA DISTRIBUTIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            786,
+            504,
+            800
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A main reason that we choose the Weibull distribution to construct the inference network is that the Weibull and gamma distributions have similar PDFs: ",
+        "bbox": [
+            174,
+            809,
+            821,
+            838
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Weibull PD $\\mathsf { F } \\colon P ( x \\mid k , \\lambda ) = \\frac { k } { \\lambda ^ { k } } x ^ { k - 1 } e ^ { ( x / \\lambda ) ^ { k } } , \\mathrm { G a m m a } \\mathrm { P D F } \\colon P ( x \\mid \\alpha , \\beta ) = \\frac { \\beta ^ { \\alpha } } { \\Gamma ( \\alpha ) } x ^ { \\alpha - 1 } e ^ { - \\beta x } ,$ where $x \\in \\mathbb { R } _ { + }$ . Another reason is due to a simple reparameterization for $x \\sim { \\mathrm { W e i b u l l } } ( k , \\lambda )$ as ",
+        "bbox": [
+            173,
+            844,
+            803,
+            900
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4312366aae21b219da55a781b0fb44fb077f6489f25eb8500b7e6c6bd56d03ea.jpg",
+        "text": "$$\nx = \\lambda ( - \\ln ( 1 - \\epsilon ) ) ^ { 1 / k } , \\epsilon \\sim \\mathrm { U n i f o r m } ( 0 , 1 ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            906,
+            642,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Moreover, its KL-divergence from the gamma distribution has an analytic expression as ",
+        "bbox": [
+            173,
+            103,
+            746,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/99d8c1c73035663fa6229dac57b9f92fe5134ace9f68b11dec09644abeeb67ab.jpg",
+        "text": "$$\n\\small \\mathsf { \\displaystyle { K L } } ( \\mathbf { W e i b u l l } ( k , \\lambda ) | | \\mathbf { G a m m a } ( \\alpha , \\beta ) ) = \\alpha \\ln \\lambda - \\frac { \\gamma \\alpha } { k } - \\ln k - \\beta \\lambda \\Gamma \\Big ( 1 + \\frac { 1 } { k } \\Big ) + \\gamma + 1 + \\alpha \\ln \\beta - \\ln \\Gamma ( \\alpha ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            125,
+            826,
+            156
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Minimizing this KL divergence, one can identify the two parameters of a Weibull distribution to approximate a given gamma one. As shown in Fig. 1, the inferred Weibull distribution in general quite accurately approximates the target gamma one, as long as the gamma shape parameter is neither too close to zero nor too large. ",
+        "bbox": [
+            174,
+            161,
+            825,
+            218
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.2.2 UPWARD-DOWNWARD INFORMATION PROPAGATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            234,
+            586,
+            250
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the DLDA upward-downward Gibbs sampler sketched in Fig. 2c, the corresponding Gibbs sampling update equation for $\\pmb { \\theta } _ { n } ^ { ( l ) }$ can be expressed as ",
+        "bbox": [
+            174,
+            258,
+            823,
+            290
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5d36b0ac083c2e0ea395a2b743dfa0448171e4035848e079f45a20082f0d1181.jpg",
+        "text": "$$\n( \\pmb { \\theta } _ { n } ^ { ( l ) } | - ) \\sim \\mathrm { G a m m a } \\left( \\pmb { m } _ { n } ^ { ( l ) ( l + 1 ) } + \\pmb { \\Phi } ^ { ( l + 1 ) } \\pmb { \\theta } _ { n } ^ { ( l + 1 ) } , f ( p _ { n } ^ { ( l ) } , c _ { n } ^ { ( l + 1 ) } ) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            296,
+            715,
+            324
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $m _ { n } ^ { ( l ) ( l + 1 ) }$ and $p _ { n } ^ { ( l ) }$ are latent random variables constituted by information upward propagated to layer $l$ , as described in detail in Zhou et al. (2016) and hence omitted here for brevity. It is clear from (5) that the conditional posterior of $\\pmb { \\theta } _ { n } ^ { ( l ) }$ is related to both the information at the higher (prior) layer, and that upward propagated to the current layer via a series of data augmentation and marginalization steps described in Zhou et al. (2016). Inspired by this instructive upwarddownward information propagation in Gibbs sampling, as shown in Fig. 2a, we construct WUDVE, the inference network of our model, as $\\begin{array} { r } { q ( \\pmb { \\theta } _ { n } ^ { ( L ) } | \\hat { \\pmb { h } _ { n } ^ { ( L ) } } ) \\bar { \\prod } _ { l = 1 } ^ { L - 1 } q ( \\pmb { \\theta } _ { n } ^ { ( l ) } | \\bar { \\Phi ^ { ( l + 1 ) } } , \\pmb { h } _ { n } ^ { ( l ) } , \\pmb { \\theta } _ { n } ^ { ( l + 1 ) } ) } \\end{array}$ , where ",
+        "bbox": [
+            173,
+            332,
+            825,
+            440
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4e84b47abff64a30ae1dc7e39975afc47308d501921d44a3abfdad21fff240f4.jpg",
+        "text": "$$\n{ q ( \\theta _ { n } ^ { ( l ) } | \\Phi ^ { ( l + 1 ) } , h _ { n } ^ { ( l ) } , \\theta _ { n } ^ { ( l + 1 ) } ) } = \\mathrm { { W e i b u l l } } ( k _ { n } ^ { ( l ) } + \\Phi ^ { ( l + 1 ) } \\theta _ { n } ^ { ( l + 1 ) } , \\lambda _ { n } ^ { ( l ) } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            446,
+            718,
+            467
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The Weibull distribution is used to approximate the gamma distributed conditional posterior, and its parameters $\\pmb { k } _ { n } ^ { ( l ) } \\in \\mathbb { R } ^ { K _ { l } }$ and $\\pmb { \\lambda } _ { n } ^ { ( l ) } \\in \\mathbb { R } ^ { K _ { l } }$ are both deterministically transformed from the observation ${ \\mathbf { \\mathcal { x } } } _ { n }$ using the neural networks, as illustrated in Fig. 2a and specified as ",
+        "bbox": [
+            173,
+            473,
+            825,
+            518
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4ebbbf50f64b149e685f734ca92839542a9ce1062f633cf87e5afe97a6efc391.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { \\boldsymbol { k } } _ { n } ^ { ( l ) } = \\ln [ 1 + \\exp ( \\mathbf { \\boldsymbol { W } } _ { 1 } ^ { ( l ) } \\boldsymbol { h } _ { n } ^ { ( l ) } + \\boldsymbol { b } _ { 1 } ^ { ( l ) } ) ] , } \\\\ & { \\lambda _ { n } ^ { ( l ) } = \\ln [ 1 + \\exp ( \\mathbf { \\boldsymbol { W } } _ { 2 } ^ { ( l ) } \\boldsymbol { h } _ { n } ^ { ( l ) } + \\boldsymbol { b } _ { 2 } ^ { ( l ) } ) ] , } \\\\ & { \\boldsymbol { h } _ { n } ^ { ( l ) } = \\ln [ 1 + \\exp ( \\mathbf { \\boldsymbol { W } } _ { 3 } ^ { ( l ) } \\boldsymbol { h } _ { n } ^ { ( l - 1 ) } + \\boldsymbol { b } _ { 3 } ^ { ( l ) } ) ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            525,
+            630,
+            594
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { h } _ { n } ^ { ( 0 ) } = \\log ( 1 + \\pmb { x } _ { n } )$ , $\\mathbf { W } _ { 1 } ^ { ( l ) } \\in \\mathbb { R } ^ { K _ { l } \\times K _ { l } }$ , $\\mathbf { W } _ { 2 } ^ { ( l ) } \\in \\mathbb { R } ^ { K _ { l } \\times K _ { l } }$ , $\\mathbf { W } _ { 3 } ^ { ( l ) } \\in \\mathbb { R } ^ { K _ { l } \\times K _ { l - 1 } }$ , $b _ { 1 } ^ { ( l ) } \\in \\mathbb { R } ^ { K _ { l } }$ , $b _ { 2 } ^ { ( l ) } \\in \\mathbb { R } ^ { K _ { l } }$ , and $b _ { 3 } ^ { ( l ) } \\in \\mathbb { R } ^ { K _ { l } }$ . This upward-downward inference network is distinct from that of a usual VAE, where it is common that the inference network has a pure bottom-up structure and only interacts with the generative model via the ELBO (Kingma $\\&$ Welling, 2014; Ishaan et al., 2017). Note that WUDVE no longer follows mean-field variational Bayes to make a fully factorized assumption as in (4). ",
+        "bbox": [
+            173,
+            599,
+            825,
+            691
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Comparing Figs. 2c and 2a show that in each iteration, both Gibbs sampling and WUDVE have not only an upward information propagation (orange arrows), but also a downward one (blue arrows), but their underlying implementations are distinct from each other. Gibbs sampling in Fig. 2c does not have an inference network and needs the local variables $\\pmb { \\theta } _ { n } ^ { ( l ) }$ to help perform stochastic upward information propagation, whereas WUDVE in Fig. 2a uses its non-probabilistic part to perform deterministic upward information propagation, without relying on the local variables $\\pmb { \\theta } _ { n } ^ { ( l ) }$ . It is also interesting to notice that the upward-downward structure of WUDVE, motivated by the upwarddownward Gibbs sampler of DLDA, is closely related to that used in the ladder VAE of Sonderby et al. (2016). However, to combine the bottom-up and top-down information, ladder VAE relies on some heuristic restricted to Gaussian latent variables. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            842
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 HYBRID MCMC/VAE INFERENCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            852,
+            450,
+            867
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Section 2.1, we describe how to use TLASGR-MCMC of Cong et al. (2017a), a stochasticgradient MCMC algorithm for DLDA, to sample the global parameters $\\{ \\Phi ^ { ( l ) } \\} _ { 1 , L }$ ; whereas in Section 2.2.2, we describe how to use WUDVE, an autoencoding variational inference network, to approximate the conditional posterior of the local parameters $\\{ \\pmb { \\theta } _ { n } ^ { ( l ) } \\} _ { 1 , L }$ given $\\{ \\Phi ^ { ( l ) } \\} _ { 1 , L }$ and observation ${ \\mathbf { \\mathcal { x } } } _ { n }$ . Rather than merely finding a point estimate of the global parameters $\\{ \\Phi ^ { ( l ) } \\} _ { 1 , L }$ we describe in Algorithm 1 how to combine TLASGR-MCMC and the proposed WUDVE into a hybrid MCMC/VAE inference algorithm, which infers posterior samples for both the global parameters $\\{ \\Phi ^ { ( l ) } \\} _ { 1 , L }$ of the generative network, and the corresponding neural network parameters $\\boldsymbol \\Omega = \\{ \\mathbf { W } _ { 1 } ^ { ( l ) } , \\boldsymbol { b } _ { 1 } ^ { ( l ) } , \\mathbf { W } _ { 2 } ^ { ( l ) } , \\boldsymbol { b } _ { 2 } ^ { ( l ) } , \\mathbf { W } _ { 3 } ^ { ( l ) } , \\boldsymbol { b } _ { 3 } ^ { ( l ) } \\} _ { 1 , L }$ of the inference network. Being able to efficiently evaluating the gradient of the ELBO is important to the success of a variational inference algorithm (Hoffman et al., 2013; Paisley et al., 2012; Kingma & Welling, 2014; Mnih & Gregor, 2014; Ranganath et al., 2015; Ruiz et al., 2016; Rezende et al., 2014). An important step of Algorithm 1 is calculating the gradient of the ELBO in (3) with respect to the NN parameters $\\pmb { \\Omega }$ . Thanks to the choice of the Weibull distribution, the second term of the ELBO in (3) is analytic, and due to simple reparameterization of the Weibull distribution, the gradient of the first term of the ELBO with respect to $\\pmb { \\Omega }$ can be accurately evaluated, achieving satisfactory performance using even a single Monte Carlo sample, as shown in our experimental results. Thanks to the architecture of WUDVE, using the inference network, for a new mini-batch, we can directly find the conditional posteriors of $\\{ \\pmb { \\theta } _ { n } ^ { ( l ) } \\} _ { 1 , L }$ given $\\{ \\Phi ^ { ( l ) } \\} _ { 1 , L }$ and the stochastically updated $\\pmb { \\Omega }$ , with which we can sample the local parameters and then use TLASGR-MCMC to stochastically update the global parameters $\\{ \\Phi ^ { ( l ) } \\} _ { 1 , L }$ . ",
+        "bbox": [
+            174,
+            878,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/73966c449ae8047e0d29c648b34143d5b8d901c36d3dc1c2bcde883bc02e567e.jpg",
+        "image_caption": [
+            "Figure 2: (a-b): Inference (or encoder/recognition) and generative (or decoder) models for (a) WHAI and (b) AVITM; (c) the generative model and a sketch of the upward-downward Gibbs sampler of DLDA, where $\\mathbf { Z } ^ { l }$ are augmented latent counts that are upward sampled in each Gibbs sampling iteration. Circles are stochastic variables and squares are deterministic variables. The orange and blue arrows denote the upward and downward information propagation respectively, and the red ones denote the data generation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            116,
+            803,
+            270
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            382,
+            825,
+            637
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2.4 VARIATIONS OF WHAI ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            652,
+            375,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To clearly understand how each component contributes to the overall performance of WHAI, below we consider two different variations: GHAI and WAI. We first consider gamma hybrid autoencoding inference (GHAI). In WUDVE, the inference network for WHAI, we have a deterministic-upward and stochastic-downward structure, where the reparameterizable Weilbull distribution is used to connect adjacent stochastic layers. Although we choose to use the Weibull distribution for the reasons specified in Section 2.2.1, one may also choose some other distribution in the downward structure. For example, one may choose the gamma distribution and replace (6) with ",
+        "bbox": [
+            173,
+            678,
+            825,
+            776
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eb5a3fef21ad10197e66bb6b940c47e6ad0af5b941001c25dd25fd120e18c67c.jpg",
+        "text": "$$\nq ( \\theta _ { n } ^ { ( l ) } | \\Phi ^ { ( l + 1 ) } , \\mathbf { h } _ { n } ^ { ( l ) } , \\pmb { \\theta } _ { n } ^ { ( l + 1 ) } ) = \\mathrm { G a m m a } ( \\pmb { k } _ { n } ^ { ( l ) } + \\Phi ^ { ( l + 1 ) } \\pmb { \\theta } _ { n } ^ { ( l + 1 ) } , \\pmb { \\lambda } _ { n } ^ { ( l ) } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            781,
+            720,
+            801
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Even though the gamma distribution does not have a simple reparameteriation, one may use the RSVI of Naesseth et al. to define an approximate reparameterization procedure via rejection sampling. More specifically, following Naesseth et al., to generate a gamma random variable $z \\sim \\mathrm { G a m m a } ( \\alpha , \\beta )$ , one may first use the rejection sampler of Marsaglia & Tsang (2000) to generate $\\tilde { z } \\sim \\mathrm { G a m m a } ( \\alpha + B , 1 )$ , for which the proposal distribution is expressed as ",
+        "bbox": [
+            174,
+            808,
+            823,
+            878
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5f8518f7e5cfc424b12362a9b86b68e7e87a11e1ea0b9af0df23f7db6124dd11.jpg",
+        "text": "$$\n\\tilde { z } = \\left( \\alpha + B - \\frac { 1 } { 3 } \\right) \\left( 1 + \\frac { \\varepsilon } { \\sqrt { 9 ( \\alpha + B ) - 3 } } \\right) ^ { 3 } , \\mathrm { ~ } \\varepsilon \\sim \\mathcal { N } ( 0 , 1 ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            882,
+            705,
+            929
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Set mini-batch size $m$ and the number of layer $L$   \nInitialize encoder parameter $\\pmb { \\Omega }$ and model parameter $\\{ \\Phi ^ { ( l ) } \\} _ { 1 , L }$ .   \nfor $i t e r = 1 , 2 , \\cdots$ do Randomly select a mDraw random noise $m$ documents to form a subset m uniform distribution; $\\mathbf { X } = \\{ \\pmb { x } _ { i } \\} _ { 1 , m }$ ; $\\left\\{ \\varepsilon _ { i } ^ { l } \\right\\} _ { i = 1 , l = 1 } ^ { m , L }$ Calculate $\\nabla _ { \\Omega } L \\left( \\Omega , \\Phi ^ { \\{ l \\} } ; \\mathbf { X } , \\varepsilon _ { i } ^ { l } \\right)$ according to (3), and update $\\pmb { \\Omega }$ ; Sample ${ \\pmb \\theta } _ { i } ^ { \\{ l \\} }$ from (6) via $\\pmb { \\Omega }$ to update topics $\\{ \\Phi ^ { ( l ) } \\} _ { l = 1 } ^ { L }$ according to (2);   \nend for ",
+        "bbox": [
+            187,
+            122,
+            725,
+            260
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $B$ is a pre-set integer to make the acceptance probability be close to 1; one then lets $z = \\beta ^ { - 1 } \\tilde { z } \\prod _ { i = 1 } ^ { B } { u _ { i } } ^ { 1 / ( \\alpha + i - 1 ) }$ , where $u _ { i } \\sim \\mathrm { U n i f o r m } ( 0 , 1 )$ . The gradients of the ELBO, however, could still suffer from relatively high variance, as how likely a proposed $\\varepsilon$ will be accepted depends on the gamma distribution parameters, and $B$ extra uniform random variables $\\{ u _ { i } \\} _ { 1 , B }$ need to be introduced. ",
+        "bbox": [
+            174,
+            287,
+            825,
+            361
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the advantages of the proposed hybrid inference for WHAI, which infers posterior samples of the global parameters, including $\\{ \\Phi ^ { ( l ) } \\} _ { 1 , L }$ and $\\pmb { \\Omega }$ , using TLASGR-MCMC, we also consider Weibull autoencoding inference (WAI) that has the same inference network as WHAI but infers $\\{ \\Phi ^ { ( l ) } \\} _ { 1 , L }$ and $\\pmb { \\Omega }$ using stochastic gradient decent (SGD) (Kingma & Ba, 2015). Note that as argued in Mandt et al. (2017), SGD can also be used for approximate Bayesian inference. We will show in experiments that sampling the global parameters via TLASGR-MCMC provides improved performance in comparison to sampling them via SGD. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            470
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To understand the importance of the stochastic-downward structure used in the inference network, and further understand the differences between using the Weibull distribution with simple reparameterization and using the gamma distribution with RSVI, we also consider DLDA-GHAI-Independent and DLDA-WHAI-Independent that remove the stochastic-downward connections of DLDA-GHAI and DLDAas Weilbull spec and fically, they define , respectively, and $q ( \\pmb \\theta _ { n } ^ { ( l ) } \\mid \\Phi ^ { ( l + 1 ) } , \\pmb h _ { n } ^ { ( l ) } , \\pmb \\theta _ { n } ^ { ( l + 1 ) } )$ in (6) RSVI, (k(l)n , λ(l)n ) $\\mathrm { G a m m a } ( \\boldsymbol { k } _ { n } ^ { ( l ) } , \\bar { \\lambda } _ { n } ^ { ( l ) } )$ ",
+        "bbox": [
+            173,
+            477,
+            825,
+            580
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            602,
+            415,
+            617
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare the performance of different algorithms on 20Newsgroups (20News), Reuters Corpus Volume I (RCV1), and Wikipedia (Wiki). 20News consists of 18,845 documents with a vocabulary size of 2,000. RCV1 consists of 804,414 documents with a vocabulary size of 10,000. Wiki, with a vocabulary size of 7,702, consists of 10 million documents randomly downloaded from Wikipedia using the script provided for Hoffman et al. (2010). Similar to Cong et al. (2017a), we randomly select 100,000 documents for testing. To be consistent with previous settings (Gan et al., 2015; Henao et al., 2015; Cong et al., 2017a), no precautions are taken in the Wikipedia downloading script to prevent a testing document from being downloaded into a mini-batch for training. Our code is written in Theano (Theano Development Team, 2016). ",
+        "bbox": [
+            174,
+            633,
+            825,
+            760
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For comparison, we consider the deep Poisson factor analysis (DPFA) of Gan et al. (2015), DLDAGibbs of Zhou et al. (2016), DLDA-TLASGR of Cong et al. (2017a), and AVITM of Srivastava & Sutton (2017), using the code provided by the authors. Note that as shown in Cong et al. (2017a), DLDA-Gibbs and DLDA-TLASGR are state-of-the-art topic modeling algorithms that clearly outperform a large number of previously proposed ones, such as the replicated softmax of Salakhutdinov & Hinton (2009) and the nested Hierarchical Dirichlet process of Paisley et al. (2015). ",
+        "bbox": [
+            174,
+            766,
+            825,
+            849
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.1 PER-HELDOUT-WORD PERPLEXITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            868,
+            452,
+            882
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Per-heldout-word perplexity is a widely-used performance measure. Similar to Wallach et al. (2009), Paisley et al. (2011), and Zhou et al. (2012), for each corpus, we randomly select $7 0 \\%$ of the word ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/28c265bfe48a0a47751c4959fd5acf4c8d6e111fb1f48b99766c8f359e2717f8.jpg",
+        "table_caption": [
+            "Table 1: Comparison of per-heldout-word perplexity and testing time (average seconds per document) on three different datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">Size</td><td colspan=\"3\">Perplexity</td><td colspan=\"3\">Test Time</td></tr><tr><td>20News</td><td>RCV1</td><td>Wiki</td><td>20News</td><td>RCV1</td><td>Wiki</td></tr><tr><td>DLDA-Gibbs</td><td>128-64-32</td><td>571</td><td>938</td><td>966</td><td>10.46</td><td>23.38</td><td>23.69</td></tr><tr><td>DLDA-Gibbs</td><td>128-64</td><td>573</td><td>942</td><td>968</td><td>8.73</td><td>18.50</td><td>19.79</td></tr><tr><td>DLDA-Gibbs</td><td>128</td><td>584</td><td>951</td><td>981</td><td>4.69</td><td>12.57</td><td>13.31</td></tr><tr><td>DLDA-TLASGR</td><td>128-64-32</td><td>579</td><td>950</td><td>978</td><td>10.46</td><td>23.38</td><td>23.69</td></tr><tr><td>DLDA-TLASGR</td><td>128-64</td><td>581</td><td>955</td><td>979</td><td>8.73</td><td>18.50</td><td>19.79</td></tr><tr><td>DLDA-TLASGR</td><td>128</td><td>590</td><td>963</td><td>993</td><td>4.69</td><td>12.57</td><td>13.31</td></tr><tr><td>DPFA</td><td>128-64-32</td><td>637</td><td>1041</td><td>1056</td><td>20.12</td><td>34.21</td><td>35.41</td></tr><tr><td>AVITM</td><td>128</td><td>654</td><td>1062</td><td>1088</td><td>0.23</td><td>0.68</td><td>0.80</td></tr><tr><td>DLDA-GHAI-Independent</td><td>128-64-32</td><td>613</td><td>970</td><td>999</td><td>0.62</td><td>1.22</td><td>1.47</td></tr><tr><td>DLDA-GHAI-Independent</td><td>128-64</td><td>614</td><td>970</td><td>1000</td><td>0.41</td><td>0.94</td><td>1.01</td></tr><tr><td>DLDA-GHAI-Independent</td><td>128</td><td>615</td><td>972</td><td>1003</td><td>0.22</td><td>0.69</td><td>0.80</td></tr><tr><td>DLDA-GHAI</td><td>128-64-32</td><td>604</td><td>963</td><td>994</td><td>0.66</td><td>1.25</td><td>1.49</td></tr><tr><td>DLDA-GHAI</td><td>128-64</td><td>608</td><td>965</td><td>997</td><td>0.44</td><td>0.96</td><td>1.05</td></tr><tr><td>DLDA-GHAI</td><td>128</td><td>615</td><td>972</td><td>1003</td><td>0.22</td><td>0.69</td><td>0.80</td></tr><tr><td>DLDA-WHAI-Independent</td><td>128-64-32</td><td>588</td><td>964</td><td>990</td><td>0.58</td><td>1.15</td><td>1.38</td></tr><tr><td>DLDA-WHAI-Independent</td><td>128-64</td><td>589</td><td>965</td><td>992</td><td>0.38</td><td>0.87</td><td>0.97</td></tr><tr><td>DLDA-WHAI-Independent</td><td>128</td><td>592</td><td>966</td><td>996</td><td>0.20</td><td>0.66</td><td>0.78</td></tr><tr><td>DLDA-WAI</td><td>128-64-32</td><td>581</td><td>954</td><td>984</td><td>0.63</td><td>1.20</td><td>1.43</td></tr><tr><td>DLDA-WAI</td><td>128-64</td><td>583</td><td>958</td><td>986</td><td>0.42</td><td>0.91</td><td>1.02</td></tr><tr><td>DLDA-WAI</td><td>128</td><td>593</td><td>967</td><td>999</td><td>0.20</td><td>0.66</td><td>0.78</td></tr><tr><td>DLDA-WHAI</td><td>128-64-32</td><td>581</td><td>953</td><td>980</td><td>0.63</td><td>1.20</td><td>1.43</td></tr><tr><td>DLDA-WHAI</td><td>128-64</td><td>582</td><td>957</td><td>982</td><td>0.42</td><td>0.91</td><td>1.02</td></tr><tr><td>DLDA-WHAI</td><td>128</td><td>591</td><td>965</td><td>996</td><td>0.20</td><td>0.66</td><td>0.78</td></tr></table>",
+        "bbox": [
+            173,
+            142,
+            834,
+            497
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "tokens from each document to form a training matrix $\\mathbf { T }$ , holding out the remaining $3 0 \\%$ to form a testing matrix $\\mathbf { Y }$ . We use $\\mathbf { T }$ to train the model and calculate the per-heldout-word perplexity as ",
+        "bbox": [
+            174,
+            520,
+            825,
+            549
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/03c5eee56470b0d46670c10e340448f1e8c8eb63928092e3f3e56c01b8af49f8.jpg",
+        "text": "$$\n\\exp \\left\\{ - \\frac { 1 } { y . . } \\sum _ { v = 1 } ^ { V } \\sum _ { n = 1 } ^ { N } y _ { v n } \\ln \\frac { \\sum _ { s = 1 } ^ { S } \\sum _ { k = 1 } ^ { K ^ { 1 } } \\phi _ { v k } ^ { ( 1 ) s } \\theta _ { k n } ^ { ( 1 ) s } } { \\sum _ { s = 1 } ^ { S } \\sum _ { v = 1 } ^ { V } \\sum _ { k = 1 } ^ { K ^ { 1 } } \\phi _ { v k } ^ { ( 1 ) s } \\theta _ { k n } ^ { ( 1 ) s } } \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            553,
+            696,
+            598
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $S$ is the total number of collected samples and $\\begin{array} { r } { y _ { \\cdot \\cdot } = \\sum _ { v = 1 } ^ { V } \\sum _ { n = 1 } ^ { N ^ { ' } } y _ { v n } } \\end{array}$ PVv=1 PNn=1 yvn. For the proposed model, we set the mini-batch size as 200, and use as burn-in 2000 mini-batches for both 20News and RCV1 and 3500 for wiki. We collect 3000 samples after burn-in to calculate perplexity. The hyperparameters of WHAI are set as: $\\eta ^ { ( l ) } = 1 / K _ { l }$ , $\\mathbf r = \\mathbf 1$ , and $c _ { n } ^ { ( l ) } = 1$ . ",
+        "bbox": [
+            174,
+            604,
+            825,
+            667
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1 lists for various algorithms both the perplexity and the average run time per testing document given a single sample (estimate) of the global parameters. Clearly, given the same generative network structure, DLDA-Gibbs performs the best in terms of predicting heldout word tokens, which is not surprising as this batch algorithm can sample from the true posteriors given enough Gibbs sampling iterations. DLDA-TLASGR is a mini-batch algorithm that is much more scalable in training than DLDA-Gibbs, at the expense of slighted degraded performance in out-of-sample prediction. Both DLDA-WAI, using SGD to infer the global parameters, and DLDA-WHAI, using a stochasticgradient MCMC to infer the global parameters, slightly underperform DLDA-TLASGR; all minibatch based algorithms are scalable to a big training corpus, but due to the use of the WUDVE inference network, both DLDA-GHAI and DLDA-WHAI, as well as their variations, are considerably fast in processing a testing document. In terms of perplexity, all algorithms with DLDA as the generative model clearly outperform both DPFA of Gan et al. (2015) and AVITM of Srivastava & Sutton (2017), while in terms of the computational cost for testing, all algorithms with an inference network, such as AVITM, DLDA-GHAI, and DLDA-WHAI, clearly outperform these relying on an interactive procedure for out-of-sample prediction, including DPFA, DLDA-Gibbs, and DLDA-TLASGR. It is also clear that except for DLDA-GHAI-Independent and DLDA-WHAI-Independent that have no stochastic-downward components in their inference, all the other algorithms with DLDA as the generative model have a clear trend of improvement as the generative network becomes deeper, indicating the importance of having stochastic-downward information propagation during posterior inference; and DLDA-WHAI with a single hidden layer already clearly outperforms AVITM, indicating that using the Weibull distribution is more appropriate than using the logistic-normal distribution to model the document latent representation. Furthermore, thanks to the use of the stochastic gradient based TLASGR-MCMC rather than a simple SGD procedure, DLDA-WHAI consistently outperforms DLDA-WAI. Last but not least, while DLDA-GHAI that relies on RSVI to approximately reparameterize the gamma distributions clearly outperforms AVITM and DPFA, it clearly underperforms DLDA-WHAI that has simple reparameterizations for its Weibull distributions. ",
+        "bbox": [
+            173,
+            674,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/955981f5a9a6a19435e98659db58a8cf4961d3af1af64054e83e10fbfe2cac1a.jpg",
+        "image_caption": [
+            "Figure 3: Plot of per-heldout-word perplexity as a function of time for (a) 20News, (b) RCV1, and (c) Wiki. Except for AVITM that has a single hidden layer with 128 topics, all the other algorithms have the same network size of 128-64-32 for their deep generative models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            116,
+            816,
+            266
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            347,
+            825,
+            458
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Below we examine how various inference algorithms progress over time during training, evaluated with per-holdout-word perplexity. As clearly shown in Fig. 3, DLDA-WHAI outperforms DPFA and AVITM in providing lower perplexity as time progresses, which is not surprising as the DLDA multilayer generative model is good at document representation, while AVITM is only \"deep\" in the deterministic part of its inference network and DPFA is restricted to model binary topic usage patterns via its deep network. When DLDA is used as the generative model, in comparison to Gibbs sampling and TLASGR-MCMC on two large corpora, RCV1 and Wiki, the mini-batch based WHAI converges slightly slower than TLASGR-MCMC but much faster than Gibbs sampling; WHAI consistently outperforms WAI, which demonstrates the advantage of the hybrid MCMC/VAE inference; in addition, the RSVI based DLDA-GHAI clearly converges more slowly in time than DLDAWHAI. Note that for all three datasets, the perplexity of TLASGR decreases at a fast rate, followed by closely by WHAI, while that of Gibbs sampling decreases slowly, especially for RCV1 and Wiki, as shown in Figs. 3(b-c). This is expected as both RCV1 and Wiki are much larger corpora, for which a mini-batch based inference algorithm can already make significant progress in inferring the global model parameters, before a batch-learning Gibbs sampler finishes a single iteration that needs to go through all documents. We also notice that although AVITM is fast for testing via the use of a VAE, its representation power is limited due to not only the use of a shallow topic model, but also the use of a latent Gaussian based inference network that is not naturally suited to model document latent representation. ",
+        "bbox": [
+            173,
+            464,
+            825,
+            729
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.2 TOPIC HIERARCHY AND MANIFOLD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            746,
+            459,
+            760
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In addition to quantitative evaluations, we have also visually inspected the inferred topics at different layers and the inferred connection weights between the topics of adjacent layers. Distinct from many existing deep learning models that build nonlinearity via “black-box” neural networks, we can easily visualize the whole stochastic network, whose hidden units of layer $l - 1$ and those of layer $l$ are connected by $\\phi _ { k ^ { \\prime } k } ^ { ( l ) }$ that are sparse. In particular, we can understand the meaning of each hidden unit by projecting it back to the original data space via $\\left[ \\prod _ { t = 1 } ^ { l - 1 } \\Phi ^ { ( t ) } \\right] \\phi _ { k } ^ { ( l ) }$ . We show in Fig. 4 a subnetwork, originating from units 16, 19, and 24 of the top hidden layer, taken from the generative network of size 128-64-32 inferred on Wiki. The semantic meaning of each topic and the connections between different topics are highly interpretable. We provide several additional topic hierarchies for Wiki in the Appendix. ",
+        "bbox": [
+            173,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/bccad350bd63987708ece31b4b2b19938e4233c4a86afecc64c2b7ac349fb130.jpg",
+        "image_caption": [
+            "Figure 4: An example of hierarchical topics learned from Wiki by a three-hidden-layer WHAI of size 128-64-32. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            101,
+            816,
+            330
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/7e626e2fe3ebf5b77184c614514f6d59128963d957022bd06aefeaeb42ddca7a.jpg",
+        "image_caption": [
+            "Figure 5: Learned topics on MNIST digits with a three-hidden-layer WHAI of size 128-64- 32. Shown in (a)-(c) are example topics for layers 1, 2 and 3, respectively, learned with a deterministic-upward-stochastic-downward encoder, and shown in (d)-(f) are the ones learned with a deterministic-upward encoder. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            299,
+            407,
+            699,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To further illustrate the effectiveness of our multilayer representation in our model, we apply a threehidden-layer WHAI to MNIST digits and present the learned dictionary atoms. We use the Poisson likelihood directly to model the MNIST digit pixel values that are nonnegative integers ranging from 0 to 255. As shown in Figs. 5a-5c, it is clear that the factors at layers one to three represent localized points, strokes, and digit components, respectively, that cover increasingly larger spatial regions. This type of hierarchical visual representation is difficult to achieve with other types of deep neural networks (Srivastava et al., 2013; Kingma & Welling, 2014; Rezende et al., 2014; Sonderby et al., 2016). ",
+        "bbox": [
+            173,
+            719,
+            825,
+            830
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "WUDVE, the inference network of WHAI, has a deterministic-upward-stochastic-downward structure, in contrast to a conventional VAE that often has a pure deterministic bottom-up structure. Here, we further visualize the importance of the stochastic-downward part of WUDVE through a simple experiment. We remove the stochastic-downward part of WUDVE shown in (6) and define the inference network as $q ( \\pmb { \\theta } _ { n } ^ { ( l ) } | \\pmb { h } _ { n } ^ { ( l ) } ) = \\mathrm { W e i b u l l } ( \\pmb { k } _ { n } ^ { ( l ) } , \\mathbf { \\bar { \\lambda } } _ { n } ^ { ( l ) } )$ , in other words, we ignore the top-down information. As shown in Figs. 5d-5f, although some latent structures are learned, the hierarchical relationships between adjacent layers almost all disappear, indicating the importance of having a stochastic-downward structure together with a deterministic-upward one in the inference network. ",
+        "bbox": [
+            174,
+            837,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/41e8d3206488bfab34498ed7225ccad0d2037e4c9a389bf5f131769ee8de907b.jpg",
+        "image_caption": [
+            "Figure 6: Latent space interpolations on the MNIST test set. Left and right columns correspond to the images generated frominterpolated linearly from $z _ { 1 } ^ { ( 3 ) }$ 3) and z(3)2 , a nd the others are generated from the latent representations $z _ { 1 } ^ { ( 3 ) }$ to z 2 $z _ { 2 } ^ { ( 3 ) }$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            112,
+            772,
+            246
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            334,
+            823,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "As a sanity check for latent representation and overfitting, we shown in Fig. 6 the latent space interpolations between the test set examples on MNIST dataset, and provide related results in the Appendix for the 20News corpus. With the 3-layer model learned before, following Dumoulin et al. (2016), we sample pairs of test set examples x1 and x2 and project them into z(3)1 a nd z 2 . We then linearly interpolate between $z _ { 1 } ^ { ( 3 ) }$ and $z _ { 2 } ^ { ( 3 ) }$ , and pass the intermediary points through the generative model to generate the input-space interpolations. In Fig. 6, the left and right column are the digits generated from $z _ { 1 } ^ { ( 3 ) }$ and $\\bar { z } _ { 2 } ^ { ( 3 ) }$ , while the middle ones are generated from the interpolation latent space. We observe a smooth transitions between pairs of example, and intermediary images remain interpretable. In other words, the latent space the model learned is on a manifold, indicating that WHAI has learned a generalizable latent feature representation rather than concentrating its probability mass exclusively around training examples. ",
+        "bbox": [
+            173,
+            371,
+            825,
+            534
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "4 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            547,
+            318,
+            563
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "To infer a hierarchical latent representations of a big corpus, we develop Weibull hybrid autoencoding inference (WHAI) for deep latent Dirichlet allocation (DLDA), a deep probabilistic topic model that factorizes the observed high-dimensional count vectors under the Poisson likelihood and models the latent representation under the gamma likelihood at multiple different layers. WHAI integrates topic-layer-adaptive stochastic gradient Riemannian (TLASGR) MCMC to update the global parameters given the posterior sample of a mini-batch’s local parameters, and a Weibull distribution based upward-downward variational autoencoder to infer the conditional posterior of the local parameters given the stochastically updated global parameters. The use of the Weibull distribution, which resembles the gamma distribution and has a simple reparameterization, makes one part of the evidence lower bound (ELBO) analytic, and makes it efficient to compute the gradient of the non-analytic part of the ELBO with respect to the parameters of the inference network. Moving beyond deep models and inference procedures based on Gaussian latent variables, WHAI provides posterior samples for both the global parameters of the generative model and these of the inference network, yields highly interpretable multilayer latent document representation, is scalable to a big training corpus due to the use of a stochastic-gradient MCMC, and is fast in out-of-sample prediction due to the use of an inference network. Compelling experimental results on big text corpora demonstrate the advantages of WHAI in both quantitative and qualitative analysis. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            815
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5 ACKNOWLEDGE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            835,
+            339,
+            852
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work is partially supported by the Fund for Foreign Scholars in University Research and Teaching Programs (the 111 Project) (No. B18039), the Thousand Young Talent Program of China, NSFC (61771361) , NSFC for Distinguished Young Scholars (61525105), and Innovation Fund of International Exchange Program for Graduate Student of Xidian University. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David M Blei, Andrew $\\mathrm { ~ Y ~ N ~ g ~ }$ , and Michael I Jordan. Latent Dirichlet allocation. Journal of Machine Learning Research, 3(Jan):993–1022, 2003. ",
+        "bbox": [
+            176,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yulai Cong, Bo Chen, Hongwei Liu, and Mingyuan Zhou. Deep latent Dirichlet allocation with topic-layer-adaptive stochastic gradient riemannian mcmc. In ICML, 2017a. ",
+        "bbox": [
+            176,
+            162,
+            821,
+            193
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yulai Cong, Bo Chen, and Mingyuan Zhou. Fast simulation of hyperplane-truncated multivariate normal distributions. Bayesian Analysis, 2017b. ",
+        "bbox": [
+            173,
+            200,
+            823,
+            231
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhenwen Dai, Andreas C Damianou, Javier Gonzalez, and Neil D Lawrence. Variational autoencoded deep Gaussian processes. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            238,
+            825,
+            268
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Alex Lamb, Martin Arjovsky, Olivier Mastropietro, and Aaron Courville. Adversarially learned inference. arXiv:1606.00704, 2016. ",
+        "bbox": [
+            173,
+            276,
+            823,
+            306
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhe Gan, Changyou Chen, Ricardo Henao, David Carlson, and Lawrence Carin. Scalable deep Poisson factor analysis for topic modeling. In ICML, pp. 1823–1832, 2015. ",
+        "bbox": [
+            171,
+            314,
+            823,
+            344
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ricardo Henao, Zhe Gan, James Lu, and Lawrence Carin. Deep Poisson factor modeling. In NIPS, pp. 2800–2808, 2015. ",
+        "bbox": [
+            173,
+            352,
+            821,
+            381
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "M. Hoffman, D. Blei, and F. Bach. Online learning for latent Dirichlet allocation. In NIPS, 2010. ",
+        "bbox": [
+            174,
+            388,
+            810,
+            406
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew D Hoffman, David M Blei, Chong Wang, and John William Paisley. Stochastic variational inference. Journal of Machine Learning Research, 14(1):1303–1347, 2013. ",
+        "bbox": [
+            171,
+            414,
+            821,
+            444
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gulrajani Ishaan, Kumar Kundan, Ahmed Faruk, Taiga Adrien, Ali, Visin Francesco, Vazquez David, and Courville Aaron. Pixelvae: A latent variable model for natural images. In ICLR, 2017. ",
+        "bbox": [
+            178,
+            452,
+            823,
+            494
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Michael I Jordan, Zoubin Ghahramani, Tommi S Jaakkola, and Lawrence K Saul. An introduction to variational methods for graphical models. Machine learning, 37(2):183–233, 1999. ",
+        "bbox": [
+            173,
+            502,
+            823,
+            534
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Lei Ba. Adam: A method for stochastic optimization. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            540,
+            823,
+            571
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Stochastic gradient VB and the variational auto-encoder. In ICLR, 2014. ",
+        "bbox": [
+            173,
+            579,
+            825,
+            608
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David A Knowles. Stochastic gradient variational Bayes for gamma approximating distributions. arXiv preprint arXiv:1509.01631, 2015. ",
+        "bbox": [
+            171,
+            616,
+            823,
+            646
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Y. Ma, T. Chen, and E. Fox. A complete recipe for stochastic gradient MCMC. In NIPS, pp. 2899–2907, 2015. ",
+        "bbox": [
+            173,
+            654,
+            821,
+            684
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stephan Mandt, Matthew D Hoffman, and David M Blei. Stochastic gradient descent as approximate Bayesian inference. arXiv:1704.04289, to appear in Journal of Machine Learning Research, 2017. ",
+        "bbox": [
+            174,
+            691,
+            823,
+            734
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "George Marsaglia and Wai Wan Tsang. A simple method for generating gamma variables. ACM Transactions on Mathematical Software (TOMS), 26(3):363–372, 2000. ",
+        "bbox": [
+            171,
+            743,
+            823,
+            773
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andriy Mnih and Karol Gregor. Neural variational inference and learning in belief networks. In ICML, pp. 1791–1799, 2014. ",
+        "bbox": [
+            174,
+            781,
+            821,
+            810
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Naesseth, Francisco Ruiz, Scott Linderman, and David Blei. Reparameterization gradients through acceptance-rejection sampling algorithms. In AISTATS. ",
+        "bbox": [
+            173,
+            819,
+            821,
+            849
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "J. Paisley, C. Wang, and D. Blei. The discrete infinite logistic normal distribution for mixedmembership modeling. In AISTATS, 2011. ",
+        "bbox": [
+            174,
+            857,
+            820,
+            887
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "J. Paisley, C. Wang, D. M. Blei, and M. I. Jordan. Nested hierarchical Dirichlet processes. IEEE Trans. Pattern Anal. Mach. Intell., 2015. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Paisley, David M Blei, and Michael I Jordan. Variational Bayesian inference with stochastic search. In Proceedings of the 29th International Coference on International Conference on Machine Learning, pp. 1363–1370. Omnipress, 2012. ",
+        "bbox": [
+            178,
+            103,
+            821,
+            147
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sam Patterson and Yee Whye Teh. Stochastic gradient Riemannian Langevin dynamics on the probability simplex. In NIPS, pp. 3102–3110, 2013. ",
+        "bbox": [
+            173,
+            155,
+            821,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Rajesh Ranganath, Linpeng Tang, Laurent Charlin, and David Blei. Deep exponential families. In AISTATS, pp. 762–771, 2015. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Danilo J Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proceedings of the 31st International Conference on Machine Learning (ICML-14), pp. 1278–1286, 2014. ",
+        "bbox": [
+            174,
+            231,
+            823,
+            273
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Francisco JR Ruiz, Michalis K Titsias, and David M Blei. The generalized reparameterization gradient. In NIPS, pp. 460–468, 2016. ",
+        "bbox": [
+            173,
+            281,
+            823,
+            311
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ruslan Salakhutdinov and Geoffrey E Hinton. Replicated softmax: an undirected topic model. In NIPS, pp. 1607–1614, 2009. ",
+        "bbox": [
+            174,
+            319,
+            823,
+            349
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Casper Kaae Sonderby, Tapani Raiko, Lars Maaloe, Soren Kaae Sonderby, and Ole Winther. Ladder variational autoencoders. In NIPS, pp. 3738–3746, 2016. ",
+        "bbox": [
+            173,
+            357,
+            823,
+            387
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Akash Srivastava and Charles Sutton. Autoencoding variational inference for topic models. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            395,
+            823,
+            424
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Ruslan Salakhutdinov, and Geoffrey E Hinton. Modeling documents with deep Boltzmann machines. In Uncertainty in Artificial Intelligence, 2013. ",
+        "bbox": [
+            176,
+            433,
+            823,
+            462
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.02688, May 2016. ",
+        "bbox": [
+            174,
+            469,
+            821,
+            500
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "H. M. Wallach, I. Murray, R. Salakhutdinov, and D. Mimno. Evaluation methods for topic models. In ICML, 2009. ",
+        "bbox": [
+            173,
+            507,
+            821,
+            537
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "M. Welling and Y. W. Teh. Bayesian learning via stochastic gradient Langevin dynamics. In ICML, pp. 681–688, 2011. ",
+        "bbox": [
+            171,
+            546,
+            823,
+            575
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Mingyuan Zhou, Lauren Hannah, David B Dunson, and Lawrence Carin. Beta-negative binomial process and Poisson factor analysis. In AISTATS, pp. 1462–1471, 2012. ",
+        "bbox": [
+            173,
+            583,
+            823,
+            613
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Mingyuan Zhou, Yulai Cong, and Bo Chen. The Poisson gamma belief network. In NIPS, pp. 3043–3051, 2015. ",
+        "bbox": [
+            171,
+            621,
+            821,
+            651
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Mingyuan Zhou, Yulai Cong, and Bo Chen. Augmentable gamma belief networks. J. Mach. Learn. Res., 17(163):1–44, 2016. ",
+        "bbox": [
+            173,
+            659,
+            821,
+            689
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A HIERARCHICAL TOPICS LEARNED FROM WIKI ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            593,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/31fb4889ef8e222ae9e067ec6b3e84136e83c7905c10c2074b4db9ed02c250cf.jpg",
+        "image_caption": [
+            "Figure 7: An example of hierarchical topics learned from Wiki by a three-hidden-layer WHAI of size 128-64-32. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            136,
+            800,
+            373
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/a0104ecb3b2534ea333b739a8e0e251361a9f984a87b4d7eb2584b82ec28eb83.jpg",
+        "image_caption": [
+            "Figure 8: An example of hierarchical topics learned from Wiki by a four-hidden-layer WHAI of size 256-128-64-32. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            433,
+            803,
+            709
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B MANIFOLD ON DOCUMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            441,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "From a sci.medicine document to an eci.space one ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            133,
+            522,
+            148
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1. com, writes, article, edu, medical, pitt, pain, blood, disease, doctor, medicine, treatment, patients, health, ibm   \n2. com, writes, article, edu, space, medical, pitt, pain, blood, disease, doctor, data, treatment, patients, health   \n3. space, com, writes, article, edu, data, medical, launch, earth, states, blood, moon, disease, satellite, medicine,   \n4. space, data, com, writes, article, edu, launch, earth, states, moon, satellite, shuttle, nasa, price, lunar   \n5. space, data, launch, earth, states, moon, satellite, case, com, shuttle, price, nasa, price, lunar, writes,   \n6. space, data, launch, earth, states, moon, orbit, satellite, case, shuttle, price, nasa, system, lunar, spacecraft ",
+        "bbox": [
+            169,
+            155,
+            826,
+            359
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "From a alt.atheism document to a soc.religion.christian one ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            366,
+            588,
+            381
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1. god, just, want, moral, believe, religion, atheists, atheism, christian, make, atheist, good, say, bible, faith   \n2. god, just, want, believe, jesus, christian, atheists, bible, atheism faith, say, make, religious, christians, atheist   \n3. god, jesus, just, faith, believe, christian, bible, want, church, say, religion, moral, lord, world, writes   \n4. god, jesus, faith, just, bible, church, christ, believe, say, writes, lord, religion, world, want, sin 5. god, jesus, faith, church, christ, bible, christian, say, write, lord, believe, truth, world, human, holy   \n6. god, jesus, faith, church, christ, bible, writes, say, christian, lord, sin, human, father, spirit, truth ",
+        "bbox": [
+            171,
+            388,
+            826,
+            565
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "From a com.graphics document to a comp.sys.ibm.pc.hardware one ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            571,
+            648,
+            587
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1. image, color, windows, files, image, thanks, jpeg, gif, card, bit, window, win, help, colors, format 2. image, windows, color, files, card, images, jpeg, thanks, gif, bit, window, win, colors, monitor, program   \n3. windows, image, color, card, files, gov, writes, nasa, article, images, program, jpeg, vidio, display, monitor   \n4. windows, gov, writes, nasa, article, card, going, program, image, color, memory, files, software, know, screen   \n5. gov, windows, writes, nasa, article, going, dos, card, memory, know, display, says, screen, work, ram   \n6. gov, writes, nasa, windows, article, going, dos, program, card, memory, software, says, ram, work, running ",
+        "bbox": [
+            171,
+            593,
+            826,
+            785
+        ],
+        "page_idx": 14
+    }
+]

parse/train/rylV-2C9KQ/rylV-2C9KQ.md

@@ -0,0 +1,313 @@
+# DEEP DECODER: CONCISE IMAGE REPRESENTATIONS FROM UNTRAINED NON-CONVOLUTIONAL NETWORKS
+
+Reinhard Heckel   
+Department of Electrical and Computer Engineering   
+Rice University   
+rh43@rice.edu   
+Paul Hand   
+Department of Mathematics and   
+College of Computer and Information Science   
+Northeastern University   
+p.hand@northeastern.edu
+
+# ABSTRACT
+
+Deep neural networks, in particular convolutional neural networks, have become highly effective tools for compressing images and solving inverse problems including denoising, inpainting, and reconstruction from few and noisy measurements. This success can be attributed in part to their ability to represent and generate natural images well. Contrary to classical tools such as wavelets, imagegenerating deep neural networks have a large number of parameters—typically a multiple of their output dimension—and need to be trained on large datasets. In this paper, we propose an untrained simple image model, called the deep decoder, which is a deep neural network that can generate natural images from very few weight parameters. The deep decoder has a simple architecture with no convolutions and fewer weight parameters than the output dimensionality. This underparameterization enables the deep decoder to compress images into a concise set of network weights, which we show is on par with wavelet-based thresholding. Further, underparameterization provides a barrier to overfitting, allowing the deep decoder to have state-of-the-art performance for denoising. The deep decoder is simple in the sense that each layer has an identical structure that consists of only one upsampling unit, pixel-wise linear combination of channels, ReLU activation, and channelwise normalization. This simplicity makes the network amenable to theoretical analysis, and it sheds light on the aspects of neural networks that enable them to form effective signal representations.
+
+# 1 INTRODUCTION
+
+Data models are central for signal and image processing and play a key role in compression and inverse problems such as denoising, super-resolution, and compressive sensing. These data models impose structural assumptions on the signal or image, which are traditionally based on expert knowledge. For example, imposing the assumption that an image can be represented with few non-zero wavelet coefficients enables modern (lossy) image compression (Antonini et al., 1992) and efficient denoising (Donoho, 1995).
+
+In recent years, it has been demonstrated that for a wide range of imaging problems, from compression to denoising, deep neural networks trained on large datasets can often outperform methods based on traditional image models (Toderici et al., 2016; Agustsson et al., 2017; Theis et al., 2017; Burger et al., 2012; Zhang et al., 2017). This success can largely be attributed to the ability of deep networks to represent realistic images when trained on large datasets. Examples include learned representations via autoencoders (Hinton & Salakhutdinov, 2006) and generative adversarial models (Goodfellow et al., 2014). Almost exclusively, three common features of the recent success stories of using deep neural network for imaging related tasks are i) that the corresponding networks are over-parameterized (i.e., they have much more parameters than the dimension of the image that they represent or generate), ii) that the networks have a convolutional structure, and perhaps most importantly, iii) that the networks are trained on large datasets.
+
+An important exception that breaks with the latter feature is a recent work by Ulyanov et al. Ulyanov et al. (2018), which provides an algorithm, called the deep image prior (DIP), based on deep neural networks, that can solve inverse problems well without any training. Specifically, Ulyanov et al. demonstrated that fitting the weights of an over-parameterized deep convolutional network to a single image, together with strong regularization by early stopping of the optimization, performs competitively on a variety of image restoration problems. This result is surprising because it does not involve a training dataset, which means that the notion of what makes an image ‘natural’ is contained in a combination of the network structure and the regularization. However, without regularization the proposed network has sufficient capacity to overfit to noise, preventing meaningful image denoising.
+
+These prior works demonstrating the effectiveness of deep neural networks for image generation beg the question whether there may be a deep neural network model of natural images that is underparameterized and whose architecture alone, without algorithmic assistance, forms an efficient model for natural images.
+
+In this paper, we propose a simple image model in the form of a deep neural network that can represent natural images well while using very few parameters. This model thus enables image compression, denoising, and solving a variety of inverse problems with close to or state of the art performance. We call the network the deep decoder, due to its resemblance to the decoder part of an autoencoder. The network does not require training, and contrary to previous approaches, the network itself incorporates all assumptions on the data, is under-parameterized, does not involve convolutions, and has a simplicity that makes it amenable to theoretical analysis. The key contributions of this paper are as follows:
+
+• The network is under-parameterized. Thus, the network maps a lower-dimensional space to a higher-dimensional space, similar to classical image representations such as sparse wavelet representations. This feature enables image compression by storing the coefficients of the network after its weights are optimized to fit a single image. In Section 2, we demonstrate that the compression is on-par with wavelet thresholding (Antonini et al., 1992), a strong baseline that underlies JPEG-2000. An additional benefit of underparameterization is that it provides a barrier to overfitting, which enables regularization of inverse problems.   
+• The network itself acts as a natural data model. Not only does the network require no training (just as the DIP Ulyanov et al. (2018)); it also does not critically rely on regularization, for example by early stopping (in contrast to the DIP). The property of not involving learning has at least two benefits: The same network and code is usable for a number of applications, and the method is not sensitive to a potential misfit of training and test data. The network does not use convolutions. Instead, the network does have pixelwise linear combinations of channels, and, just like in a convolutional neural network, the weights are shared among spatial positions. Nonetheless, these are not convolutions because they provide no spatial coupling between pixels, despite how pixelwise linear combinations are sometimes called ‘1x1 convolutions.’ In contrast, the majority of the networks for image compression, restoration, and recovery have convolutional layers with filters of nontrivial spatial extent Toderici et al. (2016); Agustsson et al. (2017); Theis et al. (2017); Burger et al. (2012); Zhang et al. (2017). This work shows that relationships characteristic of nearby pixels of natural images can be imposed directly by upsampling layers. The network only consists of a simple combination of few building blocks, which makes it amenable to analysis and theory. For example, we prove that the deep decoder can only fit a small proportion of noise, which, combined with the empirical observation that it can represent natural images well, explains its denoising performance.
+
+The remainder of the paper is organized as follows. In Section 2, we first demonstrate that the deep decoder enables concise image representations. We formally introduce the deep decoder in Section 3. In Section 4, we show the performance of the deep decoder on a number of inverse problems such as denoising. In Section 5 we discuss related work, and finally, in Section 6 we provide theory and explanations on what makes the deep decoder work.
+
+Intuitively, a model describes a class of signals well if it is able to represent or approximate a member of the class with few parameters. In this section, we demonstrate that the deep decoder, an untrained, non-convolutional neural network, defined in the next section, enables concise representation of an image—on par with state of the art wavelet thresholding.
+
+The deep decoder is a deep image model $G \colon \mathbb { R } ^ { N } \to \mathbb { R } ^ { n }$ , where $N$ is the number of parameters of the model, and $n$ is the output dimension, which is (much) larger than the number of parameters $( n \gg N )$ . The parameters of the model, which we denote by $\mathbf { C }$ , are the weights of the network, and not the input of the network, which we will keep fixed. To demonstrate that the deep decoder enables concise image representations, we choose the number of parameters of the deep decoder, $N$ , such that it is a small fraction of the output dimension of the deep decoder, i.e., the dimension of the images1.
+
+We draw 100 images from the ImageNet validation set uniformly at random and crop the center to obtain a 512x512 pixel color image. For each image $\mathbf { x } ^ { * }$ , we fit a deep decoder model $G ( \mathbf { C } )$ by minimizing the loss
+
+$$
+L ( \mathbf { C } ) = \left. G ( \mathbf { C } ) - \mathbf { x } ^ { * } \right. _ { 2 } ^ { 2 }
+$$
+
+with respect to the network parameters $\mathbf { C }$ using the Adam optimizer. We then compute for each image the corresponding peak-signal-to-noise ratio, defined as $1 0 \log _ { 1 0 } ( 1 / \mathrm { M S E } )$ , where ${ \mathrm { M S E } } =$ $\begin{array} { r } { \frac { 1 } { 3 \cdot 5 1 2 ^ { 2 } } \| \mathbf { x } ^ { * } - G ( \mathbf { C } ) \| _ { 2 } ^ { 2 } } \end{array}$ , $G ( \mathbf { C } )$ is the image generated by the network, and $\mathbf { x } ^ { * }$ is the original image.
+
+We compare the compression performance to wavelet compression (Antonini et al., 1992) by representing each image with the $N$ -largest wavelet coefficients. Wavelets—which underly JPEG 2000, a standard for image compression—are one of the best methods to approximate images with few coefficients. In Fig. 1 we depict the results. It can be seen that for large compression factors $( 3 \cdot 5 1 2 ^ { 2 } / N = 3 \bar { 2 . } 3 )$ , the representation by the deep decoder is slightly better for most images (i.e., is above the red line), while for smalle compression factors $( 3 \cdot 5 \bar { 1 } 2 ^ { 2 } \bar { / } N = 8 )$ , the wavelet representation is slightly better. This experiment shows that deep neural networks can represent natural images well with very few parameters and without any learning.
+
+The observation that, for small compression factors, wavelets enable more concise representations than the deep decoder is intuitive because any image can be represented exactly with sufficiently many wavelet coefficients. In contrast, there is no reason to believe a priori that the deep decoder has zero representation error because it is underparameterized.
+
+The main point of this experiment is to demonstrate that the deep decoder is a good image model, which enables applications like solving inverse problems, as in Section 4. However, it also suggest that the deep decoder can be used for lossy image compression, by quantizing the coefficients $\mathbf { C }$ and saving the quantized coefficients. In the appendix, we show that image representations of the deep decoder are not sensitive to perturbations of its coefficients, thus quantization does not have a detrimental effect on the image quality. Deep networks were used successfully before for the compression of images (Toderici et al., 2016; Agustsson et al., 2017; Theis et al., 2017). In contrast to our work, which is capable of compressing images without any learning, the aforementioned works learn an encoder and decoder using convolutional recurrent neural networks (Toderici et al., 2016) and convolutional autoencoders (Theis et al., 2017) based on training data.
+
+# 3 THE DEEP DECODER
+
+We consider a decoder architecture that transforms a randomly chosen and fixed tensor ${ \bf B } _ { 0 } \in  { }$ $\mathbb { R } ^ { n _ { 0 } \times k _ { 0 } }$ consisting of $k _ { 0 }$ many $n _ { 0 }$ -dimensional channels to an $n _ { d } \times k _ { \mathrm { o u t } }$ dimensional image, where $k _ { \mathrm { o u t } } ~ = ~ 1$ for a grayscale image, and $k _ { \mathrm { o u t } } ~ = ~ 3$ for an RGB image with three color channels. Throughout, $n _ { i }$ has two dimensions; for example our default configuration has $n _ { 0 } = 1 6 \times 1 6$ and $n _ { d } = 5 1 2 \times 5 1 2$ . The network transforms the tensor $\mathbf { B } _ { 0 }$ to an image by pixel-wise linearly combining the channels, upsampling operations, applying rectified linear units (ReLUs), and normalizing the channels. Specifically, the channels in the $( i + 1 )$ -th layer are given by
+
+![](images/98388eb9d0ef06f5d253a49bfb2c967f9ed9de65da5b600cdb06c19e7b55bc38.jpg)  
+Figure 1: The deep decoder (depicted on the right) enables concise image representations, onpar with state-of-the-art wavelet based compression. The crosses on the left depict the PSNRs for 100 randomly chosen ImageNet-images represented with few wavelet coefficients and with a deep decoder with an equal number of parameters. A cross above the red line means the corresponding image has a smaller representation error when represented with the deep decoder. The deep decoder is particularly simple, as each layer has the same structure, consisting of a pixel-wise linear combination of channels, upsampling, ReLU nonlinearities, and channelwise normalization (CN).
+
+$$
+\mathbf { B } _ { i + 1 } = \operatorname { c n } ( \operatorname { r e l u } ( \mathbf { U } _ { i } \mathbf { B } _ { i } \mathbf { C } _ { i } ) ) , \quad i = 0 , \dots , d - 1 .
+$$
+
+Here, the coefficient matrices $\mathbf { C } _ { i } \in \mathbb { R } ^ { k _ { i } \times k _ { i + 1 } }$ contain the weights of the network. Each column of the tensor $\mathbf { B } _ { i } \mathbf { C } _ { i } \in \mathbb { R } ^ { n _ { i } \times k _ { i + 1 } }$ is formed by taking linear combinations of the channels of the tensor $\mathbf { B } _ { i }$ in a way that is consistent across all pixels.
+
+Then, $\mathrm { c n } ( \cdot )$ performs a channel normalization operation which is equivalent to normalizing each channel individually, and can be viewed as a special case of the popular batch normalization proposed in (Ioffe & Szegedy, 2015). Specifically, let ${ \bf Z } _ { i } = \mathrm { r e l u } ( { \bf U } _ { i } { \bf \bar { B } } _ { i } { \bf \bar { C } } _ { i } )$ be the channels in the $i$ -th layer, and let $\mathbf { z } _ { i j }$ be the $j$ -th channel in the $i$ -th layer. Then channel normalization performs the following transformation: $\begin{array} { r } { \mathbf { z } _ { i j } ^ { \prime } = \frac { \mathbf { z } _ { i j } - \mathrm { m e a n } ( \mathbf { z } _ { i j } ) } { \sqrt { \mathrm { v a r } ( \mathbf { z } _ { i j } ) + \epsilon } } \gamma _ { i j } + \beta _ { i j } } \end{array}$ , where mean and var compute the empirical mean and variance, and $\gamma _ { i j }$ and $\beta _ { i j }$ are parameters, learned independently for each channel, and $\epsilon$ is a fixed small constant. Learning the parameter $\gamma$ and $\beta$ helps the optimization but is not critical. This is a special case of batch normalization with batch size one proposed in (Ioffe & Szegedy, 2015), and significantly improves the fitting of the model, just like how batch norm alleviates problems encountered when training deep neural networks.
+
+The operator $\mathbf { U } _ { i } \in \mathbb { R } ^ { n _ { i + 1 } \times n _ { i } }$ is an upsampling tensor, which we choose throughout so that it performs bi-linear upsampling. For example, if the channels in the input have dimensions $n _ { 0 } = 1 6 \times 1 6$ , then the upsampling operator $\mathbf { U } _ { 0 }$ upsamples each channel to dimensions $3 2 \times 3 2$ . In the last layer, we do not upsample, which is to say that we choose the corresponding upsampling operator as the identity. Finally, the output of the $d$ -layer network is formed as
+
+$$
+\begin{array} { r } { \mathbf { x } = \mathrm { s i g m o i d } ( \mathbf { B } _ { d } \mathbf { C } _ { d } ) , } \end{array}
+$$
+
+where $\mathbf { C } _ { d } ~ \in ~ \mathbb { R } ^ { k _ { d } \times k _ { \mathrm { o u t } } }$ . See Fig. 1 for an illustration. Throughout, our default architecture is a $d = 6$ layer network with $k _ { i } = k$ for all $i$ , and we focus on output images of dimensions $n _ { d } =$ $5 1 2 \times 5 1 2$ and number of channels $k _ { \mathrm { o u t } } = 3$ . Recall that the parameters of the network are given by $\mathbf { C } = \{ \mathbf { C } _ { 0 } , \mathbf { C } _ { 1 } , \hdots , \mathbf { C } _ { d } \}$ , and the output of the network is only a function of $\mathbf { C }$ , since we choose the tensor $\mathbf { B } _ { 0 }$ at random and fix it. Therefore, we write $\mathbf { x } = G ( \mathbf { C } )$ . Note that the number of parameters is given by $\begin{array} { r } { N = \sum _ { i = 1 } ^ { d } ( k _ { i } k _ { i + 1 } + 2 k _ { i } ) + k _ { \mathrm { o u t } } k _ { d } } \end{array}$ where the term $2 k _ { i }$ corresponds to the two free parameters associated with the channel normalization. Thus, the number of parameters is $N = d k ^ { 2 } + 2 d k + 3 k$ . In the default architectures with $d = 6$ and $k = 6 4$ or $k = 1 2 8$ , we have that $N = 2 5 { , } 5 3 6$ (for $k = 6 4$ ) and $N = 1 0 0 { , } 2 2 4$ $k = 1 2 8 ,$ ) out of an RGB image space of dimensionality $5 1 2 \times 5 1 2 \times 3 = 7 8 6 { , } 4 3 2$ parameters.
+
+We finally note that naturally variations of the deep decoder are possible; for example in a previous version of this manuscript, we applied upsampling after applying the relu-nonlinearity, but found that applying it before yields slightly better results.
+
+# 3.1 A NON-CONVOLUTIONAL NETWORK?
+
+While the deep decoder does not use convolutions, its structure is closely related to that of a convolutional neural network. Specifically, the network does have pixelwise linear combinations of channels, and just like in a convolutional neural network, the weights are shared among spatial positions. Nonetheless, pixelwise linear combinations are not proper convolutions because they provide no spatial coupling of pixels, despite how they are sometimes called $1 \times 1$ convolutions. In the deep decoder, the source of spatial coupling is only from upsampling operations.
+
+In contrast, a large number of networks for image compression, restoration, and recovery have convolutional layers with filters of nontrivial spatial extent Toderici et al. (2016); Agustsson et al. (2017); Theis et al. (2017); Burger et al. (2012); Zhang et al. (2017). Thus, it is natural to ask whether using linear combinations as we do, instead of actual convolutions yields better results.
+
+Our simulations indicate that, indeed, linear combinations yield more concise representations of natural images than $p \times p$ convolutions, albeit not by a huge factor. Recall that the number of parameters of the deep decoder with $d$ layers, $k$ channels at each layer, and $1 \times 1$ convolutions is ${ \bf { \dot { \cal { N } } } } ( d , k ; 1 ) = d k ^ { 2 } + 3 { \bf { \dot { k } } } + 2 d k$ . If we consider a deep decoder with convolutional layers with filters of size $p \times p$ , then the number of parameters is: ${ \hat { N ( d , k ; p ) } } = p ^ { 2 } ( d k ^ { 2 } + 3 k ) + 2 { \dot { d k } }$ . If we fix the number of channels, $k$ , but increase $p$ to 3, the representation error only decreases since we increase the number of parameters (by a factor of approximately $3 ^ { 2 }$ ). We consider image reconstruction as described in Section 2. For a meaningful comparison, we keep the number of parameters fixed, and compare the representation error of a deep decoder with $p = 1$ and $k = 6 4$ (the default architecture in our paper) to a variant of the deep decoder with $p = 3$ and $k = 2 2$ , so that the number of parameters is essentially the same in both configurations. We find that the representation of the deep decoder with $p = 1$ is better (by about 1dB, depending on the image), and thus for concise image representations, linear combinations $\smash { \mathrm { ~ \ . ~ } } ^ { \mathrm { ~ T ~ } \times 1 }$ convolutions) appear to be more effective than convolutions of larger spatial extent.
+
+# 4 SOLVING INVERSE PROBLEMS WITH THE DEEP DECODER
+
+In this section, we use the deep decoder as a structure-enforcing model or regularizers for solving standard inverse problems: denoising, super-resolution, and inpainting. In all of those inverse problems, the goal is to recover an image $\mathbf { x }$ from a noisy observation $\mathbf { y } = f ( \mathbf { x } ) + \boldsymbol { \eta }$ . Here, $f$ is a known forward operator (possibly equal to identity), and $\eta$ is structured or unstructured noise.
+
+We recover the image $\mathbf { x }$ with the deep decoder as follows. Motivated by the finding from the previous section that a natural image $\mathbf { x }$ can (approximately) be represented with the deep decoder as $G ( \mathbf { C } )$ , we estimate the unknown image from the noisy observation $\mathbf { y }$ by minimizing the loss
+
+$$
+L ( \mathbf { C } ) = \left\| f ( G ( \mathbf { C } ) ) - \mathbf { y } \right\| _ { 2 } ^ { 2 }
+$$
+
+with respect to the model parameters $\mathbf { C }$ . Let $\hat { \mathbf { C } }$ be the result of the optimization procedure. We estimate the image as $\hat { \mathbf { x } } = G ( \hat { \mathbf { C } } )$ .
+
+We use the Adam optimizer for minimizing the loss, but have obtained comparable results with gradient descent. Note that this optimization problem is non-convex and we might not reach a global minimum. Throughout, we consider the least-squares loss (i.e., we take $\lVert \cdot \rVert _ { 2 }$ to be the $\ell _ { 2 }$ norm), but the loss function can be adapted to account for structure of the noise.
+
+We remark that fitting an image model to observations in order to solve an inverse problem is a standard approach and is not specific to the deep decoder or deep-network-based models in general. Specifically, a number of classical signal recovery approaches fit into this framework; for example solving a compressive sensing problem with $\ell _ { 1 }$ -norm minimization amounts to choosing the forward operator as $f ( \mathbf { x } ) = \mathbf { A x }$ and minimizing over $\mathbf { x }$ in a $\ell _ { 1 }$ -norm ball.
+
+# 4.1 DENOISING
+
+We start with the perhaps most basic inverse problem, denoising. The motivation to study denoising is at least threefold: First, denoising is an important problem in practice, second, many inverse problem can be solved as a chain of denoising steps (Romano et al., 2017), and third, the denoising problem is simple to model mathematically, and thus a common entry point for gaining intuition on a new method. Given a noisy observation $\mathbf { y } = \mathbf { x } + \boldsymbol { \eta }$ , where $\eta$ is additive noise, we estimate an image with the deep decoder by minimizing the least squares loss $\left\| G ( \mathbf { C } ) - \mathbf { y } \right\| _ { 2 } ^ { 2 }$ , as described above.
+
+![](images/eb1e4e815d13625808a98154f04edd3a269aa5182c562ab6954b435e5694e6f0.jpg)  
+Figure 2: An application of the deep decoder for denoising the astronaut test image. The deep decoder has performance on-par with state of the art untrained denoising methods, such as the DIP method (Ulyanov et al., 2018) and the BM3D algorithm (Dabov et al., 2007).
+
+The results in Fig. 2 and Table 1 demonstrate that the deep decoder has denoising performance onpar with state of the art untrained denoising methods, such as the related Deep Image Prior (DIP) method (Ulyanov et al., 2018) (discussed in more detail later) and the BM3D algorithm (Dabov et al., 2007). Since the deep decoder is an untrained method, we only compared to other state-of-the-art untrained methods (as opposed to learned methods such as (Zhang et al., 2017)).
+
+Why does the deep decoder denoise well? In a nutshell, from Section 2 we know that the deep decoder can represent natural images well even when highly underparametrized. In addition, as a consequence of being under-parameterized, the deep decoder can only represent a small proportion of the noise, as we show analytically in Section 6, and as demonstrated experimentally in Fig. 4. Thus, the deep decoder “filters out” a significant proportion of the noise, and retains most of the signal.
+
+How to choose the parameters of the deep decoder? The larger $k$ , the larger the number of latent parameters and thus the smaller the representation error, i.e., the error that the deep decoder makes when representing a noise-free image. On the other hand, the smaller $k$ , the fewer parameters, and the smaller the range space of the deep decoder $G ( \mathbf { C } )$ , and thus the more noise the method will remove. The optimal $k$ trades off those two errors; larger noise levels require smaller values of $k$ (or some other form of regularization). If the noise is significantly larger, then the method requires either choosing $k$ smaller, or it requires another means of regularization, for example early stopping of the optimization. For example $k = 6 4$ or 128 performs best out of $\{ 3 2 , 6 4 , 1 2 8 \}$ , for a PSNR of around 20dB, while for a PSNR of about 14dB, $k = 3 2$ performs best.
+
+# 4.2 SUPERRESOLUTION
+
+We next super-resolve images with the deep denoiser. We define a forward model $f$ that performs downsampling with the Lanczos filter by a factor of four. We then downsample a given image by a factor of four, and then reconstruct it with the deep decoder (with $k = 1 2 8$ , as before). We compare performance to bi-cubic interpolation and to the deep image prior, and find that the deep decoder outperforms bicubic interpolation, and is on-par with the deep image prior (see Table 1 in the appendix).
+
+# 4.3 INPAINTING
+
+Finally, we use the deep decoder for inpainting, where we are given an inpainted image $\mathbf { y }$ , and a forward model $f$ mapping a clean image to an inpainted image. The forward model $f$ is defined by a mask that describes the inpainted region, and simply maps that part of the image to zero. Fig. 3 and Table 1 demonstrate that the deep decoder performs well on the inpainting problems; however, the deep image prior performs slightly better on average over the examples considered. For the impainting problem we choose a significantly more expressive prior, specifically $k = 3 2 0$ .
+
+![](images/c836519214a72355970314dd98d20329fb961a66184b5085c75d50d9e0a9adf1.jpg)  
+Figure 3: An application of the deep decoder for recovering an inpainted image. For this example, the deep decoder and the deep image perform almost equally well.
+
+# 5 RELATED WORK
+
+Image compression, restoration, and recovery algorithms are either trained or untrained. Conceptually, the deep decoder image model is most related to untrained methods, such as sparse representations in overcomplete dictionaries (for example wavelets (Donoho, 1995) and curvelets (Starck et al., 2002)). A number of highly successful image restoration and recovery schemes are not directly based on generative image models, but rely on structural assumptions about the image, such as exploiting self-similarity in images for denoising (Dabov et al., 2007) and super-resolution (Glasner et al., 2009).
+
+Since the deep decoder is an image-generating deep network, it is also related to methods that rely on trained deep image models. Deep learning based methods are either trained end-to-end for tasks ranging from compression (Toderici et al., 2016; Agustsson et al., 2017; Theis et al., 2017; Burger et al., 2012; Zhang et al., 2017) to denoising (Burger et al., 2012; Zhang et al., 2017), or are based on learning a generative image model (by training an autoencoder or GAN (Hinton & Salakhutdinov, 2006; Goodfellow et al., 2014)) and then using the resulting model to solve inverse problems such as compressed sensing (Bora et al., 2017; Hand & Voroninski, 2018), denoising (Heckel et al., 2018), phase retrieval (Hand et al., 2018; Shamshad & Ahmed, 2018), and blind deconvolution (Asim et al., 2018), by minimizing an associated loss. In contrast to the deep decoder, where the optimization is over the weights of the network, in all the aforementioned methods, the weights are adjusted only during training and then are fixed upon solving the inverse problem.
+
+Most related to our work is the Deep Image Prior (DIP), recently proposed by Ulyanov et al. (Ulyanov et al., 2018). The deep image prior is an untrained method that uses a network with an hourglass or encoder-decoder architecture, similar to the U-net and related architectures that work well as autoencoders. The key differences to the deep decoder are threefold: i) the DIP is over-parameterized, whereas the deep decoder is under-parameterized. ii) Since the DIP is highly over-parameterized, it critically relies on regularization through early stopping and adding noise to its input, whereas the deep decoder does not need to be regularized (however, regularization can enhance performance). iii) The DIP is a convolutional neural network, whereas the deep decoder is not.
+
+We further illustrate point ii) comparing the DIP and deep decoder by denoising the astronaut image from Fig. 2. In Fig. 4(a) we plot the Mean Squared Error (MSE) over the number of iterations of the optimizer for fitting the noisy astronaut image $\mathbf { x } + \boldsymbol { \eta }$ . Note that to fit the model, we minimize the error $\| G ( \mathbf { C } ) - ( \mathbf { x } + \pmb { \eta } ) \| _ { 2 } ^ { 2 }$ , because we are only given the noisy image, but we plot the MSE between the representation and the actual, true image $\left\| G ( \mathbf { C } ^ { t } ) - \mathbf { x } \right\| _ { 2 } ^ { 2 }$ at iteration $t$ . Here, $\mathbf { C } ^ { t }$ are the parameters of the deep decoder after $t$ iterations of the optimizer. In Fig. 4(b) and (c), we plot the loss or MSE associated with fitting the noiseless astronaut image, x $( \left\| \boldsymbol { G } ( \mathbf { C } ^ { t } ) - \mathbf { x } \right\| _ { 2 } ^ { 2 } )$ and the noise itself, $\eta$ , $( \left\| \boldsymbol G ( \mathbf C ^ { t } ) - \boldsymbol \eta \right\| _ { 2 } ^ { 2 } )$ . Models are fitted independently for the noisy image, the noiseless image, and the noise.
+
+The plots in Fig. 4 show that with sufficiently many iterations, both the DIP and the DD can fit the image well. However, even with a large number of iterations, the deep decoder can not fit the noise well, whereas the DIP can. This is not surprising, given that the DIP is over-parameterized and the deep decoder is under-parameterized. In fact, in Section 6 we formally show that due to the underparameterization, the deep decoder can only fit a small proportion of the noise, no matter how and how long we optimize. As a consequence, it filters out much of the noise when applied to a natural image. In contrast, the DIP relies on the empirical observation that the DIP fits a structured image faster than it fits noise, and thus critically relies on early stopping.
+
+![](images/b4e3ef1a6e49f8715c4b4d1235107ae96448cb82b08450cb3fbabcb8ace80ab8.jpg)  
+Figure 4: Denoising with the deep decoder and the deep image prior. The first two panels shows the MSE of the output of the DD or DIP for a noisy or noiseless image relative to the noiseless image. The third panel shows the MSE of the output of DD or DIP for an image consisting purely of noise, as computed relative to that noise. Due to under-parameterization, the deep decoder can only fit a small proportion of the noise, and thus enables image denoising. Early stopping can mildly enhance the performance of DD; to see this note that in panel (a), the minimum is obtained at around 5000 iterations and not at 50,000. The deep image prior can fit noise very well, but fits an image faster than noise, thus early stopping is critical for denoising performance.
+
+# 6 DISCUSSION ON WHAT MAKES THE DECODER WORK
+
+In the previous sections we empirically showed that the deep decoder can represent images well and at the same time cannot fit noise well. In this section, we formally show that the deep decoder can only fit a small proportion of the noise, relative to the degree of underparameterization. In addition, we provide insights into how the components of the deep decoder contribute to representing natural images well, and we provide empirical observations on the sensitivity of the parameters and their distribution.
+
+# 6.1 THE DEEP DECODER CAN ONLY FIT LITTLE NOISE
+
+We start by showing that an under-parameterized deep decoder can only fit a proportion of the noise relative to the degree of underparameterization. At the heart of our argument is the intuition that a method mapping from a low- to a high-dimensional space can only fit a proportion of the noise relative to the number of free parameters. For simplicity, we consider a one-layer network, and ignore the batch normalization operation. Then, the networks output is given by
+
+$$
+G ( \mathbf { C } ) = \operatorname { r e l u } ( \mathbf { U } _ { 0 } \mathbf { B } _ { 0 } \mathbf { C } _ { 0 } ) \mathbf { c } _ { 1 } \in \mathbb { R } ^ { n } .
+$$
+
+Here, we take $\mathbf { C } = ( \mathbf { C } _ { 0 } , \mathbf { c } _ { 1 } )$ , where $\mathbf { C } _ { 0 }$ is a $k \times k$ matrix and $\mathbf { c } _ { 1 }$ is a $k$ -dimensional vector, assuming that the number of output channels is 1. While for the performance of the deep decoder the choice of upsampling matrix is important, it is not relevant for showing that the deep decoder cannot represent noise well. Therefore, the following statement makes no assumptions about the upsampling matrix $\mathbf { U } _ { 0 }$ .
+
+Proposition 1. Consider a deep decoder with one layer and arbitrary upsampling and input matrices. That is, let $\mathbf { B } _ { 0 } \in \mathbb { R } ^ { n _ { 0 } \times k }$ and $\mathbf { U } _ { 0 } \in \mathbb { R } ^ { n \times n _ { 0 } }$ . Let $\eta \in \mathbb { R } ^ { n }$ be zero-mean Gaussian noise with covariance matrix σI, $\sigma > 0$ . Assume that $k ^ { 2 } \log ( n _ { 0 } ) / n \leq 1 / 3 2$ . Then, with probability at least $1 - 2 { n _ { 0 } } ^ { - k ^ { 2 } }$
+
+$$
+\operatorname* { m i n } _ { \mathbf { C } } \left\| { G ( \mathbf { C } ) - \eta } \right\| _ { 2 } ^ { 2 } \geq \left\| \eta \right\| _ { 2 } ^ { 2 } \left( 1 - 2 0 \frac { k ^ { 2 } \log ( n _ { 0 } ) } { n } \right) .
+$$
+
+The proposition asserts that the deep decoder can only fit a small portion of the noise energy, precisely a proportion determined by its number of parameters relative to the output dimension, $n$ . Our simulations and preliminary analytic results suggest that this statement extends to multiple layers in that the lower bound becomes 1 − c k2 log(Qdi=1 ni−1)n  , where $c$ is a numerical constant. Note that the lower bound does not directly depend on the noise variance $\sigma$ since both sides of the inequality scale with $\sigma ^ { 2 }$ .
+
+![](images/910ad77a0e68cff5d46dbe68489dc23d1136d095583796613342adbc30e026c4.jpg)  
+Figure 5: The blue curves show a one-dimensional piecewise smooth signal, and the red crosses show estimates of this signal by a one-dimensional deep decoder with either linear or convex upsampling. We see that linear upsampling acts as an indirect signal prior that promotes piecewise smoothness.
+
+# 6.2 UPSAMPLING
+
+Upsampling is a vital part of the deep decoder because it is the only way that the notion of locality explicitly enters the signal model. In contrast, most convolutional neural networks have spatial coupling between pixels both by unlearned upsampling, but also by learned convolutional filters of nontrivial spatial extent. The choice of the upsampling method in the deep decoder strongly affects the ‘character’ of the resulting signal estimates. We now discuss the impacts of a few choices of upsampling matrices $\mathbf { U } _ { i }$ , and their impact on the images the model can fit.
+
+No upsampling: If there is no upsampling, or, equivalently, if $\mathbf { U } _ { i } = \mathbf { I }$ , then there is no notion of locality in the resulting image. All pixels become decoupled, and there is then no notion of which pixels are near to each other. Specifically, a permutation of the input pixels (the rows of $\mathbf { B } _ { 0 }$ ) simply induces the identical permutation of the output pixels. Thus, if a deep decoder without upsampling could fit a given image, it would also be able to fit random permutations of the image equally well, which is practically equivalent to fitting random noise.
+
+Nearest neighbor upsampling: If the upsampling operations perform nearest neighbor upsampling, then the output of the deep decoder consists of piecewise constant patches. If the upsampling doubles the image dimensions at each layer, this would result in patches of $2 ^ { d } \times 2 ^ { d }$ pixels that are constant. While this upsampling method does induce a notion of locality, it does so too strongly in the sense that squares of nearby pixels become identical and incapable of fitting local variation within natural images.
+
+Linear and convex, non-linear upsampling: The specific choice of upsampling matrix affects the multiscale ‘character’ of the signal estimates. To illustrate this, Figure 5 shows the signal estimate from a 1-dimensional deep decoder with upsampling operations given by linear upsampling $( x _ { 0 } , x _ { 1 } , x _ { 2 } , \ldots ) \mapsto ( x _ { 0 } , 0 . 5 x _ { 0 } + 0 . 5 x _ { 1 } , x _ { 1 } , 0 . 5 x _ { 1 } + 0 . 5 x _ { 2 } , x _ { 2 } , \ldots )$ and convex nonlinear upsampling given by $( x _ { 0 } , x _ { 1 } , x _ { 2 } , \ldots ) \mapsto ( x _ { 0 } , 0 . 7 5 x _ { 0 } + 0 . 2 5 x _ { 1 } , x _ { 1 } , 0 .$ .75x1 + 0.25x2, x2, . . .). Note that while both models are able to capture the coarse signal structure, the convex upsampling results in a multiscale fractal-like structure that impedes signal representation. In contrast, linear upsampling is better able to represent smoothly varying portions of the signal. Linear upsampling in a deep decoder indirectly encodes the prior that natural signals are piecewise smooth and in some sense have approximately linear behavior at multiple scales
+
+# 6.3 NETWORK INPUT
+
+Throughout, the network input is fixed. We choose the network input $\mathbf { B } _ { 1 }$ by choosing its entries uniformly at random. The particular choice of the input is not very important; it is however desirable that the rows are incoherent. To see this, as an extreme case, if any two rows of $\mathbf { B } _ { 1 }$ are equal and if the upsampling operation preserves the values of those pixels exactly (for example, as with the linear upsampling from the previous section), then the corresponding pixels of the output image is also exactly the same, which restricts the range space of the deep decoder unrealistically, since for any pair of pixels, the majority of natural images does not have exactly the same value at this pair of pixels.
+
+![](images/556c00a166d94a9d51ab568d756758de3ea019b79bd82556d45cce65705b59d0.jpg)  
+Figure 6: The left panel shows an image reconstruction after training a deep decoder on the MRI phantom image (PSNR is 51dB). The right panel shows how the deep decoder builds up an image starting from a random input. From top to bottom are the input to the network and the activation maps (i.e., $\operatorname { r e l u } ( \mathbf { B } _ { i } \mathbf { C } _ { i } ) ) ,$ ) for eight out of the 64 channels in layers one to six.
+
+Table 1: Performance comparison of the deep decoder for denoising (DN), superresolution (SR), and inpainting (IP), in peak signal to noise ratio (PSNR). Note that identity corresponds to the PSNR of the noise and corruption in the DN and IP experiments, respectively.   
+
+<table><tr><td></td><td></td><td>barbara</td><td>lovett</td><td>mri</td><td>zebra</td><td>F16</td><td>baboon</td><td>fruit</td><td>astronaut</td><td>castle</td><td>saturn</td></tr><tr><td rowspan="4">DN</td><td>identity</td><td>20.3</td><td>20.9</td><td>22.1</td><td>21.3</td><td>20.3</td><td>20.3</td><td>20.5</td><td>20.6</td><td>20.4</td><td>20.2</td></tr><tr><td>DD128</td><td>26.8</td><td>27.9</td><td>26.9</td><td>22.5</td><td>29.1</td><td>21.4</td><td>29.2</td><td>29.8</td><td>27.7</td><td>29.0</td></tr><tr><td>DIP</td><td>24.4</td><td>25.3</td><td>26.6</td><td>24.8</td><td>25.0</td><td>22.8</td><td>25.7</td><td>26.1</td><td>25.0</td><td>25.0</td></tr><tr><td>BM3D</td><td>24.7</td><td>25.1</td><td>28.0</td><td>22.8</td><td>25.2</td><td>22.6</td><td>26.3</td><td>26.2</td><td>25.6</td><td>30.5</td></tr><tr><td rowspan="3">SR</td><td>bicubic</td><td>26.3</td><td>26.0</td><td>24.5</td><td>18.2</td><td>26.4</td><td>20.7</td><td>27.1</td><td>29.3</td><td>25.8</td><td>27.9</td></tr><tr><td>DD128</td><td>26.4</td><td>26.3</td><td>26.4</td><td>19.0</td><td>26.6</td><td>20.6</td><td>28.6</td><td>30.2</td><td>26.1</td><td>27.8</td></tr><tr><td>DIP</td><td>26.4</td><td>26.6</td><td>25.6</td><td>19.2</td><td>27.4</td><td>20.6</td><td>28.3</td><td>29.6</td><td>26.0</td><td>27.9</td></tr><tr><td rowspan="3">IP</td><td>identity</td><td>14.9</td><td>14.4</td><td>18.3</td><td>13.0</td><td>11.7</td><td>14.0</td><td>12.4</td><td>14.0</td><td>14.2</td><td>13.4</td></tr><tr><td>DD320</td><td>32.3</td><td>33.6</td><td>31.4</td><td>24.4</td><td>34.9</td><td>24.9</td><td>36.6</td><td>36.5</td><td>32.5</td><td>36.7</td></tr><tr><td>DIP</td><td>35.6</td><td>26.9</td><td>32.1</td><td>24.2</td><td>34.7</td><td>26.2</td><td>35.5</td><td>35.3</td><td>32.6</td><td>36.2</td></tr></table>
+
+# 6.4 IMAGE GENERATION BY SUCCESSIVE APPROXIMATION
+
+The deep decoder is tasked with coverting multiple noise channels into a structured signal primarily using pixelwise linear combinations, ReLU activation funcions, and upsampling. Using these tools, the deep decoder builds up an image through a series of successive approximations that gradually morph between random noise and signal. To illustrate that, we plot the activation maps (i.e., $\operatorname { r e l u } ( \mathbf { B } _ { i } \mathbf { C } _ { i } ) )$ of a deep decoder fitted to the phantom MRI test image (see Fig. 6). We choose a deep decoder with $d = 5$ layers and $k = 6 4$ channels. This image reconstruction approach is in contrast to being a semantically meaningful hierarchical representation (i.e., where edges get combined into corners, that get combined into simple sample, and then into more complicated shapes), similar to what is common in discriminative networks.
+
+# ACKNOWLEDGMENTS
+
+RH is partially supported by NSF award IIS-1816986, an NVIDIA Academic GPU Grant, and would like to thank Ludwig Schmidt for helpful discussions on the deep decoder in general, and in particular for suggestions on the experiments in Section 2.
+
+Code to reproduce the results is available at https://github.com/reinhardh/ supplement_deep_decoder
+
+REFERENCES   
+E. Agustsson, F. Mentzer, M. Tschannen, L. Cavigelli, R. Timofte, L. Benini, and L. V. Gool. Softto-hard vector quantization for end-to-end learning compressible representations. In Advances in Neural Information Processing Systems, pp. 1141–1151, 2017.   
+M. Antonini, M. Barlaud, P. Mathieu, and I. Daubechies. Image coding using wavelet transform. IEEE Transactions on Image Processing, 1(2):205–220, 1992.   
+M. Asim, F. Shamshad, and A. Ahmed. Solving bilinear inverse problems using deep generative priors. arXiv preprint arXiv:1802.04073, 2018.   
+A. Bora, A. Jalal, E. Price, and A. G. Dimakis. Compressed sensing using generative models. In International Conference on Machine Learning, pp. 537–546, 2017.   
+H. C. Burger, C. J. Schuler, and S. Harmeling. Image denoising: Can plain neural networks compete with BM3d? In IEEE Conference on Computer Vision and Pattern Recognition, pp. 2392–2399, 2012.   
+K. Dabov, A. Foi, V. Katkovnik, and K. Egiazarian. Image denoising by sparse 3-D transformdomain collaborative filtering. IEEE Transactions on Image Processing, 16(8):2080–2095, 2007.   
+D. L. Donoho. De-noising by soft-thresholding. IEEE Transactions on Information Theory, 41(3): 613–627, 1995.   
+D. Glasner, S. Bagon, and M. Irani. Super-resolution from a single image. In IEEE International Conference on Computer Vision, pp. 349–356, 2009.   
+I. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems, pp. 2672–2680. 2014.   
+P. Hand and V. Voroninski. Global guarantees for enforcing deep generative priors by empirical risk. In Conference on Learning Theory, pp. 970–978, 2018.   
+P. Hand, O. Leong, and V. Voroninski. Phase retrieval under a generative prior. In Advances in Neural Information Processing, pp. 9136–9146, 2018.   
+R. Heckel, W. Huang, P. Hand, and V. Voroninski. Deep denoising: Rate-optimal recovery of structured signals with a deep prior. arXiv:1805.08855, 2018.   
+G. E. Hinton and R. R. Salakhutdinov. Reducing the dimensionality of data with neural networks. Science, 313(5786):504–507, 2006.   
+S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015.   
+B. Laurent and P. Massart. Adaptive estimation of a quadratic functional by model selection. The Annals of Statistics, 28(5):1302–1338, 2000.   
+Y. Romano, M. Elad, and P. Milanfar. The little engine that could: Regularization by denoising (red). SIAM Journal on Imaging Sciences, 10(4):18041844, 2017.   
+F. Shamshad and A. Ahmed. Robust compressive phase retrieval via deep generative priors. arXiv preprint arXiv:1808.05854, 2018.   
+J.-L. Starck, E. J. Candes, and D. L. Donoho. The curvelet transform for image denoising. IEEE Transactions on Image Processing, 11(6):670–684, 2002.   
+L. Theis, W. Shi, A. Cunningham, and F. Huszar. Lossy image compression with compressive ´ autoencoders. In International Conference on Learning Representations, 2017.   
+G. Toderici, S. M. OMalley, S. J. Hwang, D. Vincent, D. Minnen, S. Baluja, M. Covell, and R. Sukthankar. Variable rate image compression with recurrent neural networks. In International Conference on Learning Representations, 2016.   
+D. Ulyanov, A. Vedaldi, and V. Lempitsky. Deep image prior. In Conference on Computer Vision and Pattern Recognition, 2018.   
+R. O. Winder. Partitions of n-space by hyperplanes. SIAM Journal on Applied Mathematics, 14(4): 811–818, 1966.   
+K. Zhang, W. Zuo, Y. Chen, D. Meng, and L. Zhang. Beyond a Gaussian denoiser: Residual learning of deep CNN for image denoising. IEEE Transactions on Image Processing, 26(7):3142–3155, 2017.
+
+# APPENDIX
+
+# A PROOF OF PROPOSITION 1
+
+Suppose that the network has one layer, i.e., $G ( { \bf C } ) = \mathrm { r e l u } ( { \bf U } _ { 0 } { \bf B } _ { 0 } { \bf C } _ { 0 } ) { \bf c } _ { 1 }$ . We start by re-writing ${ \bf B } _ { 1 } = \mathrm { r e l u } ( { \bf B } _ { 0 } { \bf C } _ { 0 } )$ in a convenient form. For a given vector $\mathbf { x } \in \mathbb { R } ^ { n }$ , denote by $\mathrm { d i a g } ( \mathbf { x } > 0 )$ the matrix that contains one on its diagonal if the respective entry of $\mathbf { x }$ is positive and zero otherwise. Let ${ \bf c } _ { j c i }$ denote the $i$ -th column of $\mathbf { C } _ { j }$ , and denote by $\mathbf { W } _ { j i } \in \mathbf { \bar { \{ 0 , 1 \} } } ^ { k \times k }$ the corresponding diagonal matrix $\mathbf { W } _ { j i } = \mathrm { d i a g } ( \mathbf { U } _ { j } \mathbf { B } _ { j } \mathbf { c } _ { j c i } > 0 )$ ). With this notation, we can write
+
+$$
+{ \bf B } _ { 1 } = \mathrm { r e l u } ( { \bf U } _ { 0 } { \bf B } _ { 0 } { \bf C } _ { 0 } ) = [ { \bf W } _ { 0 1 } { \bf U } _ { 0 } { \bf B } _ { 0 } { \bf c } _ { 0 c 1 } , \ldots , { \bf W } _ { 0 k } { \bf U } _ { 0 } { \bf B } _ { 0 } { \bf c } _ { 0 c k } ] .
+$$
+
+Thus,
+
+$$
+G ( \mathbf { C } ) = [ \mathbf { W } _ { 0 1 } \mathbf { U } _ { 0 } \mathbf { B } _ { 0 } , \dots , \mathbf { W } _ { 0 k } \mathbf { U } _ { 0 } \mathbf { B } _ { 0 } ] \left[ \begin{array} { c } { \mathbf { c } _ { 0 c 1 } [ \mathbf { c } _ { 1 } ] _ { 1 } } \\ { \vdots } \\ { \mathbf { c } _ { 0 c 1 } [ \mathbf { c } _ { 1 } ] _ { k } } \end{array} \right] ,
+$$
+
+where $[ \mathbf { c } _ { 1 } ] _ { i }$ denotes the $i$ -th entry of $\mathbf { c } _ { 1 }$ . Thus, $G ( \mathbf { C } )$ lies in the union of at-most- $k ^ { 2 }$ -dimensional subspaces of $\mathbb { R } ^ { n }$ , where each subspace is determined by the matrices $\{ \mathbf { W } _ { 0 j } \} _ { j = 1 } ^ { k }$ . The number of those subspaces is bounded by $n ^ { k ^ { 2 } }$ . This follows from the fact that for the matrix $\mathbf { A } : = \mathbf { U } _ { 0 } \mathbf { B } _ { 0 }$ , by Lemma 1 below, the number of different matrices $\mathbf { W } _ { 0 j }$ is bounded by $n ^ { k }$ . Since there are $k$ matrices, the number of different sets of matrices is bounded by $n ^ { k ^ { 2 } }$ .
+
+Lemma 1. For any $\mathbf { A } \in \mathbb { R } ^ { n \times k }$ and $k \geq 5$
+
+$$
+| \{ \mathrm { d i a g } ( \mathbf { A } \mathbf { v } > 0 ) \mathbf { A } | \mathbf { v } \in \mathbb { R } ^ { k } \} | \leq n ^ { k } .
+$$
+
+Next, fix the matrixes $\{ \mathbf { W } _ { 0 j } \} _ { j }$ . As $G ( \mathbf { C } )$ lies in an at-most- $k ^ { 2 }$ -dimensional subspace, let $S$ be a $k ^ { 2 }$ -dimensional subspace that contains the range of $G$ for these fixed $\{ \mathbf { W } _ { 0 j } \} _ { j }$ . It follows that
+
+$$
+\operatorname* { m i n } _ { \mathbf { C } } \left\| G ( \mathbf { C } ) - \eta \right\| _ { 2 } ^ { 2 } \geq \frac { \left\| P _ { S ^ { c } } \eta \right\| _ { 2 } ^ { 2 } } { \left\| \eta \right\| _ { 2 } ^ { 2 } } .
+$$
+
+Now, we make use of the following bound on the projection of the noise $\eta$ onto a subspace.
+
+Lemma 2. Let $S \subset \mathbb { R } ^ { n }$ be a subspace with dimension $\ell .$ . Let $\eta \sim \mathcal { N } ( 0 , I _ { n } )$ and $\beta \geq 1$ . Then,
+
+$$
+\mathrm { P } \left[ \frac { \left\| P _ { S ^ { c } } \eta \right\| _ { 2 } ^ { 2 } } { \left\| \eta \right\| _ { 2 } ^ { 2 } } \ge 1 - \frac { 1 0 \beta \ell } { n } \right] \ge 1 - e ^ { - \beta \ell } - e ^ { - n / 1 6 } .
+$$
+
+Proof of Lemma 2. From Laurent & Massart (2000, Lem. 1), if $X \sim \chi _ { n } ^ { 2 }$ , then
+
+$$
+\begin{array} { r } { \mathrm { P } \left[ X - n \geq 2 \sqrt { n x } + 2 x \right] \leq e ^ { - x } , } \\ { \mathrm { P } \left[ X \leq n - 2 \sqrt { n x } \right] \leq e ^ { - x } . } \end{array}
+$$
+
+With these, we obtain
+
+$$
+\begin{array} { r l } & { \mathrm { P } \left[ X \ge 5 \beta n \right] \le e ^ { - \beta n } \mathrm { i f } \beta \ge 1 , } \\ & { \mathrm { P } \left[ X \le n / 2 \right] \le e ^ { - n / 1 6 } . } \end{array}
+$$
+
+We have $\begin{array} { r } { \frac { \| P _ { S ^ { c } } \eta \| _ { 2 } ^ { 2 } } { \| \eta \| _ { 2 } ^ { 2 } } = 1 - \frac { \| P _ { S } \eta \| _ { 2 } ^ { 2 } } { \| \eta \| _ { 2 } ^ { 2 } } } \end{array}$ . Note that $\| P _ { S } \eta \| _ { 2 } \sim \chi _ { \ell } ^ { 2 }$ and $\left\| \eta \right\| _ { 2 } ^ { 2 } \sim \chi _ { n } ^ { 2 }$ . Applying inequality (2) to bound $\| P _ { S } \eta \| _ { 2 }$ and inequality (3) to bound $\| \boldsymbol { \eta } \| _ { 2 } ^ { 2 }$ , a union bound gives that claim. □
+
+Thus, by inequality (1) and Lemma 2 with $\ell = k ^ { 2 }$ , for all $\beta \geq 1$
+
+$$
+\mathrm { P } \left[ \frac { 1 } { \left\| \eta \right\| _ { 2 } ^ { 2 } } \operatorname* { m i n } _ { \mathbf { C } } \left\| \boldsymbol { G } ( \mathbf { C } ) - \eta \right\| _ { 2 } ^ { 2 } \geq 1 - \frac { 1 0 \beta k ^ { 2 } } { n } \bigg | \{ \mathbf { W } _ { 0 j } \} _ { j } \right] \geq 1 - e ^ { - k ^ { 2 } \beta } - e ^ { - n / 1 6 } .
+$$
+
+Since the number of matrices $\{ \mathbf { W } _ { 0 j } \} _ { j }$ is bounded by ${ n _ { 0 } } ^ { k ^ { 2 } }$ , by a union bound,
+
+$$
+\mathrm { P } \left[ \frac { 1 } { \left\| \eta \right\| _ { 2 } ^ { 2 } } \operatorname* { m i n } _ { \mathbf { C } } \left\| \boldsymbol { G } ( \mathbf { C } ) - \eta \right\| _ { 2 } ^ { 2 } \leq 1 - \frac { 1 0 \beta k ^ { 2 } } { n } \right] \leq { n _ { 0 } } ^ { k ^ { 2 } } \big ( e ^ { - \beta k ^ { 2 } } + e ^ { - n / 1 6 } \big ) \leq { 2 n _ { 0 } } ^ { - k ^ { 2 } } ,
+$$
+
+where the last inequality follows with choosing $\beta = 2 \log ( n _ { 0 } )$ and by the assumption that $k ^ { 2 } <$ $\frac { n } { 3 2 \log n _ { 0 } }$ This proves the claim in Proposition 1.
+
+![](images/ec5e689357789706d2a98d754ab29cc6b3548f4c17563a8b8a5e66cb53f16c04.jpg)  
+Figure 7: Sensitivity to parameter perturbations of the weights in each layer, and images generated by perturbing the weights in different layers, and keeping the weights in the other layers constant.
+
+# A.1 PROOF OF LEMMA 1
+
+Our goal is to count the number of sign patterns $( \mathbf { A } \mathbf { v } > 0 ) \in \{ 0 , 1 \}$ . Note that this number is equal to the maximum number of partitions one can get when cutting a $k$ -dimensional space with $n$ many hyperplanes that all pass through the origin, and are perpendicular to the rows of A. This number if well known (see for example Winder (1966)) and is upper bounded by
+
+$$
+2 \sum _ { i = 0 } ^ { n - 1 } { \binom { n - 1 } { k } } .
+$$
+
+Thus,
+
+$$
+| \{ \mathrm { d i a g } ( \mathbf { A } \mathbf { v } > 0 ) \mathbf { A } \colon \mathbf { v } \in \mathbb { R } ^ { k } \} | \leq 2 \sum _ { i = 0 } ^ { n - 1 } { \binom { n - 1 } { k } } \leq 2 k \left( { \frac { e ( n - 1 ) } { k } } \right) ^ { k } \leq n ^ { k } ,
+$$
+
+where the last inequality holds for $k \geq 5$ .
+
+# B SENSITIVITY TO PARAMETER PERTURBATIONS AND DISTRIBUTION OF PARAMETERS
+
+The deep decoder is not overly sensitive to perturbations of its coefficients. To demonstrate this, fit the standard test image Barbara with a deep decoder with 6 layers and $k = 1 2 8$ , as before. We then perturb the weights in a given layer $i$ (i.e., the matrix $\mathbf { C } _ { i }$ ) with Gaussian noise of a certain signal-tonoise ratio relative to $\mathbf { C } _ { i }$ and leave the other weights and the input untouched. We then measure the peak signal-to-noise ratio in the image domain, and plot the corresponding curve for each layer (see Fig. 7). It can be seen that the representation provided by the deep decoder is relatively stable with respect to perturbations of its coefficients, and that it is more sensitive to perturbations in higher levels.
+
+Finally, in Fig. 8 we depict the distribution of the weights of the network after fitted to the Barbara test image, and note that the weights are approximately Gaussian distributed.
+
+![](images/8dd65c1fbb98abe334c56bfccb3383d2b727edb450726b6fb31812cc7708668e.jpg)  
+Figure 8: Distribution of the weights for fitting the test image Barbara along with a Gaussian fit: The distribution of the weighs is approximately Gaussian.

parse/train/rylV-2C9KQ/rylV-2C9KQ_content_list.json

@@ -0,0 +1,1479 @@
+[
+    {
+        "type": "text",
+        "text": "DEEP DECODER: CONCISE IMAGE REPRESENTATIONS FROM UNTRAINED NON-CONVOLUTIONAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinhard Heckel   \nDepartment of Electrical and Computer Engineering   \nRice University   \nrh43@rice.edu   \nPaul Hand   \nDepartment of Mathematics and   \nCollege of Computer and Information Science   \nNortheastern University   \np.hand@northeastern.edu ",
+        "bbox": [
+            183,
+            195,
+            526,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            544,
+            195,
+            849,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            301,
+            544,
+            316
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks, in particular convolutional neural networks, have become highly effective tools for compressing images and solving inverse problems including denoising, inpainting, and reconstruction from few and noisy measurements. This success can be attributed in part to their ability to represent and generate natural images well. Contrary to classical tools such as wavelets, imagegenerating deep neural networks have a large number of parameters—typically a multiple of their output dimension—and need to be trained on large datasets. In this paper, we propose an untrained simple image model, called the deep decoder, which is a deep neural network that can generate natural images from very few weight parameters. The deep decoder has a simple architecture with no convolutions and fewer weight parameters than the output dimensionality. This underparameterization enables the deep decoder to compress images into a concise set of network weights, which we show is on par with wavelet-based thresholding. Further, underparameterization provides a barrier to overfitting, allowing the deep decoder to have state-of-the-art performance for denoising. The deep decoder is simple in the sense that each layer has an identical structure that consists of only one upsampling unit, pixel-wise linear combination of channels, ReLU activation, and channelwise normalization. This simplicity makes the network amenable to theoretical analysis, and it sheds light on the aspects of neural networks that enable them to form effective signal representations. ",
+        "bbox": [
+            233,
+            335,
+            764,
+            613
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            646,
+            336,
+            662
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Data models are central for signal and image processing and play a key role in compression and inverse problems such as denoising, super-resolution, and compressive sensing. These data models impose structural assumptions on the signal or image, which are traditionally based on expert knowledge. For example, imposing the assumption that an image can be represented with few non-zero wavelet coefficients enables modern (lossy) image compression (Antonini et al., 1992) and efficient denoising (Donoho, 1995). ",
+        "bbox": [
+            174,
+            680,
+            825,
+            763
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In recent years, it has been demonstrated that for a wide range of imaging problems, from compression to denoising, deep neural networks trained on large datasets can often outperform methods based on traditional image models (Toderici et al., 2016; Agustsson et al., 2017; Theis et al., 2017; Burger et al., 2012; Zhang et al., 2017). This success can largely be attributed to the ability of deep networks to represent realistic images when trained on large datasets. Examples include learned representations via autoencoders (Hinton & Salakhutdinov, 2006) and generative adversarial models (Goodfellow et al., 2014). Almost exclusively, three common features of the recent success stories of using deep neural network for imaging related tasks are i) that the corresponding networks are over-parameterized (i.e., they have much more parameters than the dimension of the image that they represent or generate), ii) that the networks have a convolutional structure, and perhaps most importantly, iii) that the networks are trained on large datasets. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An important exception that breaks with the latter feature is a recent work by Ulyanov et al. Ulyanov et al. (2018), which provides an algorithm, called the deep image prior (DIP), based on deep neural networks, that can solve inverse problems well without any training. Specifically, Ulyanov et al. demonstrated that fitting the weights of an over-parameterized deep convolutional network to a single image, together with strong regularization by early stopping of the optimization, performs competitively on a variety of image restoration problems. This result is surprising because it does not involve a training dataset, which means that the notion of what makes an image ‘natural’ is contained in a combination of the network structure and the regularization. However, without regularization the proposed network has sufficient capacity to overfit to noise, preventing meaningful image denoising. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "These prior works demonstrating the effectiveness of deep neural networks for image generation beg the question whether there may be a deep neural network model of natural images that is underparameterized and whose architecture alone, without algorithmic assistance, forms an efficient model for natural images. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a simple image model in the form of a deep neural network that can represent natural images well while using very few parameters. This model thus enables image compression, denoising, and solving a variety of inverse problems with close to or state of the art performance. We call the network the deep decoder, due to its resemblance to the decoder part of an autoencoder. The network does not require training, and contrary to previous approaches, the network itself incorporates all assumptions on the data, is under-parameterized, does not involve convolutions, and has a simplicity that makes it amenable to theoretical analysis. The key contributions of this paper are as follows: ",
+        "bbox": [
+            174,
+            313,
+            825,
+            424
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• The network is under-parameterized. Thus, the network maps a lower-dimensional space to a higher-dimensional space, similar to classical image representations such as sparse wavelet representations. This feature enables image compression by storing the coefficients of the network after its weights are optimized to fit a single image. In Section 2, we demonstrate that the compression is on-par with wavelet thresholding (Antonini et al., 1992), a strong baseline that underlies JPEG-2000. An additional benefit of underparameterization is that it provides a barrier to overfitting, which enables regularization of inverse problems.   \n• The network itself acts as a natural data model. Not only does the network require no training (just as the DIP Ulyanov et al. (2018)); it also does not critically rely on regularization, for example by early stopping (in contrast to the DIP). The property of not involving learning has at least two benefits: The same network and code is usable for a number of applications, and the method is not sensitive to a potential misfit of training and test data. The network does not use convolutions. Instead, the network does have pixelwise linear combinations of channels, and, just like in a convolutional neural network, the weights are shared among spatial positions. Nonetheless, these are not convolutions because they provide no spatial coupling between pixels, despite how pixelwise linear combinations are sometimes called ‘1x1 convolutions.’ In contrast, the majority of the networks for image compression, restoration, and recovery have convolutional layers with filters of nontrivial spatial extent Toderici et al. (2016); Agustsson et al. (2017); Theis et al. (2017); Burger et al. (2012); Zhang et al. (2017). This work shows that relationships characteristic of nearby pixels of natural images can be imposed directly by upsampling layers. The network only consists of a simple combination of few building blocks, which makes it amenable to analysis and theory. For example, we prove that the deep decoder can only fit a small proportion of noise, which, combined with the empirical observation that it can represent natural images well, explains its denoising performance. ",
+        "bbox": [
+            214,
+            443,
+            825,
+            839
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The remainder of the paper is organized as follows. In Section 2, we first demonstrate that the deep decoder enables concise image representations. We formally introduce the deep decoder in Section 3. In Section 4, we show the performance of the deep decoder on a number of inverse problems such as denoising. In Section 5 we discuss related work, and finally, in Section 6 we provide theory and explanations on what makes the deep decoder work. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, a model describes a class of signals well if it is able to represent or approximate a member of the class with few parameters. In this section, we demonstrate that the deep decoder, an untrained, non-convolutional neural network, defined in the next section, enables concise representation of an image—on par with state of the art wavelet thresholding. ",
+        "bbox": [
+            174,
+            133,
+            823,
+            189
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The deep decoder is a deep image model $G \\colon \\mathbb { R } ^ { N } \\to \\mathbb { R } ^ { n }$ , where $N$ is the number of parameters of the model, and $n$ is the output dimension, which is (much) larger than the number of parameters $( n \\gg N )$ . The parameters of the model, which we denote by $\\mathbf { C }$ , are the weights of the network, and not the input of the network, which we will keep fixed. To demonstrate that the deep decoder enables concise image representations, we choose the number of parameters of the deep decoder, $N$ , such that it is a small fraction of the output dimension of the deep decoder, i.e., the dimension of the images1. ",
+        "bbox": [
+            173,
+            195,
+            825,
+            295
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We draw 100 images from the ImageNet validation set uniformly at random and crop the center to obtain a 512x512 pixel color image. For each image $\\mathbf { x } ^ { * }$ , we fit a deep decoder model $G ( \\mathbf { C } )$ by minimizing the loss ",
+        "bbox": [
+            174,
+            301,
+            825,
+            343
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bd2dbf6c7c67749a9ce4426632b0745ee7c1428f80f9c44bc01c54d90d49ea50.jpg",
+        "text": "$$\nL ( \\mathbf { C } ) = \\left. G ( \\mathbf { C } ) - \\mathbf { x } ^ { * } \\right. _ { 2 } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            342,
+            581,
+            362
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "with respect to the network parameters $\\mathbf { C }$ using the Adam optimizer. We then compute for each image the corresponding peak-signal-to-noise ratio, defined as $1 0 \\log _ { 1 0 } ( 1 / \\mathrm { M S E } )$ , where ${ \\mathrm { M S E } } =$ $\\begin{array} { r } { \\frac { 1 } { 3 \\cdot 5 1 2 ^ { 2 } } \\| \\mathbf { x } ^ { * } - G ( \\mathbf { C } ) \\| _ { 2 } ^ { 2 } } \\end{array}$ , $G ( \\mathbf { C } )$ is the image generated by the network, and $\\mathbf { x } ^ { * }$ is the original image. ",
+        "bbox": [
+            174,
+            366,
+            825,
+            411
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We compare the compression performance to wavelet compression (Antonini et al., 1992) by representing each image with the $N$ -largest wavelet coefficients. Wavelets—which underly JPEG 2000, a standard for image compression—are one of the best methods to approximate images with few coefficients. In Fig. 1 we depict the results. It can be seen that for large compression factors $( 3 \\cdot 5 1 2 ^ { 2 } / N = 3 \\bar { 2 . } 3 )$ , the representation by the deep decoder is slightly better for most images (i.e., is above the red line), while for smalle compression factors $( 3 \\cdot 5 \\bar { 1 } 2 ^ { 2 } \\bar { / } N = 8 )$ , the wavelet representation is slightly better. This experiment shows that deep neural networks can represent natural images well with very few parameters and without any learning. ",
+        "bbox": [
+            173,
+            416,
+            825,
+            529
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The observation that, for small compression factors, wavelets enable more concise representations than the deep decoder is intuitive because any image can be represented exactly with sufficiently many wavelet coefficients. In contrast, there is no reason to believe a priori that the deep decoder has zero representation error because it is underparameterized. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            590
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The main point of this experiment is to demonstrate that the deep decoder is a good image model, which enables applications like solving inverse problems, as in Section 4. However, it also suggest that the deep decoder can be used for lossy image compression, by quantizing the coefficients $\\mathbf { C }$ and saving the quantized coefficients. In the appendix, we show that image representations of the deep decoder are not sensitive to perturbations of its coefficients, thus quantization does not have a detrimental effect on the image quality. Deep networks were used successfully before for the compression of images (Toderici et al., 2016; Agustsson et al., 2017; Theis et al., 2017). In contrast to our work, which is capable of compressing images without any learning, the aforementioned works learn an encoder and decoder using convolutional recurrent neural networks (Toderici et al., 2016) and convolutional autoencoders (Theis et al., 2017) based on training data. ",
+        "bbox": [
+            174,
+            598,
+            825,
+            737
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 THE DEEP DECODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            757,
+            375,
+            773
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider a decoder architecture that transforms a randomly chosen and fixed tensor ${ \\bf B } _ { 0 } \\in  { }$ $\\mathbb { R } ^ { n _ { 0 } \\times k _ { 0 } }$ consisting of $k _ { 0 }$ many $n _ { 0 }$ -dimensional channels to an $n _ { d } \\times k _ { \\mathrm { o u t } }$ dimensional image, where $k _ { \\mathrm { o u t } } ~ = ~ 1$ for a grayscale image, and $k _ { \\mathrm { o u t } } ~ = ~ 3$ for an RGB image with three color channels. Throughout, $n _ { i }$ has two dimensions; for example our default configuration has $n _ { 0 } = 1 6 \\times 1 6$ and $n _ { d } = 5 1 2 \\times 5 1 2$ . The network transforms the tensor $\\mathbf { B } _ { 0 }$ to an image by pixel-wise linearly combining the channels, upsampling operations, applying rectified linear units (ReLUs), and normalizing the channels. Specifically, the channels in the $( i + 1 )$ -th layer are given by ",
+        "bbox": [
+            173,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/98388eb9d0ef06f5d253a49bfb2c967f9ed9de65da5b600cdb06c19e7b55bc38.jpg",
+        "image_caption": [
+            "Figure 1: The deep decoder (depicted on the right) enables concise image representations, onpar with state-of-the-art wavelet based compression. The crosses on the left depict the PSNRs for 100 randomly chosen ImageNet-images represented with few wavelet coefficients and with a deep decoder with an equal number of parameters. A cross above the red line means the corresponding image has a smaller representation error when represented with the deep decoder. The deep decoder is particularly simple, as each layer has the same structure, consisting of a pixel-wise linear combination of channels, upsampling, ReLU nonlinearities, and channelwise normalization (CN). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            98,
+            816,
+            268
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            396,
+            661,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e7ba46da0fb7621080773b61903a3017817381da99bf3bba240d0bd97c6eb415.jpg",
+        "text": "$$\n\\mathbf { B } _ { i + 1 } = \\operatorname { c n } ( \\operatorname { r e l u } ( \\mathbf { U } _ { i } \\mathbf { B } _ { i } \\mathbf { C } _ { i } ) ) , \\quad i = 0 , \\dots , d - 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            415,
+            656,
+            431
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, the coefficient matrices $\\mathbf { C } _ { i } \\in \\mathbb { R } ^ { k _ { i } \\times k _ { i + 1 } }$ contain the weights of the network. Each column of the tensor $\\mathbf { B } _ { i } \\mathbf { C } _ { i } \\in \\mathbb { R } ^ { n _ { i } \\times k _ { i + 1 } }$ is formed by taking linear combinations of the channels of the tensor $\\mathbf { B } _ { i }$ in a way that is consistent across all pixels. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            477
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Then, $\\mathrm { c n } ( \\cdot )$ performs a channel normalization operation which is equivalent to normalizing each channel individually, and can be viewed as a special case of the popular batch normalization proposed in (Ioffe & Szegedy, 2015). Specifically, let ${ \\bf Z } _ { i } = \\mathrm { r e l u } ( { \\bf U } _ { i } { \\bf \\bar { B } } _ { i } { \\bf \\bar { C } } _ { i } )$ be the channels in the $i$ -th layer, and let $\\mathbf { z } _ { i j }$ be the $j$ -th channel in the $i$ -th layer. Then channel normalization performs the following transformation: $\\begin{array} { r } { \\mathbf { z } _ { i j } ^ { \\prime } = \\frac { \\mathbf { z } _ { i j } - \\mathrm { m e a n } ( \\mathbf { z } _ { i j } ) } { \\sqrt { \\mathrm { v a r } ( \\mathbf { z } _ { i j } ) + \\epsilon } } \\gamma _ { i j } + \\beta _ { i j } } \\end{array}$ , where mean and var compute the empirical mean and variance, and $\\gamma _ { i j }$ and $\\beta _ { i j }$ are parameters, learned independently for each channel, and $\\epsilon$ is a fixed small constant. Learning the parameter $\\gamma$ and $\\beta$ helps the optimization but is not critical. This is a special case of batch normalization with batch size one proposed in (Ioffe & Szegedy, 2015), and significantly improves the fitting of the model, just like how batch norm alleviates problems encountered when training deep neural networks. ",
+        "bbox": [
+            173,
+            482,
+            825,
+            633
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The operator $\\mathbf { U } _ { i } \\in \\mathbb { R } ^ { n _ { i + 1 } \\times n _ { i } }$ is an upsampling tensor, which we choose throughout so that it performs bi-linear upsampling. For example, if the channels in the input have dimensions $n _ { 0 } = 1 6 \\times 1 6$ , then the upsampling operator $\\mathbf { U } _ { 0 }$ upsamples each channel to dimensions $3 2 \\times 3 2$ . In the last layer, we do not upsample, which is to say that we choose the corresponding upsampling operator as the identity. Finally, the output of the $d$ -layer network is formed as ",
+        "bbox": [
+            173,
+            640,
+            825,
+            710
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/38bf8ba5c535fb5af080ddcc7d9fda9703348450d3df0e5c635143baec642bff.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { x } = \\mathrm { s i g m o i d } ( \\mathbf { B } _ { d } \\mathbf { C } _ { d } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            424,
+            713,
+            571,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { C } _ { d } ~ \\in ~ \\mathbb { R } ^ { k _ { d } \\times k _ { \\mathrm { o u t } } }$ . See Fig. 1 for an illustration. Throughout, our default architecture is a $d = 6$ layer network with $k _ { i } = k$ for all $i$ , and we focus on output images of dimensions $n _ { d } =$ $5 1 2 \\times 5 1 2$ and number of channels $k _ { \\mathrm { o u t } } = 3$ . Recall that the parameters of the network are given by $\\mathbf { C } = \\{ \\mathbf { C } _ { 0 } , \\mathbf { C } _ { 1 } , \\hdots , \\mathbf { C } _ { d } \\}$ , and the output of the network is only a function of $\\mathbf { C }$ , since we choose the tensor $\\mathbf { B } _ { 0 }$ at random and fix it. Therefore, we write $\\mathbf { x } = G ( \\mathbf { C } )$ . Note that the number of parameters is given by $\\begin{array} { r } { N = \\sum _ { i = 1 } ^ { d } ( k _ { i } k _ { i + 1 } + 2 k _ { i } ) + k _ { \\mathrm { o u t } } k _ { d } } \\end{array}$ where the term $2 k _ { i }$ corresponds to the two free parameters associated with the channel normalization. Thus, the number of parameters is $N = d k ^ { 2 } + 2 d k + 3 k$ . In the default architectures with $d = 6$ and $k = 6 4$ or $k = 1 2 8$ , we have that $N = 2 5 { , } 5 3 6$ (for $k = 6 4$ ) and $N = 1 0 0 { , } 2 2 4$ $k = 1 2 8 ,$ ) out of an RGB image space of dimensionality $5 1 2 \\times 5 1 2 \\times 3 = 7 8 6 { , } 4 3 2$ parameters. ",
+        "bbox": [
+            173,
+            732,
+            825,
+            876
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We finally note that naturally variations of the deep decoder are possible; for example in a previous version of this manuscript, we applied upsampling after applying the relu-nonlinearity, but found that applying it before yields slightly better results. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 A NON-CONVOLUTIONAL NETWORK? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            472,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While the deep decoder does not use convolutions, its structure is closely related to that of a convolutional neural network. Specifically, the network does have pixelwise linear combinations of channels, and just like in a convolutional neural network, the weights are shared among spatial positions. Nonetheless, pixelwise linear combinations are not proper convolutions because they provide no spatial coupling of pixels, despite how they are sometimes called $1 \\times 1$ convolutions. In the deep decoder, the source of spatial coupling is only from upsampling operations. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            213
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In contrast, a large number of networks for image compression, restoration, and recovery have convolutional layers with filters of nontrivial spatial extent Toderici et al. (2016); Agustsson et al. (2017); Theis et al. (2017); Burger et al. (2012); Zhang et al. (2017). Thus, it is natural to ask whether using linear combinations as we do, instead of actual convolutions yields better results. ",
+        "bbox": [
+            174,
+            219,
+            825,
+            276
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our simulations indicate that, indeed, linear combinations yield more concise representations of natural images than $p \\times p$ convolutions, albeit not by a huge factor. Recall that the number of parameters of the deep decoder with $d$ layers, $k$ channels at each layer, and $1 \\times 1$ convolutions is ${ \\bf { \\dot { \\cal { N } } } } ( d , k ; 1 ) = d k ^ { 2 } + 3 { \\bf { \\dot { k } } } + 2 d k$ . If we consider a deep decoder with convolutional layers with filters of size $p \\times p$ , then the number of parameters is: ${ \\hat { N ( d , k ; p ) } } = p ^ { 2 } ( d k ^ { 2 } + 3 k ) + 2 { \\dot { d k } }$ . If we fix the number of channels, $k$ , but increase $p$ to 3, the representation error only decreases since we increase the number of parameters (by a factor of approximately $3 ^ { 2 }$ ). We consider image reconstruction as described in Section 2. For a meaningful comparison, we keep the number of parameters fixed, and compare the representation error of a deep decoder with $p = 1$ and $k = 6 4$ (the default architecture in our paper) to a variant of the deep decoder with $p = 3$ and $k = 2 2$ , so that the number of parameters is essentially the same in both configurations. We find that the representation of the deep decoder with $p = 1$ is better (by about 1dB, depending on the image), and thus for concise image representations, linear combinations $\\smash { \\mathrm { ~ \\ . ~ } } ^ { \\mathrm { ~ T ~ } \\times 1 }$ convolutions) appear to be more effective than convolutions of larger spatial extent. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            477
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 SOLVING INVERSE PROBLEMS WITH THE DEEP DECODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            498,
+            679,
+            513
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we use the deep decoder as a structure-enforcing model or regularizers for solving standard inverse problems: denoising, super-resolution, and inpainting. In all of those inverse problems, the goal is to recover an image $\\mathbf { x }$ from a noisy observation $\\mathbf { y } = f ( \\mathbf { x } ) + \\boldsymbol { \\eta }$ . Here, $f$ is a known forward operator (possibly equal to identity), and $\\eta$ is structured or unstructured noise. ",
+        "bbox": [
+            174,
+            529,
+            823,
+            585
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We recover the image $\\mathbf { x }$ with the deep decoder as follows. Motivated by the finding from the previous section that a natural image $\\mathbf { x }$ can (approximately) be represented with the deep decoder as $G ( \\mathbf { C } )$ , we estimate the unknown image from the noisy observation $\\mathbf { y }$ by minimizing the loss ",
+        "bbox": [
+            174,
+            592,
+            825,
+            633
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c1ede005a852ed2e6db1f68282d9e366dbf7f98a6ca3987dbfbdf2263a0bbaf4.jpg",
+        "text": "$$\nL ( \\mathbf { C } ) = \\left\\| f ( G ( \\mathbf { C } ) ) - \\mathbf { y } \\right\\| _ { 2 } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            640,
+            588,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "with respect to the model parameters $\\mathbf { C }$ . Let $\\hat { \\mathbf { C } }$ be the result of the optimization procedure. We estimate the image as $\\hat { \\mathbf { x } } = G ( \\hat { \\mathbf { C } } )$ . ",
+        "bbox": [
+            176,
+            667,
+            823,
+            699
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use the Adam optimizer for minimizing the loss, but have obtained comparable results with gradient descent. Note that this optimization problem is non-convex and we might not reach a global minimum. Throughout, we consider the least-squares loss (i.e., we take $\\lVert \\cdot \\rVert _ { 2 }$ to be the $\\ell _ { 2 }$ norm), but the loss function can be adapted to account for structure of the noise. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            762
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We remark that fitting an image model to observations in order to solve an inverse problem is a standard approach and is not specific to the deep decoder or deep-network-based models in general. Specifically, a number of classical signal recovery approaches fit into this framework; for example solving a compressive sensing problem with $\\ell _ { 1 }$ -norm minimization amounts to choosing the forward operator as $f ( \\mathbf { x } ) = \\mathbf { A x }$ and minimizing over $\\mathbf { x }$ in a $\\ell _ { 1 }$ -norm ball. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            839
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DENOISING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            856,
+            295,
+            869
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We start with the perhaps most basic inverse problem, denoising. The motivation to study denoising is at least threefold: First, denoising is an important problem in practice, second, many inverse problem can be solved as a chain of denoising steps (Romano et al., 2017), and third, the denoising problem is simple to model mathematically, and thus a common entry point for gaining intuition on a new method. Given a noisy observation $\\mathbf { y } = \\mathbf { x } + \\boldsymbol { \\eta }$ , where $\\eta$ is additive noise, we estimate an image with the deep decoder by minimizing the least squares loss $\\left\\| G ( \\mathbf { C } ) - \\mathbf { y } \\right\\| _ { 2 } ^ { 2 }$ , as described above. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/eb1e4e815d13625808a98154f04edd3a269aa5182c562ab6954b435e5694e6f0.jpg",
+        "image_caption": [
+            "Figure 2: An application of the deep decoder for denoising the astronaut test image. The deep decoder has performance on-par with state of the art untrained denoising methods, such as the DIP method (Ulyanov et al., 2018) and the BM3D algorithm (Dabov et al., 2007). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            108,
+            810,
+            234
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            310,
+            825,
+            368
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The results in Fig. 2 and Table 1 demonstrate that the deep decoder has denoising performance onpar with state of the art untrained denoising methods, such as the related Deep Image Prior (DIP) method (Ulyanov et al., 2018) (discussed in more detail later) and the BM3D algorithm (Dabov et al., 2007). Since the deep decoder is an untrained method, we only compared to other state-of-the-art untrained methods (as opposed to learned methods such as (Zhang et al., 2017)). ",
+        "bbox": [
+            174,
+            376,
+            825,
+            445
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Why does the deep decoder denoise well? In a nutshell, from Section 2 we know that the deep decoder can represent natural images well even when highly underparametrized. In addition, as a consequence of being under-parameterized, the deep decoder can only represent a small proportion of the noise, as we show analytically in Section 6, and as demonstrated experimentally in Fig. 4. Thus, the deep decoder “filters out” a significant proportion of the noise, and retains most of the signal. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            536
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "How to choose the parameters of the deep decoder? The larger $k$ , the larger the number of latent parameters and thus the smaller the representation error, i.e., the error that the deep decoder makes when representing a noise-free image. On the other hand, the smaller $k$ , the fewer parameters, and the smaller the range space of the deep decoder $G ( \\mathbf { C } )$ , and thus the more noise the method will remove. The optimal $k$ trades off those two errors; larger noise levels require smaller values of $k$ (or some other form of regularization). If the noise is significantly larger, then the method requires either choosing $k$ smaller, or it requires another means of regularization, for example early stopping of the optimization. For example $k = 6 4$ or 128 performs best out of $\\{ 3 2 , 6 4 , 1 2 8 \\}$ , for a PSNR of around 20dB, while for a PSNR of about 14dB, $k = 3 2$ performs best. ",
+        "bbox": [
+            173,
+            542,
+            825,
+            667
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 SUPERRESOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            685,
+            349,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We next super-resolve images with the deep denoiser. We define a forward model $f$ that performs downsampling with the Lanczos filter by a factor of four. We then downsample a given image by a factor of four, and then reconstruct it with the deep decoder (with $k = 1 2 8$ , as before). We compare performance to bi-cubic interpolation and to the deep image prior, and find that the deep decoder outperforms bicubic interpolation, and is on-par with the deep image prior (see Table 1 in the appendix). ",
+        "bbox": [
+            174,
+            712,
+            825,
+            795
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 INPAINTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            814,
+            297,
+            828
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, we use the deep decoder for inpainting, where we are given an inpainted image $\\mathbf { y }$ , and a forward model $f$ mapping a clean image to an inpainted image. The forward model $f$ is defined by a mask that describes the inpainted region, and simply maps that part of the image to zero. Fig. 3 and Table 1 demonstrate that the deep decoder performs well on the inpainting problems; however, the deep image prior performs slightly better on average over the examples considered. For the impainting problem we choose a significantly more expressive prior, specifically $k = 3 2 0$ . ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/c836519214a72355970314dd98d20329fb961a66184b5085c75d50d9e0a9adf1.jpg",
+        "image_caption": [
+            "Figure 3: An application of the deep decoder for recovering an inpainted image. For this example, the deep decoder and the deep image perform almost equally well. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            107,
+            764,
+            237
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            295,
+            341,
+            310
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Image compression, restoration, and recovery algorithms are either trained or untrained. Conceptually, the deep decoder image model is most related to untrained methods, such as sparse representations in overcomplete dictionaries (for example wavelets (Donoho, 1995) and curvelets (Starck et al., 2002)). A number of highly successful image restoration and recovery schemes are not directly based on generative image models, but rely on structural assumptions about the image, such as exploiting self-similarity in images for denoising (Dabov et al., 2007) and super-resolution (Glasner et al., 2009). ",
+        "bbox": [
+            173,
+            327,
+            825,
+            424
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Since the deep decoder is an image-generating deep network, it is also related to methods that rely on trained deep image models. Deep learning based methods are either trained end-to-end for tasks ranging from compression (Toderici et al., 2016; Agustsson et al., 2017; Theis et al., 2017; Burger et al., 2012; Zhang et al., 2017) to denoising (Burger et al., 2012; Zhang et al., 2017), or are based on learning a generative image model (by training an autoencoder or GAN (Hinton & Salakhutdinov, 2006; Goodfellow et al., 2014)) and then using the resulting model to solve inverse problems such as compressed sensing (Bora et al., 2017; Hand & Voroninski, 2018), denoising (Heckel et al., 2018), phase retrieval (Hand et al., 2018; Shamshad & Ahmed, 2018), and blind deconvolution (Asim et al., 2018), by minimizing an associated loss. In contrast to the deep decoder, where the optimization is over the weights of the network, in all the aforementioned methods, the weights are adjusted only during training and then are fixed upon solving the inverse problem. ",
+        "bbox": [
+            173,
+            431,
+            825,
+            584
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Most related to our work is the Deep Image Prior (DIP), recently proposed by Ulyanov et al. (Ulyanov et al., 2018). The deep image prior is an untrained method that uses a network with an hourglass or encoder-decoder architecture, similar to the U-net and related architectures that work well as autoencoders. The key differences to the deep decoder are threefold: i) the DIP is over-parameterized, whereas the deep decoder is under-parameterized. ii) Since the DIP is highly over-parameterized, it critically relies on regularization through early stopping and adding noise to its input, whereas the deep decoder does not need to be regularized (however, regularization can enhance performance). iii) The DIP is a convolutional neural network, whereas the deep decoder is not. ",
+        "bbox": [
+            173,
+            590,
+            825,
+            715
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We further illustrate point ii) comparing the DIP and deep decoder by denoising the astronaut image from Fig. 2. In Fig. 4(a) we plot the Mean Squared Error (MSE) over the number of iterations of the optimizer for fitting the noisy astronaut image $\\mathbf { x } + \\boldsymbol { \\eta }$ . Note that to fit the model, we minimize the error $\\| G ( \\mathbf { C } ) - ( \\mathbf { x } + \\pmb { \\eta } ) \\| _ { 2 } ^ { 2 }$ , because we are only given the noisy image, but we plot the MSE between the representation and the actual, true image $\\left\\| G ( \\mathbf { C } ^ { t } ) - \\mathbf { x } \\right\\| _ { 2 } ^ { 2 }$ at iteration $t$ . Here, $\\mathbf { C } ^ { t }$ are the parameters of the deep decoder after $t$ iterations of the optimizer. In Fig. 4(b) and (c), we plot the loss or MSE associated with fitting the noiseless astronaut image, x $( \\left\\| \\boldsymbol { G } ( \\mathbf { C } ^ { t } ) - \\mathbf { x } \\right\\| _ { 2 } ^ { 2 } )$ and the noise itself, $\\eta$ , $( \\left\\| \\boldsymbol G ( \\mathbf C ^ { t } ) - \\boldsymbol \\eta \\right\\| _ { 2 } ^ { 2 } )$ . Models are fitted independently for the noisy image, the noiseless image, and the noise. ",
+        "bbox": [
+            173,
+            723,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The plots in Fig. 4 show that with sufficiently many iterations, both the DIP and the DD can fit the image well. However, even with a large number of iterations, the deep decoder can not fit the noise well, whereas the DIP can. This is not surprising, given that the DIP is over-parameterized and the deep decoder is under-parameterized. In fact, in Section 6 we formally show that due to the underparameterization, the deep decoder can only fit a small proportion of the noise, no matter how and how long we optimize. As a consequence, it filters out much of the noise when applied to a natural image. In contrast, the DIP relies on the empirical observation that the DIP fits a structured image faster than it fits noise, and thus critically relies on early stopping. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b4e3ef1a6e49f8715c4b4d1235107ae96448cb82b08450cb3fbabcb8ace80ab8.jpg",
+        "image_caption": [
+            "Figure 4: Denoising with the deep decoder and the deep image prior. The first two panels shows the MSE of the output of the DD or DIP for a noisy or noiseless image relative to the noiseless image. The third panel shows the MSE of the output of DD or DIP for an image consisting purely of noise, as computed relative to that noise. Due to under-parameterization, the deep decoder can only fit a small proportion of the noise, and thus enables image denoising. Early stopping can mildly enhance the performance of DD; to see this note that in panel (a), the minimum is obtained at around 5000 iterations and not at 50,000. The deep image prior can fit noise very well, but fits an image faster than noise, thus early stopping is critical for denoising performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            227,
+            99,
+            777,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            414,
+            825,
+            469
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION ON WHAT MAKES THE DECODER WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            483,
+            638,
+            498
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the previous sections we empirically showed that the deep decoder can represent images well and at the same time cannot fit noise well. In this section, we formally show that the deep decoder can only fit a small proportion of the noise, relative to the degree of underparameterization. In addition, we provide insights into how the components of the deep decoder contribute to representing natural images well, and we provide empirical observations on the sensitivity of the parameters and their distribution. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            590
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.1 THE DEEP DECODER CAN ONLY FIT LITTLE NOISE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            606,
+            558,
+            619
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We start by showing that an under-parameterized deep decoder can only fit a proportion of the noise relative to the degree of underparameterization. At the heart of our argument is the intuition that a method mapping from a low- to a high-dimensional space can only fit a proportion of the noise relative to the number of free parameters. For simplicity, we consider a one-layer network, and ignore the batch normalization operation. Then, the networks output is given by ",
+        "bbox": [
+            173,
+            631,
+            825,
+            702
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d3b5d9d6c6f43dbba32e79f1e32925ff74de2890bf95eb1d74c12aa9f563a785.jpg",
+        "text": "$$\nG ( \\mathbf { C } ) = \\operatorname { r e l u } ( \\mathbf { U } _ { 0 } \\mathbf { B } _ { 0 } \\mathbf { C } _ { 0 } ) \\mathbf { c } _ { 1 } \\in \\mathbb { R } ^ { n } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            704,
+            611,
+            722
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Here, we take $\\mathbf { C } = ( \\mathbf { C } _ { 0 } , \\mathbf { c } _ { 1 } )$ , where $\\mathbf { C } _ { 0 }$ is a $k \\times k$ matrix and $\\mathbf { c } _ { 1 }$ is a $k$ -dimensional vector, assuming that the number of output channels is 1. While for the performance of the deep decoder the choice of upsampling matrix is important, it is not relevant for showing that the deep decoder cannot represent noise well. Therefore, the following statement makes no assumptions about the upsampling matrix $\\mathbf { U } _ { 0 }$ . ",
+        "bbox": [
+            173,
+            724,
+            825,
+            795
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1. Consider a deep decoder with one layer and arbitrary upsampling and input matrices. That is, let $\\mathbf { B } _ { 0 } \\in \\mathbb { R } ^ { n _ { 0 } \\times k }$ and $\\mathbf { U } _ { 0 } \\in \\mathbb { R } ^ { n \\times n _ { 0 } }$ . Let $\\eta \\in \\mathbb { R } ^ { n }$ be zero-mean Gaussian noise with covariance matrix σI, $\\sigma > 0$ . Assume that $k ^ { 2 } \\log ( n _ { 0 } ) / n \\leq 1 / 3 2$ . Then, with probability at least $1 - 2 { n _ { 0 } } ^ { - k ^ { 2 } }$ ",
+        "bbox": [
+            173,
+            796,
+            825,
+            854
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e114ca800486752b4c35c4a62be52c82313deada213f50c0c63b27f0ffca9050.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\mathbf { C } } \\left\\| { G ( \\mathbf { C } ) - \\eta } \\right\\| _ { 2 } ^ { 2 } \\geq \\left\\| \\eta \\right\\| _ { 2 } ^ { 2 } \\left( 1 - 2 0 \\frac { k ^ { 2 } \\log ( n _ { 0 } ) } { n } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            853,
+            665,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The proposition asserts that the deep decoder can only fit a small portion of the noise energy, precisely a proportion determined by its number of parameters relative to the output dimension, $n$ . Our simulations and preliminary analytic results suggest that this statement extends to multiple layers in that the lower bound becomes \u00101 − c k2 log(Qdi=1 ni−1)n \u0011 , where $c$ is a numerical constant. Note that the lower bound does not directly depend on the noise variance $\\sigma$ since both sides of the inequality scale with $\\sigma ^ { 2 }$ . ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/910ad77a0e68cff5d46dbe68489dc23d1136d095583796613342adbc30e026c4.jpg",
+        "image_caption": [
+            "Figure 5: The blue curves show a one-dimensional piecewise smooth signal, and the red crosses show estimates of this signal by a one-dimensional deep decoder with either linear or convex upsampling. We see that linear upsampling acts as an indirect signal prior that promotes piecewise smoothness. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            98,
+            779,
+            207
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            292,
+            825,
+            358
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.2 UPSAMPLING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            375,
+            308,
+            388
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Upsampling is a vital part of the deep decoder because it is the only way that the notion of locality explicitly enters the signal model. In contrast, most convolutional neural networks have spatial coupling between pixels both by unlearned upsampling, but also by learned convolutional filters of nontrivial spatial extent. The choice of the upsampling method in the deep decoder strongly affects the ‘character’ of the resulting signal estimates. We now discuss the impacts of a few choices of upsampling matrices $\\mathbf { U } _ { i }$ , and their impact on the images the model can fit. ",
+        "bbox": [
+            173,
+            400,
+            825,
+            484
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "No upsampling: If there is no upsampling, or, equivalently, if $\\mathbf { U } _ { i } = \\mathbf { I }$ , then there is no notion of locality in the resulting image. All pixels become decoupled, and there is then no notion of which pixels are near to each other. Specifically, a permutation of the input pixels (the rows of $\\mathbf { B } _ { 0 }$ ) simply induces the identical permutation of the output pixels. Thus, if a deep decoder without upsampling could fit a given image, it would also be able to fit random permutations of the image equally well, which is practically equivalent to fitting random noise. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            574
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nearest neighbor upsampling: If the upsampling operations perform nearest neighbor upsampling, then the output of the deep decoder consists of piecewise constant patches. If the upsampling doubles the image dimensions at each layer, this would result in patches of $2 ^ { d } \\times 2 ^ { d }$ pixels that are constant. While this upsampling method does induce a notion of locality, it does so too strongly in the sense that squares of nearby pixels become identical and incapable of fitting local variation within natural images. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Linear and convex, non-linear upsampling: The specific choice of upsampling matrix affects the multiscale ‘character’ of the signal estimates. To illustrate this, Figure 5 shows the signal estimate from a 1-dimensional deep decoder with upsampling operations given by linear upsampling $( x _ { 0 } , x _ { 1 } , x _ { 2 } , \\ldots ) \\mapsto ( x _ { 0 } , 0 . 5 x _ { 0 } + 0 . 5 x _ { 1 } , x _ { 1 } , 0 . 5 x _ { 1 } + 0 . 5 x _ { 2 } , x _ { 2 } , \\ldots )$ and convex nonlinear upsampling given by $( x _ { 0 } , x _ { 1 } , x _ { 2 } , \\ldots ) \\mapsto ( x _ { 0 } , 0 . 7 5 x _ { 0 } + 0 . 2 5 x _ { 1 } , x _ { 1 } , 0 .$ .75x1 + 0.25x2, x2, . . .). Note that while both models are able to capture the coarse signal structure, the convex upsampling results in a multiscale fractal-like structure that impedes signal representation. In contrast, linear upsampling is better able to represent smoothly varying portions of the signal. Linear upsampling in a deep decoder indirectly encodes the prior that natural signals are piecewise smooth and in some sense have approximately linear behavior at multiple scales ",
+        "bbox": [
+            173,
+            671,
+            825,
+            810
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.3 NETWORK INPUT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            334,
+            842
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Throughout, the network input is fixed. We choose the network input $\\mathbf { B } _ { 1 }$ by choosing its entries uniformly at random. The particular choice of the input is not very important; it is however desirable that the rows are incoherent. To see this, as an extreme case, if any two rows of $\\mathbf { B } _ { 1 }$ are equal and if the upsampling operation preserves the values of those pixels exactly (for example, as with the linear upsampling from the previous section), then the corresponding pixels of the output image is also exactly the same, which restricts the range space of the deep decoder unrealistically, since for any pair of pixels, the majority of natural images does not have exactly the same value at this pair of pixels. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/556c00a166d94a9d51ab568d756758de3ea019b79bd82556d45cce65705b59d0.jpg",
+        "image_caption": [
+            "Figure 6: The left panel shows an image reconstruction after training a deep decoder on the MRI phantom image (PSNR is 51dB). The right panel shows how the deep decoder builds up an image starting from a random input. From top to bottom are the input to the network and the activation maps (i.e., $\\operatorname { r e l u } ( \\mathbf { B } _ { i } \\mathbf { C } _ { i } ) ) ,$ ) for eight out of the 64 channels in layers one to six. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            289,
+            112,
+            794,
+            281
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/53793025f52548adf031edbe1939d155ad21d62979c30bfd5a9a26dcc7be6c44.jpg",
+        "table_caption": [
+            "Table 1: Performance comparison of the deep decoder for denoising (DN), superresolution (SR), and inpainting (IP), in peak signal to noise ratio (PSNR). Note that identity corresponds to the PSNR of the noise and corruption in the DN and IP experiments, respectively. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td>barbara</td><td>lovett</td><td>mri</td><td>zebra</td><td>F16</td><td>baboon</td><td>fruit</td><td>astronaut</td><td>castle</td><td>saturn</td></tr><tr><td rowspan=\"4\">DN</td><td>identity</td><td>20.3</td><td>20.9</td><td>22.1</td><td>21.3</td><td>20.3</td><td>20.3</td><td>20.5</td><td>20.6</td><td>20.4</td><td>20.2</td></tr><tr><td>DD128</td><td>26.8</td><td>27.9</td><td>26.9</td><td>22.5</td><td>29.1</td><td>21.4</td><td>29.2</td><td>29.8</td><td>27.7</td><td>29.0</td></tr><tr><td>DIP</td><td>24.4</td><td>25.3</td><td>26.6</td><td>24.8</td><td>25.0</td><td>22.8</td><td>25.7</td><td>26.1</td><td>25.0</td><td>25.0</td></tr><tr><td>BM3D</td><td>24.7</td><td>25.1</td><td>28.0</td><td>22.8</td><td>25.2</td><td>22.6</td><td>26.3</td><td>26.2</td><td>25.6</td><td>30.5</td></tr><tr><td rowspan=\"3\">SR</td><td>bicubic</td><td>26.3</td><td>26.0</td><td>24.5</td><td>18.2</td><td>26.4</td><td>20.7</td><td>27.1</td><td>29.3</td><td>25.8</td><td>27.9</td></tr><tr><td>DD128</td><td>26.4</td><td>26.3</td><td>26.4</td><td>19.0</td><td>26.6</td><td>20.6</td><td>28.6</td><td>30.2</td><td>26.1</td><td>27.8</td></tr><tr><td>DIP</td><td>26.4</td><td>26.6</td><td>25.6</td><td>19.2</td><td>27.4</td><td>20.6</td><td>28.3</td><td>29.6</td><td>26.0</td><td>27.9</td></tr><tr><td rowspan=\"3\">IP</td><td>identity</td><td>14.9</td><td>14.4</td><td>18.3</td><td>13.0</td><td>11.7</td><td>14.0</td><td>12.4</td><td>14.0</td><td>14.2</td><td>13.4</td></tr><tr><td>DD320</td><td>32.3</td><td>33.6</td><td>31.4</td><td>24.4</td><td>34.9</td><td>24.9</td><td>36.6</td><td>36.5</td><td>32.5</td><td>36.7</td></tr><tr><td>DIP</td><td>35.6</td><td>26.9</td><td>32.1</td><td>24.2</td><td>34.7</td><td>26.2</td><td>35.5</td><td>35.3</td><td>32.6</td><td>36.2</td></tr></table>",
+        "bbox": [
+            173,
+            377,
+            828,
+            526
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            606,
+            825,
+            648
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6.4 IMAGE GENERATION BY SUCCESSIVE APPROXIMATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            661,
+            591,
+            674
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The deep decoder is tasked with coverting multiple noise channels into a structured signal primarily using pixelwise linear combinations, ReLU activation funcions, and upsampling. Using these tools, the deep decoder builds up an image through a series of successive approximations that gradually morph between random noise and signal. To illustrate that, we plot the activation maps (i.e., $\\operatorname { r e l u } ( \\mathbf { B } _ { i } \\mathbf { C } _ { i } ) )$ of a deep decoder fitted to the phantom MRI test image (see Fig. 6). We choose a deep decoder with $d = 5$ layers and $k = 6 4$ channels. This image reconstruction approach is in contrast to being a semantically meaningful hierarchical representation (i.e., where edges get combined into corners, that get combined into simple sample, and then into more complicated shapes), similar to what is common in discriminative networks. ",
+        "bbox": [
+            174,
+            679,
+            825,
+            804
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            821,
+            326,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "RH is partially supported by NSF award IIS-1816986, an NVIDIA Academic GPU Grant, and would like to thank Ludwig Schmidt for helpful discussions on the deep decoder in general, and in particular for suggestions on the experiments in Section 2. ",
+        "bbox": [
+            176,
+            847,
+            823,
+            888
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Code to reproduce the results is available at https://github.com/reinhardh/ supplement_deep_decoder ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nE. Agustsson, F. Mentzer, M. Tschannen, L. Cavigelli, R. Timofte, L. Benini, and L. V. Gool. Softto-hard vector quantization for end-to-end learning compressible representations. In Advances in Neural Information Processing Systems, pp. 1141–1151, 2017.   \nM. Antonini, M. Barlaud, P. Mathieu, and I. Daubechies. Image coding using wavelet transform. IEEE Transactions on Image Processing, 1(2):205–220, 1992.   \nM. Asim, F. Shamshad, and A. Ahmed. Solving bilinear inverse problems using deep generative priors. arXiv preprint arXiv:1802.04073, 2018.   \nA. Bora, A. Jalal, E. Price, and A. G. Dimakis. Compressed sensing using generative models. In International Conference on Machine Learning, pp. 537–546, 2017.   \nH. C. Burger, C. J. Schuler, and S. Harmeling. Image denoising: Can plain neural networks compete with BM3d? In IEEE Conference on Computer Vision and Pattern Recognition, pp. 2392–2399, 2012.   \nK. Dabov, A. Foi, V. Katkovnik, and K. Egiazarian. Image denoising by sparse 3-D transformdomain collaborative filtering. IEEE Transactions on Image Processing, 16(8):2080–2095, 2007.   \nD. L. Donoho. De-noising by soft-thresholding. IEEE Transactions on Information Theory, 41(3): 613–627, 1995.   \nD. Glasner, S. Bagon, and M. Irani. Super-resolution from a single image. In IEEE International Conference on Computer Vision, pp. 349–356, 2009.   \nI. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems, pp. 2672–2680. 2014.   \nP. Hand and V. Voroninski. Global guarantees for enforcing deep generative priors by empirical risk. In Conference on Learning Theory, pp. 970–978, 2018.   \nP. Hand, O. Leong, and V. Voroninski. Phase retrieval under a generative prior. In Advances in Neural Information Processing, pp. 9136–9146, 2018.   \nR. Heckel, W. Huang, P. Hand, and V. Voroninski. Deep denoising: Rate-optimal recovery of structured signals with a deep prior. arXiv:1805.08855, 2018.   \nG. E. Hinton and R. R. Salakhutdinov. Reducing the dimensionality of data with neural networks. Science, 313(5786):504–507, 2006.   \nS. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015.   \nB. Laurent and P. Massart. Adaptive estimation of a quadratic functional by model selection. The Annals of Statistics, 28(5):1302–1338, 2000.   \nY. Romano, M. Elad, and P. Milanfar. The little engine that could: Regularization by denoising (red). SIAM Journal on Imaging Sciences, 10(4):18041844, 2017.   \nF. Shamshad and A. Ahmed. Robust compressive phase retrieval via deep generative priors. arXiv preprint arXiv:1808.05854, 2018.   \nJ.-L. Starck, E. J. Candes, and D. L. Donoho. The curvelet transform for image denoising. IEEE Transactions on Image Processing, 11(6):670–684, 2002.   \nL. Theis, W. Shi, A. Cunningham, and F. Huszar. Lossy image compression with compressive ´ autoencoders. In International Conference on Learning Representations, 2017.   \nG. Toderici, S. M. OMalley, S. J. Hwang, D. Vincent, D. Minnen, S. Baluja, M. Covell, and R. Sukthankar. Variable rate image compression with recurrent neural networks. In International Conference on Learning Representations, 2016.   \nD. Ulyanov, A. Vedaldi, and V. Lempitsky. Deep image prior. In Conference on Computer Vision and Pattern Recognition, 2018.   \nR. O. Winder. Partitions of n-space by hyperplanes. SIAM Journal on Applied Mathematics, 14(4): 811–818, 1966.   \nK. Zhang, W. Zuo, Y. Chen, D. Meng, and L. Zhang. Beyond a Gaussian denoiser: Residual learning of deep CNN for image denoising. IEEE Transactions on Image Processing, 26(7):3142–3155, 2017. ",
+        "bbox": [
+            169,
+            97,
+            828,
+            926
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            826,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            264,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A PROOF OF PROPOSITION 1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            426,
+            151
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Suppose that the network has one layer, i.e., $G ( { \\bf C } ) = \\mathrm { r e l u } ( { \\bf U } _ { 0 } { \\bf B } _ { 0 } { \\bf C } _ { 0 } ) { \\bf c } _ { 1 }$ . We start by re-writing ${ \\bf B } _ { 1 } = \\mathrm { r e l u } ( { \\bf B } _ { 0 } { \\bf C } _ { 0 } )$ in a convenient form. For a given vector $\\mathbf { x } \\in \\mathbb { R } ^ { n }$ , denote by $\\mathrm { d i a g } ( \\mathbf { x } > 0 )$ the matrix that contains one on its diagonal if the respective entry of $\\mathbf { x }$ is positive and zero otherwise. Let ${ \\bf c } _ { j c i }$ denote the $i$ -th column of $\\mathbf { C } _ { j }$ , and denote by $\\mathbf { W } _ { j i } \\in \\mathbf { \\bar { \\{ 0 , 1 \\} } } ^ { k \\times k }$ the corresponding diagonal matrix $\\mathbf { W } _ { j i } = \\mathrm { d i a g } ( \\mathbf { U } _ { j } \\mathbf { B } _ { j } \\mathbf { c } _ { j c i } > 0 )$ ). With this notation, we can write ",
+        "bbox": [
+            173,
+            164,
+            826,
+            234
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c4c9a9b875debebdb690a60512af22667f6aae55b2779c59c4a7939d81b9c1ff.jpg",
+        "text": "$$\n{ \\bf B } _ { 1 } = \\mathrm { r e l u } ( { \\bf U } _ { 0 } { \\bf B } _ { 0 } { \\bf C } _ { 0 } ) = [ { \\bf W } _ { 0 1 } { \\bf U } _ { 0 } { \\bf B } _ { 0 } { \\bf c } _ { 0 c 1 } , \\ldots , { \\bf W } _ { 0 k } { \\bf U } _ { 0 } { \\bf B } _ { 0 } { \\bf c } _ { 0 c k } ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            236,
+            712,
+            253
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Thus, ",
+        "bbox": [
+            173,
+            255,
+            214,
+            268
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8c068cb69da947ce4d1d96f7cb0606db4da80f185ab70ef675ccee0bb15b36e0.jpg",
+        "text": "$$\nG ( \\mathbf { C } ) = [ \\mathbf { W } _ { 0 1 } \\mathbf { U } _ { 0 } \\mathbf { B } _ { 0 } , \\dots , \\mathbf { W } _ { 0 k } \\mathbf { U } _ { 0 } \\mathbf { B } _ { 0 } ] \\left[ \\begin{array} { c } { \\mathbf { c } _ { 0 c 1 } [ \\mathbf { c } _ { 1 } ] _ { 1 } } \\\\ { \\vdots } \\\\ { \\mathbf { c } _ { 0 c 1 } [ \\mathbf { c } _ { 1 } ] _ { k } } \\end{array} \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            265,
+            673,
+            323
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $[ \\mathbf { c } _ { 1 } ] _ { i }$ denotes the $i$ -th entry of $\\mathbf { c } _ { 1 }$ . Thus, $G ( \\mathbf { C } )$ lies in the union of at-most- $k ^ { 2 }$ -dimensional subspaces of $\\mathbb { R } ^ { n }$ , where each subspace is determined by the matrices $\\{ \\mathbf { W } _ { 0 j } \\} _ { j = 1 } ^ { k }$ . The number of those subspaces is bounded by $n ^ { k ^ { 2 } }$ . This follows from the fact that for the matrix $\\mathbf { A } : = \\mathbf { U } _ { 0 } \\mathbf { B } _ { 0 }$ , by Lemma 1 below, the number of different matrices $\\mathbf { W } _ { 0 j }$ is bounded by $n ^ { k }$ . Since there are $k$ matrices, the number of different sets of matrices is bounded by $n ^ { k ^ { 2 } }$ . ",
+        "bbox": [
+            173,
+            323,
+            826,
+            401
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1. For any $\\mathbf { A } \\in \\mathbb { R } ^ { n \\times k }$ and $k \\geq 5$ ",
+        "bbox": [
+            173,
+            404,
+            455,
+            417
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/91cc75a0045c426f41eb53903f50a97268c397a188ccb59537ae821d83afb8f0.jpg",
+        "text": "$$\n| \\{ \\mathrm { d i a g } ( \\mathbf { A } \\mathbf { v } > 0 ) \\mathbf { A } | \\mathbf { v } \\in \\mathbb { R } ^ { k } \\} | \\leq n ^ { k } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            419,
+            619,
+            438
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Next, fix the matrixes $\\{ \\mathbf { W } _ { 0 j } \\} _ { j }$ . As $G ( \\mathbf { C } )$ lies in an at-most- $k ^ { 2 }$ -dimensional subspace, let $S$ be a $k ^ { 2 }$ -dimensional subspace that contains the range of $G$ for these fixed $\\{ \\mathbf { W } _ { 0 j } \\} _ { j }$ . It follows that ",
+        "bbox": [
+            173,
+            445,
+            828,
+            477
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fdb30a725dcdde29ab28a9c53e5674d0fa32f4922b9d059346d935a18708a031.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\mathbf { C } } \\left\\| G ( \\mathbf { C } ) - \\eta \\right\\| _ { 2 } ^ { 2 } \\geq \\frac { \\left\\| P _ { S ^ { c } } \\eta \\right\\| _ { 2 } ^ { 2 } } { \\left\\| \\eta \\right\\| _ { 2 } ^ { 2 } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            478,
+            606,
+            517
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Now, we make use of the following bound on the projection of the noise $\\eta$ onto a subspace. ",
+        "bbox": [
+            169,
+            517,
+            779,
+            531
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lemma 2. Let $S \\subset \\mathbb { R } ^ { n }$ be a subspace with dimension $\\ell .$ . Let $\\eta \\sim \\mathcal { N } ( 0 , I _ { n } )$ and $\\beta \\geq 1$ . Then, ",
+        "bbox": [
+            176,
+            534,
+            781,
+            549
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a265a6c079f8b27606b281ea55e98dcf36cbccca820c97a13ef00a1645133061.jpg",
+        "text": "$$\n\\mathrm { P } \\left[ \\frac { \\left\\| P _ { S ^ { c } } \\eta \\right\\| _ { 2 } ^ { 2 } } { \\left\\| \\eta \\right\\| _ { 2 } ^ { 2 } } \\ge 1 - \\frac { 1 0 \\beta \\ell } { n } \\right] \\ge 1 - e ^ { - \\beta \\ell } - e ^ { - n / 1 6 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            549,
+            668,
+            592
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Proof of Lemma 2. From Laurent & Massart (2000, Lem. 1), if $X \\sim \\chi _ { n } ^ { 2 }$ , then ",
+        "bbox": [
+            176,
+            606,
+            681,
+            621
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/30038a23259fd3dbc5274315aba159daf3bcee7d24fbf9e6de2d953958f37811.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathrm { P } \\left[ X - n \\geq 2 \\sqrt { n x } + 2 x \\right] \\leq e ^ { - x } , } \\\\ { \\mathrm { P } \\left[ X \\leq n - 2 \\sqrt { n x } \\right] \\leq e ^ { - x } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            621,
+            612,
+            661
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "With these, we obtain ",
+        "bbox": [
+            174,
+            660,
+            318,
+            674
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/afe56c75dd39a3eddb6e5bb595c13710c8861357c3f3644f60ed0a8d976473c6.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathrm { P } \\left[ X \\ge 5 \\beta n \\right] \\le e ^ { - \\beta n } \\mathrm { i f } \\beta \\ge 1 , } \\\\ & { \\mathrm { P } \\left[ X \\le n / 2 \\right] \\le e ^ { - n / 1 6 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            674,
+            604,
+            715
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We have $\\begin{array} { r } { \\frac { \\| P _ { S ^ { c } } \\eta \\| _ { 2 } ^ { 2 } } { \\| \\eta \\| _ { 2 } ^ { 2 } } = 1 - \\frac { \\| P _ { S } \\eta \\| _ { 2 } ^ { 2 } } { \\| \\eta \\| _ { 2 } ^ { 2 } } } \\end{array}$ . Note that $\\| P _ { S } \\eta \\| _ { 2 } \\sim \\chi _ { \\ell } ^ { 2 }$ and $\\left\\| \\eta \\right\\| _ { 2 } ^ { 2 } \\sim \\chi _ { n } ^ { 2 }$ . Applying inequality (2) to bound $\\| P _ { S } \\eta \\| _ { 2 }$ and inequality (3) to bound $\\| \\boldsymbol { \\eta } \\| _ { 2 } ^ { 2 }$ , a union bound gives that claim. □ ",
+        "bbox": [
+            173,
+            717,
+            825,
+            758
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Thus, by inequality (1) and Lemma 2 with $\\ell = k ^ { 2 }$ , for all $\\beta \\geq 1$ ",
+        "bbox": [
+            173,
+            772,
+            596,
+            789
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a66dddec6f65030dbd1c4825744d2a4be708afabf07b61139d46ad19d6454609.jpg",
+        "text": "$$\n\\mathrm { P } \\left[ \\frac { 1 } { \\left\\| \\eta \\right\\| _ { 2 } ^ { 2 } } \\operatorname* { m i n } _ { \\mathbf { C } } \\left\\| \\boldsymbol { G } ( \\mathbf { C } ) - \\eta \\right\\| _ { 2 } ^ { 2 } \\geq 1 - \\frac { 1 0 \\beta k ^ { 2 } } { n } \\bigg | \\{ \\mathbf { W } _ { 0 j } \\} _ { j } \\right] \\geq 1 - e ^ { - k ^ { 2 } \\beta } - e ^ { - n / 1 6 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            240,
+            790,
+            756,
+            832
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Since the number of matrices $\\{ \\mathbf { W } _ { 0 j } \\} _ { j }$ is bounded by ${ n _ { 0 } } ^ { k ^ { 2 } }$ , by a union bound, ",
+        "bbox": [
+            173,
+            833,
+            686,
+            851
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f3b08fdff08943c7d9103aef70074eabc764077791516fda1515da5290746dfa.jpg",
+        "text": "$$\n\\mathrm { P } \\left[ \\frac { 1 } { \\left\\| \\eta \\right\\| _ { 2 } ^ { 2 } } \\operatorname* { m i n } _ { \\mathbf { C } } \\left\\| \\boldsymbol { G } ( \\mathbf { C } ) - \\eta \\right\\| _ { 2 } ^ { 2 } \\leq 1 - \\frac { 1 0 \\beta k ^ { 2 } } { n } \\right] \\leq { n _ { 0 } } ^ { k ^ { 2 } } \\big ( e ^ { - \\beta k ^ { 2 } } + e ^ { - n / 1 6 } \\big ) \\leq { 2 n _ { 0 } } ^ { - k ^ { 2 } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            852,
+            767,
+            893
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where the last inequality follows with choosing $\\beta = 2 \\log ( n _ { 0 } )$ and by the assumption that $k ^ { 2 } <$ $\\frac { n } { 3 2 \\log n _ { 0 } }$ This proves the claim in Proposition 1. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/ec5e689357789706d2a98d754ab29cc6b3548f4c17563a8b8a5e66cb53f16c04.jpg",
+        "image_caption": [
+            "Figure 7: Sensitivity to parameter perturbations of the weights in each layer, and images generated by perturbing the weights in different layers, and keeping the weights in the other layers constant. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            108,
+            818,
+            287
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.1 PROOF OF LEMMA 1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            349,
+            357,
+            363
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to count the number of sign patterns $( \\mathbf { A } \\mathbf { v } > 0 ) \\in \\{ 0 , 1 \\}$ . Note that this number is equal to the maximum number of partitions one can get when cutting a $k$ -dimensional space with $n$ many hyperplanes that all pass through the origin, and are perpendicular to the rows of A. This number if well known (see for example Winder (1966)) and is upper bounded by ",
+        "bbox": [
+            173,
+            375,
+            825,
+            433
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/01de4d93917befe58a77df982acf741455d6bf88fc36566f0d16f7682c828411.jpg",
+        "text": "$$\n2 \\sum _ { i = 0 } ^ { n - 1 } { \\binom { n - 1 } { k } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            438,
+            553,
+            481
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Thus, ",
+        "bbox": [
+            173,
+            487,
+            214,
+            501
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7234255a28e32f2c4340f40db8e4ea3f169a7e1994d9fdf8121fb96f3da73a2d.jpg",
+        "text": "$$\n| \\{ \\mathrm { d i a g } ( \\mathbf { A } \\mathbf { v } > 0 ) \\mathbf { A } \\colon \\mathbf { v } \\in \\mathbb { R } ^ { k } \\} | \\leq 2 \\sum _ { i = 0 } ^ { n - 1 } { \\binom { n - 1 } { k } } \\leq 2 k \\left( { \\frac { e ( n - 1 ) } { k } } \\right) ^ { k } \\leq n ^ { k } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            498,
+            750,
+            541
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where the last inequality holds for $k \\geq 5$ . ",
+        "bbox": [
+            176,
+            544,
+            444,
+            559
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B SENSITIVITY TO PARAMETER PERTURBATIONS AND DISTRIBUTION OF PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            579,
+            787,
+            612
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The deep decoder is not overly sensitive to perturbations of its coefficients. To demonstrate this, fit the standard test image Barbara with a deep decoder with 6 layers and $k = 1 2 8$ , as before. We then perturb the weights in a given layer $i$ (i.e., the matrix $\\mathbf { C } _ { i }$ ) with Gaussian noise of a certain signal-tonoise ratio relative to $\\mathbf { C } _ { i }$ and leave the other weights and the input untouched. We then measure the peak signal-to-noise ratio in the image domain, and plot the corresponding curve for each layer (see Fig. 7). It can be seen that the representation provided by the deep decoder is relatively stable with respect to perturbations of its coefficients, and that it is more sensitive to perturbations in higher levels. ",
+        "bbox": [
+            173,
+            627,
+            826,
+            739
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Finally, in Fig. 8 we depict the distribution of the weights of the network after fitted to the Barbara test image, and note that the weights are approximately Gaussian distributed. ",
+        "bbox": [
+            173,
+            746,
+            823,
+            775
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/8dd65c1fbb98abe334c56bfccb3383d2b727edb450726b6fb31812cc7708668e.jpg",
+        "image_caption": [
+            "Figure 8: Distribution of the weights for fitting the test image Barbara along with a Gaussian fit: The distribution of the weighs is approximately Gaussian. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            217,
+            790,
+            784,
+            852
+        ],
+        "page_idx": 13
+    }
+]