Add files using upload-large-folder tool

parse/train/0XXpJ4OtjW/0XXpJ4OtjW.md

@@ -0,0 +1,330 @@
+# EVOLVING REINFORCEMENT LEARNING ALGORITHMS
+
+John D. Co-Reyes, Yingjie Miao, Daiyi Peng, Esteban Real, Sergey Levine, Quoc V. Le, Honglak Lee, Aleksandra Faust∗ Research at Google, Mountain View, CA 94043, USA
+
+# ABSTRACT
+
+We propose a method for meta-learning reinforcement learning algorithms by searching over the space of computational graphs which compute the loss function for a value-based model-free RL agent to optimize. The learned algorithms are domain-agnostic and can generalize to new environments not seen during training. Our method can both learn from scratch and bootstrap off known existing algorithms, like DQN, enabling interpretable modifications which improve performance. Learning from scratch on simple classical control and gridworld tasks, our method rediscovers the temporal-difference (TD) algorithm. Bootstrapped from DQN, we highlight two learned algorithms which obtain good generalization performance over other classical control tasks, gridworld type tasks, and Atari games. The analysis of the learned algorithm behavior shows resemblance to recently proposed RL algorithms that address overestimation in value-based methods.
+
+# 1 INTRODUCTION
+
+Designing new deep reinforcement learning algorithms that can efficiently solve across a wide variety of problems generally requires a tremendous amount of manual effort. Learning to design reinforcement learning algorithms or even small sub-components of algorithms would help ease this burden and could result in better algorithms than researchers could design manually. Our work might then shift from designing these algorithms manually into designing the language and optimization methods for developing these algorithms automatically.
+
+Reinforcement learning algorithms can be viewed as a procedure that maps an agent’s experience to a policy that obtains high cumulative reward over the course of training. We formulate the problem of training an agent as one of meta-learning: an outer loop searches over the space of computational graphs or programs that compute the objective function for the agent to minimize and an inner loop performs the updates using the learned loss function. The objective of the outer loop is to maximize the training return of the inner loop algorithm.
+
+Our learned loss function should generalize across many different environments, instead of being specific to a particular domain. Thus, we design a search language based on genetic programming (Koza, 1993) that can express general symbolic loss functions which can be applied to any environment. Data typing and a generic interface to variables in the MDP allow the learned program to be domain agnostic. This language also supports the use of neural network modules as subcomponents of the program, so that more complex neural network architectures can be realized. Efficiently searching over the space of useful programs is generally difficult. For the outer loop optimization, we use regularized evolution (Real et al., 2019), a recent variant of classic evolutionary algorithms that employ tournament selection (Goldberg & Deb, 1991). This approach can scale with the number of compute nodes and has been shown to work for designing algorithms for supervised learning (Real et al., 2020). We adapt this method to automatically design algorithms for reinforcement learning.
+
+While learning from scratch is generally less biased, encoding existing human knowledge into the learning process can speed up the optimization and also make the learned algorithm more interpretable. Because our search language expresses algorithms as a generalized computation graph, we can embed known RL algorithms in the graphs of the starting population of programs. We compare starting from scratch with bootstrapping off existing algorithms and find that while starting from scratch can learn existing algorithms, starting from existing knowledge leads to new RL algorithms which can outperform the initial programs.
+
+![](images/c5e3257f3f2eda3cc4bb9126c6511c48019d8aaa9625413fb33c527172cf2c46.jpg)  
+Figure 1: Method overview. We use regularized evolution to evolve a population of RL algorithms. A mutator alters top performing algorithms to produce a new algorithm. The performance of the algorithm is evaluated over a set of training environments and the population is updated. Our method can incorporating existing knowledge by starting the population from known RL algorithms instead of purely from scratch.
+
+We learn two new RL algorithms which outperform existing algorithms in both sample efficiency and final performance on the training and test environments. The learned algorithms are domain agnostic and generalize to new environments. Importantly, the training environments consist of a suite of discrete action classical control tasks and gridworld style environments while the test environments include Atari games and are unlike anything seen during training.
+
+The contribution of this paper is a method for searching over the space of RL algorithms, which we instantiate by developing a formal language that describes a broad class of value-based model-free reinforcement learning methods. Our search language enables us to embed existing algorithms into the starting graphs which leads to faster learning and interpretable algorithms. We highlight two learned algorithms which generalize to completely new environments. Our analysis of the metalearned programs shows that our method automatically discovers algorithms that share structure to recently proposed RL innovations, and empirically attain better performance than deep Q-learning methods.
+
+# 2 RELATED WORK
+
+Learning to learn is an established idea in in supervised learning, including meta-learning with genetic programming (Schmidhuber, 1987; Holland, 1975; Koza, 1993), learning a neural network update rule (Bengio et al., 1991), and self modifying RNNs (Schmidhuber, 1993). Genetic programming has been used to find new loss functions (Bengio et al., 1994; Trujillo & Olague, 2006). More recently, AutoML (Hutter et al., 2018) aims to automate the machine learning training process. Automated neural network architecture search (Stanley & Miikkulainen, 2002; Real et al., 2017; 2019; Liu et al., 2017; Zoph & Le, 2016; Elsken et al., 2018; Pham et al., 2018) has made large improvements in image classification. Instead of learning the architecture, AutoML-Zero (Real et al., 2020) learns the algorithm from scratch using basic mathematical operations. Our work shares similar ideas, but is applied to the RL setting and assumes additional primitives such as neural network modules. In contrast to AutoML-Zero, we learn computational graphs with the goal of automating RL algorithm design. Our learned RL algorithms generalize to new problems, not seen in training.
+
+Automating RL. While RL is used for AutoML (Zoph & Le, 2016; Zoph et al., 2018; Cai et al., 2018; Bello et al., 2017), automating RL itself has been somewhat limited. RL requires different design choices compared to supervised learning, including the formulation of reward and policy update rules. All of which affect learning and performance, and are usually chosen through trial and error. AutoRL addresses the gap by applying the AutoML framework from supervised learning to the MDP setting in RL. For example, evolutionary algorithms are used to mutate the value or actor network weights (Whiteson & Stone, 2006; Khadka & Tumer, 2018), learn task reward (Faust et al., 2019), tune hyperparameters (Tang & Choromanski, 2020; Franke et al., 2020), or search for a neural network architecture (Song et al., 2020; Franke et al., 2020). This paper focuses on task-agnostic RL update rules in the value-based RL setting which are both interpretable and generalizable.
+
+Meta-learning in RL. Recent work has focused on few-shot task adaptation. Finn et al. (2017); Finn & Levine (2018) meta-learns initial parameters which can quickly adapt to new tasks, while $\mathrm { { R L } ^ { 2 } }$ (Duan et al., 2016) and concurrent work (Wang et al., 2017), formulates RL itself as a learning problem that is learned with an RNN. The meta-learned component of these works is tuned to a particular domain or environment, in the form of NN weights which cannot be used for completely new domains with potentially different sized inputs. Neural Programmer-Interpreters (Reed & De Freitas, 2015; Pierrot et al., 2019) overcome the environment generalization challenge by learning hierarchical neural programs with domain-specific encoders for different environments. Here, the computational graph has a flexible architecture and generalizes across different environments.
+
+Learning RL algorithms or their components, such as a reward bonus or value update function, has been studied previously with meta-gradients (Kirsch et al., 2020; Chebotar et al., 2019; Oh et al., 2020), evolutionary strategies (Houthooft et al., 2018), and RNNs (Duan et al., 2016). Although our work also learns RL algorithms, the update rule is represented as a computation graph which includes both neural network modules and symbolic operators. One key benefit is that the resulting graph can be interpreted analytically and can optionally be initialized from known existing algorithms. Prior work that focuses on learning RL losses, generalizes to different goals and initial conditions within a single environment (Houthooft et al., 2018), or learns a domain invariant policy update rule that can generalize to new environments (Kirsch et al., 2020). Another approach searches over the space of curiosity programs using a similar language of DAGs with neural network modules (Alet et al., 2020a) and performs the meta-training on a single environment. In contrast, our method is applied to learn general RL update rules and meta-trained over a diverse set of environments.
+
+# 3 LEARNING REINFORCEMENT LEARNING ALGORITHMS
+
+In this section, we first describe the problem setup. An inner loop method $\operatorname { E v a l } ( L , { \mathcal { E } } )$ evaluates a learned RL algorithm $L$ on a given environment $\mathcal { E }$ . Given access to this procedure, the goal for the outer loop optimization is to learn a RL algorithm with high training return over a set of training environments. We then describe the search language which enables the learning of general loss functions and the outer loop method which can efficiently search over this space.
+
+# 3.1 PROBLEM SETUP
+
+We assume that the agent parameterized with policy $\pi _ { \boldsymbol { \theta } } \big ( a _ { t } | \boldsymbol { s } _ { t } \big )$ outputs actions $a _ { t }$ at each time step to an environment $\mathcal { E }$ and receives reward $r _ { t }$ and next state $s _ { t + 1 }$ . Since we are focusing on discrete action value-based RL methods, $\theta$ will be the parameters for a $\mathrm { Q } \mathrm { - }$ value function and the policy is obtained from the $\mathrm { Q }$ -value function using an $\epsilon$ -greedy strategy. The agent saves this stream of transitions $( s _ { t } , s _ { t + 1 } , a _ { t } , r _ { t } )$ to a replay buffer and continually updates the policy by minimizing a loss function $L ( s _ { t } , a _ { t } , r _ { t } , s _ { t + 1 } , \theta , \gamma )$ over these transitions with gradient descent. Training will occur for a fixed number of $M$ training episodes where in each episode $m$ , the agent earns episode return $\begin{array} { r } { R _ { m } \ = \ \sum _ { t = 0 } ^ { T } r _ { t } } \end{array}$ . The performance of an algorithm for a given environment is summarized by the normalized average training return, 1M P m=1 Rmax−Rmin Ri−Rmin , where Rmin and $R _ { m a x }$ are the minimum and maximum re
+
+![](images/1ec88918e166b0c7e23bf2453d3a06432b11df469e329272937f357a14470c0c.jpg)  
+Figure 2: Visualization of a RL algorithm, DQN, as a computational graph which computes the loss $L ~ = ~ _ { \circ } ( Q ( s _ { t } , a _ { t } ) ~ - ~ ( r _ { t } ~ + ~ \gamma ~ *$ $\mathbf { \bar { m a x } } _ { a } Q _ { t a r g } ( s _ { t + 1 } , a ) ) ^ { 2 }$ . Input nodes are in blue, parameter nodes in gray, operation nodes in orange, and output in green.
+
+turn for that environment. We assume these are known ahead of time. This inner loop evaluation procedure $\mathrm { E v a l } ( L , \mathcal { E } )$ is outlined in Algorithm 1. To score an algorithm, we use the normalized average training return instead of the final behavior policy return because the former metric will factor in sample efficiency as well.
+
+The goal of the meta-learner is to find the optimal loss function $L ( s _ { t } , a _ { t } , r _ { t } , s _ { t + 1 } , \theta , \gamma )$ to optimize $\pi _ { \theta }$ with maximal normalized average training return over the set of training environments. The full objective for the meta-learner is:
+
+$$
+L ^ { * } = \arg \operatorname* { m a x } _ { L } \left[ \sum _ { \varepsilon } \operatorname { E v a l } ( L , \mathcal { E } ) \right]
+$$
+
+$L$ is represented as a computational graph which we describe in the next section.
+
+# 3.2 SEARCH LANGUAGE
+
+Our search language for the algorithm $L$ should be expressive enough to represent existing algorithms while enabling the learning of new algorithms which can obtain good generalization performance across a wide range of environments. Similar to Alet et al. (2020a), we describe the RL algorithm as general programs with a domain specific language, but we target updates to the policy rather than reward bonuses for exploration. Algorithms will map transitions $( s _ { t } , a _ { t } , s _ { t + 1 } , r _ { t } )$ , policy parameters $\theta$ , and discount factor $\gamma$ into a scalar loss to be optimized with gradient descent. We express $L$ as a computational graph or directed acyclic graph (DAG) of nodes with typed inputs and outputs. See Figure 2 for a visualization of DQN expressed in this form. Nodes are of several types:
+
+Input nodes represent inputs to the program, and include elements from transitions $( s _ { t } , a _ { t } , s _ { t + 1 } , r _ { t } )$ and constants, such as the discount factor $\gamma$ .
+
+Parameter nodes are neural network weights, which can map between various data types. For example, the weights for the Q-value network will map an input node with state data type to a list of real numbers for each action.
+
+Operation nodes compute outputs given inputs from parent nodes. This includes applying parameter nodes, as well as basic math operators from linear algebra, probability, and statistics. A full list of operation nodes is provided in Appendix A. By default, we set the last node in the graph to compute the output of the program which is the scalar loss function to be optimized. Importantly, the inputs and outputs of nodes are typed among (state, action, vector, float, list, probability). This typing allows for programs to be applied to any domain. It also restricts the space of programs to ones with valid typing which reduces the search space.
+
+1: Input: RL Algorithm $L$ , Environment $\varepsilon$ , training episodes $M$   
+2: Initialize: Q-value parameters $\theta$ , target parameters $\theta ^ { \prime }$ empty replay   
+buffer $\mathcal { D }$   
+3: for $i = 1$ to $M$ do   
+4: for $t = 0$ to $T$ do   
+5: With probability , select a random action $a _ { t }$ ,   
+6: otherwise select $a _ { t } =$ arg maxa $Q ( s _ { t } , a )$   
+7: Step environmen $\tau s _ { t + 1 } , r _ { t } \sim \mathcal { E } ( a _ { t } , s _ { t } )$   
+8: 9: D ← D ∪ {st, at, rt, st+1} Update parameters $\begin{array} { r l } & { r _ { t } , s _ { t + 1 } \big \} } \\ & { \theta  \theta - \nabla _ { \theta } L ( s _ { t } , a _ { t } , r _ { t } , s _ { t + 1 } , \theta , \gamma ) } \end{array}$   
+10: Update target $\theta ^ { \prime }  \theta$   
+11: 12: end for Compute episode return $\textstyle R _ { m } = \sum _ { t = 0 } ^ { T } r _ { t }$   
+13: end for   
+14: Output: 15: Normalized training performance $\begin{array} { r } { \frac { 1 } { M } \sum _ { m = 1 } ^ { M } \frac { R _ { m } - R _ { m i n } } { R _ { m a x } - R _ { m i n } } } \end{array}$
+
+Algorithm 1 Algorithm Evaluation, $\mathrm { E v a l } ( L , \mathcal { E } )$   
+Algorithm 2 Evolving RL Algorithms   
+
+<table><tr><td></td><td>1:Input: Training environments {ε}, hurdle environment εh,hurdle threshold α,optional existing algorithm A</td></tr><tr><td></td><td>2:Initialize:PopulationPof RL algorithms {L},historyH,random- ized inputs I. If bootstrapping,initialize P with A.</td></tr><tr><td></td><td>3:Score each LinP with H[L].score ←∑εEval(L,ε)</td></tr><tr><td></td><td>4:for c=OtoC do</td></tr><tr><td>5:</td><td>Sample tournament T~ Uniform(P)</td></tr><tr><td>6:</td><td>Parent algorithmL ← highest score algorithm in T</td></tr><tr><td>7:</td><td>Child algorithm L&#x27; ← Mutate(L)</td></tr><tr><td>8:</td><td>H[L&#x27;].hash←Hash(L&#x27;(I))</td></tr><tr><td>9:</td><td>ifH[L&#x27;].hash was new and Eval(L&#x27;,£h) &gt;α then</td></tr><tr><td>10:</td><td>H[L&#x27;].score←∑Eval(L&#x27;,ε)</td></tr><tr><td>11:</td><td>end if</td></tr><tr><td>12:</td><td>Add L&#x27;to population P</td></tr><tr><td>13: 14:</td><td>Remove oldest L from population</td></tr><tr><td colspan="2">end for</td></tr><tr><td colspan="2">15: Output:Algorithm L with highest score</td></tr></table>
+
+# 3.3 EVOLUTIONARY SEARCH METHOD
+
+Evaluating thousands of programs over a range of complex environments is prohibitively expensive, especially if done serially. We adapt a genetic programming (Koza, 1993) method for the search method and use regularized evolution (Real et al., 2019), a variant of classic evolutionary algorithms that employ tournament selection (Goldberg & Deb, 1991). Regularized evolution has been shown to work for learning supervised learning algorithms (Real et al., 2020) and can be parallelized across compute nodes. Tournament selection keeps a population of $P$ algorithms and improves the population through cycles. Each cycle picks a tournament of $T \ < \ P$ algorithms at random and selects the best algorithm in the tournament as a parent. The parent is mutated into a child algorithm which gets added to the population while the oldest algorithm in the population is removed. We use a single type of mutation which first chooses which node in the graph to mutate and then replaces it with a random operation node with inputs drawn uniformly from all possible inputs.
+
+There exists a combinatorially large number of graph configurations. Furthermore, evaluating a single graph, which means training the full inner loop RL algorithm, can take up a large amount of time compared to the supervised learning setting. Speeding up the search and avoiding needless computation are needed to make the problem more tractable. We extend regularized evolution with several techniques, detailed below, to make the optimization more efficient. The full training procedure is outlined in Algorithm 2.
+
+Functional equivalence check (Real et al., 2020; Alet et al., 2020b). Before evaluating a program, we check if it is functionally equivalent to any previously evaluated program. This check is done by hashing the concatenated output of the program for 10 values of randomized inputs. If a mutated program is functionally equivalent to an older program, we still add it to the population, but use the saved score of the older program. Since some nodes of the graph do not always contribute to the output, parts of the mutated program may eventually contribute to a functionally different program.
+
+Early hurdles (So et al., 2019). We want poor performing programs to terminate early so that we can avoid unneeded computation. We use the CartPole environment as an early hurdle environment $\mathcal { E } _ { h }$ by training a program for a fixed number of episodes. If an algorithm performs poorly, then episodes will terminate in a short number of steps (as the pole falls rapidly) which quickly exhausts the number of training episodes. We use $\mathrm { E v a l } ( L , \mathcal { E } _ { h } ) < \alpha$ as the threshold for poor performance with $\alpha$ chosen empirically.
+
+Program checks. We perform basic checks to rule out and skip training invalid programs. The loss function needs to be a scalar value so we check if the program output type is a float $( \mathrm { t y p e } ( L ) = \mathbb { R } ,$ ). Additionally, we check if each program is differentiable with respect to the policy parameters by checking if a path exists in the graph between the output and the policy parameter node.
+
+Learning from Scratch and Bootstrapping. Our method enables both learning from scratch and learning from existing knowledge by bootstrapping the initial algorithm population with existing algorithms. We learn algorithms from scratch by initializing the population of algorithms randomly. An algorithm is sampled by sampling each operation node sequentially in the DAG. For each node, an operation and valid inputs to that operation are sampled uniformly over all possible options.
+
+While learning from scratch might uncover completely new algorithms that differ substantially from the existing methods, this method can take longer to converge to a reasonable algorithm. We would like to incorporate the knowledge we do have of good algorithms to bootstrap our search from a better starting point. We initialize our graph with the loss function of DQN (Mnih et al., 2013) so that the first 7 nodes represent the standard DQN loss, while the remaining nodes are initialized randomly. During regularized evolution, the nodes are not frozen, such that it is possible for the existing sub-graph to be completely replaced if a better solution is found.
+
+# 4 LEARNED RL ALGORITHM RESULTS AND ANALYSIS
+
+We discuss the training setup and results of our experiments. We highlight two learned algorithms with good generalization performance, DQNClipped and DQNReg, and analyze their structure.
+
+# 4.1 TRAINING SETUP
+
+Meta-Training details: We search over programs with maximum 20 nodes, not including inputs or parameter nodes. A full list of node types is provided in Appendix A. We use a population size of 300, tournament size of 25, and choose these parameters based on the ones used in (Real et al., 2019). Mutations occur with probability 0.95. Otherwise a new random program is sampled. The search is done over 300 CPUs and run for roughly 72 hours, at which point around 20, 000 programs have been evaluated. The search is distributed such that any free CPU is allocated to a proposed individual such that there are no idle CPUs. Further meta-training details are in Appendix B.
+
+Training environments: The choice of training environments greatly affects the learned algorithms and their generalization performance. At the same time, our training environments should be not too computationally expensive to run as we will be evaluating thousands of RL algorithms. We use a range of 4 classical control tasks (CartPole, Acrobat, MountainCar, LunarLander) and a set of 12 multitask gridworld style environments from MiniGrid (Chevalier-Boisvert et al., 2018). These environments are computationally cheap to run but also chosen to cover a diverse set of situations. This includes dense and sparse reward, long time horizon, and tasks requiring solving a sequence of subgoals such as picking up a key and unlocking a door. More details are in Appendix C.
+
+![](images/c70a0b8e305507be3ede3357e707a95798b64fa141f0eef580be2d99f118ac68.jpg)  
+Figure 3: Left: Meta-training performance over different number of environments from scratch, and bootstrapping. Plotted as RL evaluation performance (sum of normalized training return across the training environments) over the number of candidate algorithms. Shaded region represents one standard deviation over 10 random seeds. More training environments leads to better algorithms. Bootstrapping from DQN speeds up convergence and higher final performance. Right: Meta-training performance histogram for bootstrapped training. Many of the top programs have similar structure (Appendix D).
+
+The training environments always include CartPole as an initial hurdle. If an algorithm succeeds on CartPole (normalized training performance greater than 0.6), it then proceeds to a harder set of training environments. For our experiments, we choose these training environments by sampling a set of 3 environments and leave the rest as test environments. For learning from scratch we also compare the effect of number of training environments on the learned algorithm by comparing training on just CartPole versus training on CartPole and LunarLander.
+
+RL Training details: For training the RL agent, we use the same hyperparameters across all training and test environments except as noted. All neural networks are MLPs of size (256, 256) with ReLU activations. We use the Adam optimizer with a learning rate of 0.0001. $\epsilon$ is decayed linearly from 1 to 0.05 over 1e3 steps for the classical control tasks and over 1e5 steps for the MiniGrid tasks.
+
+# 4.2 LEARNING CONVERGENCE
+
+Figure 3a shows convergence over several training configurations. We find that at the end of training roughly $7 0 \%$ of proposed algorithms are functionally equivalent to a previously evaluated program, while early hurdles cut roughly another $4 0 \%$ of proposed non-duplicate programs.
+
+Varying number of training environments: We compare learning from scratch with a single training environment (CartPole) versus with two training environments (CartPole and LunarLander). While both experiments reach the maximum performance on these environments (Figure 3a), the learned algorithms are different. The two-environment training setup learns the known TD loss
+
+$$
+L _ { D Q N } = ( Q ( s _ { t } , a _ { t } ) - ( r _ { t } + \gamma * \operatorname* { m a x } _ { a } Q _ { t a r g } ( s _ { t } , a ) ) ) ^ { 2 }
+$$
+
+while the single-environment training setup learns a slight variation $L ~ = ~ ( Q ( s _ { t } , a _ { t } ) ~ - ~ ( r _ { t } ~ +$ $\begin{array} { r } { \operatorname* { m a x } _ { a } Q _ { t a r g } ( \bar { s _ { t } } , a ) ) ) ^ { 2 } } \end{array}$ that does not use the discount, indicating that the range of difficulty on the training environments is important for learning algorithms which can generalize.
+
+Learning from scratch versus bootstrapping: In Figure 3a, we compare training from scratch versus training from bootstrapping on four training environments (CartPole, KeyCorridorS3R1, DynamicObstacle-6x6, DoorKey-5x5). The training performance does not saturate, leaving room for improvement. Bootstrapping from DQN significantly improves both the convergence and performance of the meta-training, resulting in a $4 0 \%$ increase in final training performance.
+
+# 4.3 LEARNED RL ALGORITHMS: DQNCLIPPED AND DQNREG
+
+In this section, we discuss two particularly interesting loss functions that were learned by our method, and that have good generalization performance on the test environments. Let
+
+$$
+Y _ { t } = r _ { t } + \gamma * \operatorname* { m a x } _ { a } Q _ { t a r g } ( s _ { t } , a ) , \mathrm { ~ a n d ~ } \delta = Q ( s _ { t } , a _ { t } ) - Y _ { t }
+$$
+
+The first loss function DQNClipped is
+
+$$
+L _ { \mathrm { D Q N C l i p p e d } } = \operatorname* { m a x } \left[ Q ( s _ { t } , a _ { t } ) , \delta ^ { 2 } + Y _ { t } \right] + \operatorname* { m a x } \left[ Q ( s _ { t } , a _ { t } ) - Y _ { t } , \gamma ( \operatorname* { m a x } _ { a } Q _ { t a r g } ( s _ { t } , a ) ) ^ { 2 } \right] .
+$$
+
+LDQNClipped was trained from bootstrapping off DQN using three training environments (LunarLander, MiniGrid-Dynamic-Obstacles- ${ . 5 } \mathrm { x } 5$ , MiniGrid-LavaGapS5). It outperforms DQN and doubleDQN, DDQN, (van Hasselt et al., 2015) on both the training and unseen environments (Figure 4). The intuition behind this loss function is that, if the Q-values become too large (when $Q ( s _ { t } , a _ { t } ) > \delta ^ { 2 } + Y _ { t } )$ , the loss will act to minimize $Q ( s _ { t } , a _ { t } )$ instead of the normal $\delta ^ { 2 }$ loss. Alternatively, we can view this condition as $\delta = Q ( s _ { t } , a _ { t } ) - Y _ { t } > \delta ^ { 2 }$ . This means when $\delta$ is small enough then $Q ( s _ { t } , a _ { t } )$ are relatively close and the loss is just to minimize $Q ( s _ { t } , a _ { t } )$ .
+
+![](images/19e0f91013b594a6d371df6e6cb4ea9afd43f78ceb0f62f9c0df94fcd8ee6621.jpg)  
+Figure 4: Performance of learned algorithms (DQNClipped and DQNReg) versus baselines (DQN and DDQN) on training and test environments as measured by episode return over 10 training seeds. A dashed line indicates that the algorithm was meta-trained on that environment while a solid line indicates a test environment. DQNReg can match or outperform the baselines on almost all the training and test environments. Shaded regions correspond to 1 standard deviation.
+
+The second learned loss function, which we call DQNReg, is given by
+
+$$
+L _ { \mathrm { D Q N R e g } } = 0 . 1 * Q ( s _ { t } , a _ { t } ) + \delta ^ { 2 } .
+$$
+
+DQNReg was trained from bootstrapping off DQN using three training environments (KeyCorridorS3R1, Dynamic-Obstacles-6x6, DoorKey-5x5). In comparison to DQNClipped, DQNReg directly regularizes the Q values with a weighted term that is always active. We note that both of these loss functions modify the original DQN loss function to regularize the Q-values to be lower in value. While DQNReg is quite simple, it matches or outperforms the baselines on all training and test environments including from classical control and Minigrid. It does particularly well on a few test environments (SimpleCrossingS9N1, DoorKey-6x6, and Unlock) and solves the tasks when other methods fail to attain any reward. It is also much more stable with lower variance between seeds, and more sample efficient on test environments (LavaGapS5, Empty-6x6, Empty-Random-5x5).
+
+In Table 1, we evaluate DQNReg on a set of Atari games. We use the same architecture as in DQN (Mnih et al., 2013) and use the same no-op evaluation procedure which evaluates a trained policy every 1 million training steps over 200 test episodes. Even though meta-training was on computationally simple, non-image based environments, we find that DQNReg can generalize to image-based environments and outperform baselines. The results for the baselines are taken from their respective papers
+
+<table><tr><td>Env</td><td>DQN</td><td>DDQN</td><td>PPO</td><td>DQNReg</td></tr><tr><td>Asteroid</td><td>1364.5</td><td>734.7</td><td>2097.5</td><td>2390.4</td></tr><tr><td>Bowling</td><td>50.4</td><td>68.1</td><td>40.1</td><td>80.5</td></tr><tr><td>Boxing</td><td>88.0</td><td>91.6</td><td>94.6</td><td>100.0</td></tr><tr><td>RoadRunner</td><td>39544.0</td><td>44127.0</td><td>35466.0</td><td>65516.0</td></tr></table>
+
+Table 1: Performance of learned algorithm DQNReg against baselines on several Atari games. Baseline numbers taken from reported papers.
+
+(Mnih et al., 2013; van Hasselt et al., 2015; Schulman et al., 2017).
+
+These algorithms are related to recently proposed RL algorithms, conservative Q-learning (CQL) (Kumar et al., 2020) and M-DQN (Vieillard et al., 2020). CQL learns a conservative Qfunction by augmenting the standard Bellman error objective with a simple Q-value regularizer: $\begin{array} { r } { \log \sum _ { a } \exp \left( \bar { Q ( s _ { t } , a ) } \right) - \bar { Q ( s _ { t } , a _ { t } ) } } \end{array}$ which encourages the agent to stay close to the data distribution while maintaining a maximum entropy policy. DQNReg similarly augments the standard objective with a Q-value regularizer although does so in a different direction by preventing overestimation. M-DQN modifies DQN by adding the scaled log-policy (using the softmax Q-values) to the immediate reward. Both of these methods can be seen as ways to regularize a value-based policy. This resemblance indicates that our method can find useful structures automatically that are currently being explored manually, and could be used to propose new areas for researchers to explore.
+
+We discover that the best performing algorithms from the experiment which learned DQNReg are consistent, and in the form ${ \cal L } = \bar { \delta ^ { 2 } } + \bar { k } * { \cal Q } ( s _ { t } , a _ { t } )$ . This loss could use further analysis and investigation, possibly environment-specific tuning of the parameter $k$ . See Appendix 3 for details.
+
+![](images/ed053de3ca2f53ee5a2223b92cd81b6e6548ea33eadf6d088bcb1622e0469db7.jpg)  
+4.4 ANALYSIS OF LEARNED ALGORITHMS   
+Figure 5: Overestimated value estimates is generally problematic in value-based RL. Our method learns algorithms which regularize the Q-values helping with overestimation. We compare the estimated Q-values for our learned algorithms and baselines with the optimal ground truth Q-values across several environments during training. Estimate is for taking action zero from the initial state of the environment. While DQN overestimates the Q-values, our learned algorithms DQNClipped and DQNReg underestimate the Q-values.
+
+We analyze the learned algorithms to understand their beneficial effect on performance. In Figure 5, we compare the estimated Q-values for each algorithm. We see that DQN frequently overestimates the Q values while DDQN consistently underestimates the Q values before converging to the ground truth Q value which are computed with a manually designed optimal policy. DQNClipped has similar performance to DDQN, in that it also consistently underestimates the Q values and does so slightly more aggressively than DDQN. DQNReg significantly undershoots the Q values and does not converge to the ground truth. Various works (van Hasselt et al., 2015; Haarnoja et al., 2018; Fujimoto et al., 2018) have shown that overestimated value estimates is problematic and restricting the overestimation improves performance.
+
+The loss function in DQNClipped is composed of the sum of two max operations, and so we can analyze when each update rule is active. We interpret DQNClipped as $\operatorname* { m a x } ( v _ { 1 } , v _ { 2 } ) + \operatorname* { m a x } ( v _ { 2 } , v _ { 3 } )$ with four cases: 1) $v _ { 1 } ~ > ~ v _ { 2 }$ and $v _ { 3 } > v _ { 4 } 2$ ) $v _ { 1 } > v _ { 2 }$ and $v _ { 3 } < v _ { 4 } 3$ ) $v _ { 1 } < v _ { 2 }$ and $v _ { 3 } < v _ { 4 } 4 )$ $v _ { 1 } < v _ { 2 }$ and $v _ { 3 } > v _ { 4 }$ . Case 2 corresponds to minimizing the $\mathrm { Q }$ values. Case 3 would correspond to the normal DQN loss of $\delta ^ { 2 }$ since the parameters of $Q _ { t a r g }$ are not updated during gradient descent.
+
+In Figure 6, we plot the proportion of when each case is active during training. We see that usually case 3 is generally the most active with a small dip in the beginning but then stays around $9 5 \%$ . Meanwhile, case 2, which regularizes the $\mathrm { Q }$ -values, has a small increase in the beginning and then decreases later, matching with our analysis in Figure 6, which shows that DQNClipped strongly underestimates the $\mathrm { Q }$ -values in the beginning of training. This can be seen as a constrained optimization where the amount of Q-value regularization is tuned accordingly. The regularization is stronger in the beginning of training when overestimation is problematic $( Q ( \bar { s _ { t } } , a _ { t } ) \bar { > } \delta ^ { 2 } + Y _ { t } )$ and gets weaker as $\delta ^ { 2 }$ gets smaller.
+
+![](images/6524cdbf2665146037b451be54123f7f39980d070493adc0580446f060dc2031.jpg)  
+Figure 6: Our learned algorithm, DQNClipped, can be broken down into four update rules where each rule is active under certain conditions. Case 3 corresponds to normal TD learning while case 2 corresponds to minimizing the Q-values. Case 2 is more active in the beginning when value overestimation is a problem and then becomes less active as it is no longer needed.
+
+# 5 CONCLUSION
+
+In this work, we have presented a method for learning reinforcement learning algorithms. We design a general language for representing algorithms which compute the loss function for value-based model-free RL agents to optimize. We highlight two learned algorithms which although relatively simple, can obtain good generalization performance over a wide range of environments. Our analysis of the learned algorithms sheds insight on their benefit as regularization terms which are similar to recently proposed algorithms. Our work is limited to discrete action and value-based RL algorithms that are close to DQN, but could easily be expanded to express more general RL algorithms such as actor-critic or policy gradient methods. How actions are sampled from the policy could also be part of the search space. The set of environments we use for both training and testing could also be expanded to include a more diverse set of problem types. We leave these problems for future work.
+
+# ACKNOWLEDGEMENTS
+
+We thank Luke Metz for helpful early discussions and feedback on the paper, Hanjun Dai for early discussions on related research ideas, and Xingyou Song, Krzysztof Choromanski, and Kevin Lee for help with infrastructure. We also thank Jongwook Choi for help with environment selection.
+
+# REFERENCES
+
+Ferran Alet, M. F. Schneider, Tomas Lozano-Perez, and L. Kaelbling. Meta-learning curiosity algorithms. ArXiv, abs/2003.05325, 2020a.   
+Ferran Alet, Martin F. Schneider, Tomas Lozano-Perez, and Leslie Pack Kaelbling. Meta-learning curiosity algorithms. In International Conference on Learning Representations, 2020b. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ BygdyxHFDS.   
+Irwan Bello, Barret Zoph, Vijay Vasudevan, and Quoc V Le. Neural optimizer search with reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 459–468. JMLR. org, 2017.   
+S. Bengio, Yoshua Bengio, and J. Cloutier. Use of genetic programming for the search of a new learning rule for neural networks. Proceedings of the First IEEE Conference on Evolutionary Computation. IEEE World Congress on Computational Intelligence, pp. 324–327 vol.1, 1994.   
+Yoshua Bengio, S. Bengio, and J. Cloutier. Learning a synaptic learning rule. IJCNN-91-Seattle International Joint Conference on Neural Networks, ii:969 vol.2–, 1991.   
+Han Cai, Tianyao Chen, Weinan Zhang, Yong Yu, and Jun Wang. Efficient architecture search by network transformation. In Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, (AAAI-18), the 30th innovative Applications of Artificial Intelligence (IAAI-18), and the 8th AAAI Symposium on Educational Advances in Artificial Intelligence (EAAI-18), New Orleans, Louisiana, USA, February 2-7, 2018, pp. 2787–2794, 2018.   
+Yevgen Chebotar, Artem Molchanov, Sarah Bechtle, Ludovic Righetti, F. Meier, and Gaurav S. Sukhatme. Meta-learning via learned loss. ArXiv, abs/1906.05374, 2019.
+
+Maxime Chevalier-Boisvert, Lucas Willems, and Suman Pal. Minimalistic gridworld environment for openai gym. https://github.com/maximecb/gym-minigrid, 2018.
+
+Yan Duan, John Schulman, Xi Chen, Peter L. Bartlett, Ilya Sutskever, and P. Abbeel. Rl2: Fast reinforcement learning via slow reinforcement learning. ArXiv, abs/1611.02779, 2016.
+
+Thomas Elsken, Jan Hendrik Metzen, and Frank Hutter. Neural architecture search: A survey. arXiv preprint arXiv:1808.05377, 2018.
+
+Aleksandra Faust, Anthony Francis, and Dar Mehta. Evolving rewards to automate reinforcement learning. arXiv preprint arXiv:1905.07628, 2019.
+
+Chelsea Finn and S. Levine. Meta-learning and universality: Deep representations and gradient descent can approximate any learning algorithm. ArXiv, abs/1710.11622, 2018.
+
+Chelsea Finn, P. Abbeel, and S. Levine. Model-agnostic meta-learning for fast adaptation of deep networks. ArXiv, abs/1703.03400, 2017.
+
+Jorg K. H. Franke, Gregor K ¨ ohler, Andr ¨ e Biedenkapp, and Frank Hutter. Sample-efficient automated ´ deep reinforcement learning. 2020.
+
+Scott Fujimoto, H. V. Hoof, and David Meger. Addressing function approximation error in actorcritic methods. ArXiv, abs/1802.09477, 2018.
+
+David E Goldberg and Kalyanmoy Deb. A comparative analysis of selection schemes used in genetic algorithms. FOGA, 1991.
+
+Toumas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In ICML, 2018.
+
+John H. Holland. Adaptation in Natural and Artificial Systems. University of Michigan Press, Ann Arbor, MI, 1975. second edition, 1992.
+
+Rein Houthooft, Richard Y. Chen, Phillip Isola, Bradly C. Stadie, F. Wolski, Jonathan Ho, and P. Abbeel. Evolved policy gradients. ArXiv, abs/1802.04821, 2018.
+
+Frank Hutter, Lars Kotthoff, and Joaquin Vanschoren (eds.). Automated Machine Learning: Methods, Systems, Challenges. Springer, 2018. In press, available at http://automl.org/book.
+
+Shauharda Khadka and Kagan Tumer. Evolution-guided policy gradient in reinforcement learning. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 1188–1200. Curran Associates, Inc., 2018.
+
+Louis Kirsch, Sjoerd van Steenkiste, and J. Schmidhuber. Improving generalization in meta reinforcement learning using learned objectives. ArXiv, abs/1910.04098, 2020.
+
+John Koza. Genetic programming - on the programming of computers by means of natural selection. In Complex adaptive systems, 1993.
+
+Aviral Kumar, Aurick Zhou, G. Tucker, and Sergey Levine. Conservative q-learning for offline reinforcement learning. ArXiv, abs/2006.04779, 2020.
+
+Chenxi Liu, Barret Zoph, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan L. Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. CoRR, abs/1712.00559, 2017. URL http://arxiv.org/abs/1712.00559.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin A. Riedmiller. Playing atari with deep reinforcement learning. ArXiv, abs/1312.5602, 2013.
+
+Junhyuk Oh, Matteo Hessel, Wojciech Marian Czarnecki, Zhongwen Xu, Hado van Hasselt, Satinder Singh, and David Silver. Discovering reinforcement learning algorithms. ArXiv, abs/2007.08794, 2020.
+
+Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. In ICML, 2018.
+
+Thomas Pierrot, Guillaume Ligner, Scott Reed, Olivier Sigaud, Nicolas Perrin, Alexandre Laterre, David Kas, Karim Beguir, and Nando de Freitas. Learning compositional neural programs with recursive tree search and planning. NeurIPS, 2019.
+
+Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon Suematsu, Jie Tan, Quoc V. Le, and Alexey Kurakin. Large-scale evolution of image classifiers. In Proceedings of the 34th International Conference on Machine Learning - Volume 70, ICML’17, pp. 2902–2911. JMLR.org, 2017.
+
+Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V. Le. Regularized evolution for image classifier architecture search. In AAAI, volume abs/1802.01548, 2019.
+
+Esteban Real, Chen Liang, David So, and Quoc V. Le. Automl-zero: Evolving machine learning algorithms from scratch. In ICML, volume abs/2003.03384, 2020.
+
+Scott Reed and Nando De Freitas. Neural programmer-interpreters. arXiv preprint arXiv:1511.06279, 2015.
+
+Juergen Schmidhuber. Evolutionary principles in self-referential learning. 1987.
+
+Juergen Schmidhuber. A self-referential weight matrix. 1993.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+D. So, Chen Liang, and Quoc V. Le. The evolved transformer. ArXiv, abs/1901.11117, 2019.
+
+Xingyou Song, Krzysztof Choromanski, Jack Parker-Holder, Yunhao Tang, Wenbo Gao, Aldo Pacchiano, Tamas Sarlos, Deepali Jain, and Yuxiang Yang. Reinforcement learning with chromatic networks for compact architecture search. 2020.
+
+Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002.
+
+Yunhao Tang and Krzysztof Choromanski. Online hyper-parameter tuning in off-policy learning via evolutionary strategies, 2020.
+
+L. Trujillo and G. Olague. Synthesis of interest point detectors through genetic programming. In GECCO ’06, 2006.
+
+Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. In AAAI, 2015.
+
+Nino Vieillard, Olivier Pietquin, and M. Geist. Munchausen reinforcement learning. ArXiv, abs/2007.14430, 2020.
+
+Jane X. Wang, Zeb Kurth-Nelson, Hubert Soyer, Joel Z. Leibo, Dhruva Tirumala, Remi Munos, ´ Charles Blundell, D. Kumaran, and Matt M. Botvinick. Learning to reinforcement learn. ArXiv, abs/1611.05763, 2017.
+
+S. Whiteson and P. Stone. Evolutionary function approximation for reinforcement learning. J. Mach. Learn. Res., 7:877–917, 2006.
+
+Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. In ICLR, 2016.
+
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 8697–8710, 2018.
+
+# A SEARCH LANGUAGE DETAILS
+
+Inputs and outputs to nodes in the computational graph have data types which include state $\mathbb { S }$ , action $\mathbb { Z }$ , float $\mathbb { R }$ , list $\boldsymbol { L i s t [ \mathbb { X } ] }$ , probability $\mathbb { P }$ , vector $\mathbb { V }$ . The symbol $\mathbb { X }$ indicates it can be of $\mathbb { S } , \mathbb { R }$ , or $\mathbb { V }$ . We assume that vectors are of fixed length 32 and actions are integers. Operations will broadcast so that for example adding a float variable to a state variable will result in the float being added to each element of the state. This typing allows the learned program to be domain agnostic. The full list of operators is listed below.
+
+<table><tr><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=2>Input Types</td><td rowspan=1 colspan=1>Output Type</td></tr><tr><td rowspan=1 colspan=1>Add</td><td rowspan=1 colspan=2>X,X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Subtract</td><td rowspan=1 colspan=2>X, X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Max</td><td rowspan=1 colspan=2>X, X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Min</td><td rowspan=1 colspan=2>X,X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>DotProduct</td><td rowspan=1 colspan=2>X,X</td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>Div</td><td rowspan=1 colspan=2>X,X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>L2Distance</td><td rowspan=1 colspan=2>X,X</td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>MaxList</td><td rowspan=1 colspan=1>List[R]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>MinList</td><td rowspan=1 colspan=1>List[R]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>ArgMaxList</td><td rowspan=1 colspan=1>List[R]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Z</td></tr><tr><td rowspan=1 colspan=1>SelectList</td><td rowspan=1 colspan=1>List[X],Z</td><td rowspan=1 colspan=1>Z</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>MeanList</td><td rowspan=1 colspan=1>List[X]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>VarianceList</td><td rowspan=1 colspan=1>List[X]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Log</td><td rowspan=1 colspan=2>X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Exp</td><td rowspan=1 colspan=2>X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Abs</td><td rowspan=1 colspan=2>X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>(C)NN:S → List[R]</td><td rowspan=1 colspan=2>S</td><td rowspan=1 colspan=1>List[R]</td></tr><tr><td rowspan=1 colspan=1>(C)NN:S → R</td><td rowspan=1 colspan=2>S</td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>(C)NN:S → V</td><td rowspan=1 colspan=2>V</td><td rowspan=1 colspan=1>V</td></tr><tr><td rowspan=1 colspan=1>Softmax</td><td rowspan=1 colspan=2>List[R]</td><td rowspan=1 colspan=1>P</td></tr><tr><td rowspan=1 colspan=1>KLDiv</td><td rowspan=1 colspan=2>P,P</td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>Entropy</td><td rowspan=1 colspan=2>P</td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>Constant</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>1, 0.5, 0.2,0.1, 0.01</td></tr><tr><td rowspan=1 colspan=1>MultiplyTenth</td><td rowspan=1 colspan=2>X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Normal(0, 1)</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>Uniform(0, 1)</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>R</td></tr></table>
+
+# B TRAINING DETAILS
+
+We describe the training details and hyperparameters used. For all environments we use the Adam optimzier with a learning rate of 0.0001.
+
+Common RL training details. All neural networks are MLPs of size (256, 256) with ReLU activations. For optimizing the Q-function parameters we use the Adam optimizer with a learning rate of 0.0001. Target update period is 100. These settings are used for all training and test environments.
+
+Classical control environments. The value of $\epsilon$ is decayed linearly from 1 to 0.05 over 1000 steps. CartPole, Acrobat, and MountainCar are trained for 400 episodes and LunarLander is trained for 1000 episodes.
+
+MiniGrid environments. The value of $\epsilon$ is decayed linearly from 1 to 0.05 over $1 0 ^ { 5 }$ steps. During meta-training, MiniGrid environments are trained for $5 * 1 0 ^ { \mathrm { 5 } }$ steps.
+
+Atari environments. We use the same neural network architecture as in Mnih et al. (2013). Target update period is $1 , 0 0 0$ . The value of $\epsilon$ is decayed linearly from 1 to 0.1 over $1 0 ^ { 6 }$ steps. For evaluation, we use the no-op start condition as in Mnih et al. (2013) where the agent will output the no-op action for $x$ steps where $x$ is a random integer drawn between [1, 30]. The evaluation policy uses an $\epsilon$ of 0.001 and is evaluated every $1 0 ^ { 6 }$ steps for 100 episodes. The best training snapshot is reported.
+
+# C ENVIRONMENT DETAILS
+
+We describe the classical control environments below. CartPole and LunarLander are dense reward while Acrobat and MountainCar are sparse reward.   
+
+<table><tr><td></td><td>Task ID</td><td>Description</td></tr><tr><td></td><td>CartPole-v0</td><td>The agent must balance a pole on top of a cart by applying a force of +l or -1 to the cart. A reward of +1 is provided for each timestep the pole remains upright.</td></tr><tr><td></td><td>LunarLander-v2</td><td>The agent controls a lander by firing one of four thrusters and must land it on the landing pad.</td></tr><tr><td></td><td>Acrobat-v1</td><td>The goal is to swing a 2-link system upright to a given height by applying 1,O,or -1 torque on the join between the two links.</td></tr><tr><td></td><td>MountainCar-vO</td><td>The goal is to drive up the mountain on the right by first driving back and forth to build up momentum.</td></tr></table>
+
+We describe the MiniGrid environments below. The input to the agent is a fully observed grid which is encoded as an NxNx3 size array where $_ \mathrm { N }$ is the grid size. The 1st channel contains the index of the object type at that location (out of 11 possible objects), the 2nd channel contains the color of the object (out of 6 possible colors), and the 3rd channel contains the orientation of the agent out of 4 cardinal directions. This encoding is then flattened and fed into an MLP. There are 7 possible actions (turn left, turn right, forward, pickup, drop, toggle, done).
+
+Unless stated otherwise, all tasks are sparse reward tasks with a reward of 1 for completing the task. Max steps is set to 100. A size such as 5x5 in the environment name refers to a grid size with width and height of 5 cells.
+
+<table><tr><td></td><td>Task ID</td><td>Description</td></tr><tr><td>自V日</td><td>KeyCorridorS3R1-v0</td><td>The agent has to find a key hidden in one room and then use it to pickup an object be- hind a locked door in another room． This tests sequential subgoal completion.</td></tr><tr><td>. 333333 ?</td><td>LavaGapS5-v0</td><td>The agent has to reach the green goal square without touching the lava which will termi- nate the episode with zero reward. This tests safety and safe exploration.</td></tr><tr><td></td><td>MultiRoom-N2-S4-v0</td><td>The agent must open a door to get to the green goal square in the next room.</td></tr></table>
+
+<table><tr><td>SimpleCrossingS9N1- v0</td><td>The agent has to reach the green goal square on the other corner of the room and navigate around walls.</td></tr><tr><td>Empty-v0</td><td>The agent has to reach the green goal square in an empty room.</td></tr><tr><td>EmptyRandom-v0</td><td>The agent has to reach the green goal square in an empty room but is initialized to a ran- dom location.</td></tr><tr><td>Dynamic-Obstacles-v0</td><td>The agent has to reach the green goal square without colliding with any blue obstacles which move around randomly. If the agent collides with an obstacle it receives a reward of -1 and the episode terminates.</td></tr><tr><td>FourRooms-v0</td><td>The agent must navigate in a maze com- posed of four rooms. Both the agent and goal square are randomly placed in any of the four rooms.</td></tr><tr><td>DoorKey-v0</td><td>The agent must pick up a key to unlock a door to enter another room and get to the green goal square.</td></tr></table>
+
+![](images/00e0bc3d8324d6a6475d53ece87f0bdcf3e1da16a3fe55ae5c248aa65ad035dc.jpg)
+
+# D GRAPH DISTRIBUTION ANALYSIS
+
+We look at the distribution of top performing graphs and find similarities in their structure. This is summarized in Table 3 where we describe the equations of learned algorithms for differing ranks (if sorted by score). The best performing algorithms from the experiment which learned DQNReg are all variants of adding $Q ( s _ { t } , a _ { t } )$ to the standard TD loss in some form, $\delta ^ { 2 } + k * Q ( s _ { t } , a _ { t } )$ . We think this kind of loss could use further investigation and that while we did not tune the value of $k$ , this could also be tuned per environment. In Figure 3b, we show the distribution of scores for all nonduplicate programs that have been evaluated. We provide a full list of top performing algorithms from a few of our experiments at https://github.com/jcoreyes/evolvingrl.
+
+<table><tr><td>Raw Equation</td><td>Simplified Equation</td><td>Score</td><td>Rank</td></tr><tr><td>δ²+0.1*Q(st,at)+Tt-(γ*Qtarg-0.1*Q(st,at))</td><td>δ²+0.2*Q(st,at)</td><td>3.905</td><td>2</td></tr><tr><td>δ²+0.1*Q(st,at)-γ+Qtarg</td><td>δ²+0.1*Q(st,at)</td><td>3.904</td><td>3</td></tr><tr><td>δ²-(γ *Qtarg-0.1*Q(st,at))</td><td>δ²+0.1*Q(st,at)</td><td>3.903</td><td>4</td></tr><tr><td>δ²+Qtarg+0.1 * Q(st,at)-γ</td><td>δ²+0.1*Q(st,at)</td><td>3.902</td><td>5</td></tr><tr><td>δ²-(0.1*Q(st,at)-Yt)²</td><td>δ²-(0.1*Q(st,at)-Yt)²</td><td>3.898</td><td>6</td></tr><tr><td>δ²+((rt+γ*Qtarg+Q(st,at))*(γ-max(γ,0.1*Q(st,at)) -γ *Qtarg-0.1*Q(st,at))</td><td>NA</td><td>3.846</td><td>11146</td></tr><tr><td>δ²+(δ²+0.1*Q(st,at))²</td><td>NA</td><td>3.65</td><td>12146</td></tr><tr><td>δ²+Q(st,at)</td><td>8²+Q(st,at)</td><td>2.8</td><td>12446</td></tr><tr><td>2</td><td>82</td><td>2.28</td><td>13246</td></tr></table>
+
+Table 3: Other programs learned in learning DQNReg which is rank 1 with score 3.907. Rank is if scores are sorted in decreasing order. Score is the sum of normalized RL training performance across four environments. The simplified equations contains only the relevant parts for minimizing the equation output. $Q _ { t a r g }$ refers to $\begin{array} { r } { \operatorname* { m a x } _ { a } Q _ { t a r g } ( s _ { t + 1 } , a ) } \end{array}$ .
+
+# E REPEATABILITY OF META TRAINING
+
+In Figure 7, we plot the meta-training performance for bootstrapping from DQN with four training environments (CartPole, KeyCorridorS3R1, Dynamic-Obstacles-6x6, DoorKey-5x5) over ten trials. Four out of the ten trials reach the max training performance. Two out of 10 of these trials learns the same algorithm DQNReg while the other top two trials find other less interpretable algorithms.
+
+![](images/9506b9b0e91f539451c35d6ceeb80fc879ecb6fa00d4fdf76addca3c58e47581.jpg)  
+Figure 7: Meta-training performance for boot-strapping on 4 training environments for 10 random seeds.

parse/train/0XXpJ4OtjW/0XXpJ4OtjW_content_list.json

@@ -0,0 +1,1728 @@
+[
+    {
+        "type": "text",
+        "text": "EVOLVING REINFORCEMENT LEARNING ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            658,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "John D. Co-Reyes, Yingjie Miao, Daiyi Peng, Esteban Real, Sergey Levine, Quoc V. Le, Honglak Lee, Aleksandra Faust∗ Research at Google, Mountain View, CA 94043, USA ",
+        "bbox": [
+            183,
+            169,
+            601,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            248,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a method for meta-learning reinforcement learning algorithms by searching over the space of computational graphs which compute the loss function for a value-based model-free RL agent to optimize. The learned algorithms are domain-agnostic and can generalize to new environments not seen during training. Our method can both learn from scratch and bootstrap off known existing algorithms, like DQN, enabling interpretable modifications which improve performance. Learning from scratch on simple classical control and gridworld tasks, our method rediscovers the temporal-difference (TD) algorithm. Bootstrapped from DQN, we highlight two learned algorithms which obtain good generalization performance over other classical control tasks, gridworld type tasks, and Atari games. The analysis of the learned algorithm behavior shows resemblance to recently proposed RL algorithms that address overestimation in value-based methods. ",
+        "bbox": [
+            233,
+            280,
+            764,
+            445
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            473,
+            334,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Designing new deep reinforcement learning algorithms that can efficiently solve across a wide variety of problems generally requires a tremendous amount of manual effort. Learning to design reinforcement learning algorithms or even small sub-components of algorithms would help ease this burden and could result in better algorithms than researchers could design manually. Our work might then shift from designing these algorithms manually into designing the language and optimization methods for developing these algorithms automatically. ",
+        "bbox": [
+            174,
+            505,
+            823,
+            588
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning algorithms can be viewed as a procedure that maps an agent’s experience to a policy that obtains high cumulative reward over the course of training. We formulate the problem of training an agent as one of meta-learning: an outer loop searches over the space of computational graphs or programs that compute the objective function for the agent to minimize and an inner loop performs the updates using the learned loss function. The objective of the outer loop is to maximize the training return of the inner loop algorithm. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            678
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our learned loss function should generalize across many different environments, instead of being specific to a particular domain. Thus, we design a search language based on genetic programming (Koza, 1993) that can express general symbolic loss functions which can be applied to any environment. Data typing and a generic interface to variables in the MDP allow the learned program to be domain agnostic. This language also supports the use of neural network modules as subcomponents of the program, so that more complex neural network architectures can be realized. Efficiently searching over the space of useful programs is generally difficult. For the outer loop optimization, we use regularized evolution (Real et al., 2019), a recent variant of classic evolutionary algorithms that employ tournament selection (Goldberg & Deb, 1991). This approach can scale with the number of compute nodes and has been shown to work for designing algorithms for supervised learning (Real et al., 2020). We adapt this method to automatically design algorithms for reinforcement learning. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            852
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While learning from scratch is generally less biased, encoding existing human knowledge into the learning process can speed up the optimization and also make the learned algorithm more interpretable. Because our search language expresses algorithms as a generalized computation graph, we can embed known RL algorithms in the graphs of the starting population of programs. We compare starting from scratch with bootstrapping off existing algorithms and find that while starting from scratch can learn existing algorithms, starting from existing knowledge leads to new RL algorithms which can outperform the initial programs. ",
+        "bbox": [
+            176,
+            859,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c5e3257f3f2eda3cc4bb9126c6511c48019d8aaa9625413fb33c527172cf2c46.jpg",
+        "image_caption": [
+            "Figure 1: Method overview. We use regularized evolution to evolve a population of RL algorithms. A mutator alters top performing algorithms to produce a new algorithm. The performance of the algorithm is evaluated over a set of training environments and the population is updated. Our method can incorporating existing knowledge by starting the population from known RL algorithms instead of purely from scratch. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            85,
+            808,
+            212
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            287,
+            823,
+            343
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We learn two new RL algorithms which outperform existing algorithms in both sample efficiency and final performance on the training and test environments. The learned algorithms are domain agnostic and generalize to new environments. Importantly, the training environments consist of a suite of discrete action classical control tasks and gridworld style environments while the test environments include Atari games and are unlike anything seen during training. ",
+        "bbox": [
+            174,
+            351,
+            823,
+            420
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The contribution of this paper is a method for searching over the space of RL algorithms, which we instantiate by developing a formal language that describes a broad class of value-based model-free reinforcement learning methods. Our search language enables us to embed existing algorithms into the starting graphs which leads to faster learning and interpretable algorithms. We highlight two learned algorithms which generalize to completely new environments. Our analysis of the metalearned programs shows that our method automatically discovers algorithms that share structure to recently proposed RL innovations, and empirically attain better performance than deep Q-learning methods. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            539
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            571,
+            344,
+            588
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning to learn is an established idea in in supervised learning, including meta-learning with genetic programming (Schmidhuber, 1987; Holland, 1975; Koza, 1993), learning a neural network update rule (Bengio et al., 1991), and self modifying RNNs (Schmidhuber, 1993). Genetic programming has been used to find new loss functions (Bengio et al., 1994; Trujillo & Olague, 2006). More recently, AutoML (Hutter et al., 2018) aims to automate the machine learning training process. Automated neural network architecture search (Stanley & Miikkulainen, 2002; Real et al., 2017; 2019; Liu et al., 2017; Zoph & Le, 2016; Elsken et al., 2018; Pham et al., 2018) has made large improvements in image classification. Instead of learning the architecture, AutoML-Zero (Real et al., 2020) learns the algorithm from scratch using basic mathematical operations. Our work shares similar ideas, but is applied to the RL setting and assumes additional primitives such as neural network modules. In contrast to AutoML-Zero, we learn computational graphs with the goal of automating RL algorithm design. Our learned RL algorithms generalize to new problems, not seen in training. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            777
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Automating RL. While RL is used for AutoML (Zoph & Le, 2016; Zoph et al., 2018; Cai et al., 2018; Bello et al., 2017), automating RL itself has been somewhat limited. RL requires different design choices compared to supervised learning, including the formulation of reward and policy update rules. All of which affect learning and performance, and are usually chosen through trial and error. AutoRL addresses the gap by applying the AutoML framework from supervised learning to the MDP setting in RL. For example, evolutionary algorithms are used to mutate the value or actor network weights (Whiteson & Stone, 2006; Khadka & Tumer, 2018), learn task reward (Faust et al., 2019), tune hyperparameters (Tang & Choromanski, 2020; Franke et al., 2020), or search for a neural network architecture (Song et al., 2020; Franke et al., 2020). This paper focuses on task-agnostic RL update rules in the value-based RL setting which are both interpretable and generalizable. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Meta-learning in RL. Recent work has focused on few-shot task adaptation. Finn et al. (2017); Finn & Levine (2018) meta-learns initial parameters which can quickly adapt to new tasks, while $\\mathrm { { R L } ^ { 2 } }$ (Duan et al., 2016) and concurrent work (Wang et al., 2017), formulates RL itself as a learning problem that is learned with an RNN. The meta-learned component of these works is tuned to a particular domain or environment, in the form of NN weights which cannot be used for completely new domains with potentially different sized inputs. Neural Programmer-Interpreters (Reed & De Freitas, 2015; Pierrot et al., 2019) overcome the environment generalization challenge by learning hierarchical neural programs with domain-specific encoders for different environments. Here, the computational graph has a flexible architecture and generalizes across different environments. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Learning RL algorithms or their components, such as a reward bonus or value update function, has been studied previously with meta-gradients (Kirsch et al., 2020; Chebotar et al., 2019; Oh et al., 2020), evolutionary strategies (Houthooft et al., 2018), and RNNs (Duan et al., 2016). Although our work also learns RL algorithms, the update rule is represented as a computation graph which includes both neural network modules and symbolic operators. One key benefit is that the resulting graph can be interpreted analytically and can optionally be initialized from known existing algorithms. Prior work that focuses on learning RL losses, generalizes to different goals and initial conditions within a single environment (Houthooft et al., 2018), or learns a domain invariant policy update rule that can generalize to new environments (Kirsch et al., 2020). Another approach searches over the space of curiosity programs using a similar language of DAGs with neural network modules (Alet et al., 2020a) and performs the meta-training on a single environment. In contrast, our method is applied to learn general RL update rules and meta-trained over a diverse set of environments. ",
+        "bbox": [
+            173,
+            236,
+            825,
+            402
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 LEARNING REINFORCEMENT LEARNING ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            428,
+            661,
+            444
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first describe the problem setup. An inner loop method $\\operatorname { E v a l } ( L , { \\mathcal { E } } )$ evaluates a learned RL algorithm $L$ on a given environment $\\mathcal { E }$ . Given access to this procedure, the goal for the outer loop optimization is to learn a RL algorithm with high training return over a set of training environments. We then describe the search language which enables the learning of general loss functions and the outer loop method which can efficiently search over this space. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            534
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROBLEM SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            333,
+            570
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We assume that the agent parameterized with policy $\\pi _ { \\boldsymbol { \\theta } } \\big ( a _ { t } | \\boldsymbol { s } _ { t } \\big )$ outputs actions $a _ { t }$ at each time step to an environment $\\mathcal { E }$ and receives reward $r _ { t }$ and next state $s _ { t + 1 }$ . Since we are focusing on discrete action value-based RL methods, $\\theta$ will be the parameters for a $\\mathrm { Q } \\mathrm { - }$ value function and the policy is obtained from the $\\mathrm { Q }$ -value function using an $\\epsilon$ -greedy strategy. The agent saves this stream of transitions $( s _ { t } , s _ { t + 1 } , a _ { t } , r _ { t } )$ to a replay buffer and continually updates the policy by minimizing a loss function $L ( s _ { t } , a _ { t } , r _ { t } , s _ { t + 1 } , \\theta , \\gamma )$ over these transitions with gradient descent. Training will occur for a fixed number of $M$ training episodes where in each episode $m$ , the agent earns episode return $\\begin{array} { r } { R _ { m } \\ = \\ \\sum _ { t = 0 } ^ { T } r _ { t } } \\end{array}$ . The performance of an algorithm for a given environment is summarized by the normalized average training return, 1M P m=1 Rmax−Rmin Ri−Rmin , where Rmin and $R _ { m a x }$ are the minimum and maximum re",
+        "bbox": [
+            174,
+            584,
+            483,
+            868
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ec88918e166b0c7e23bf2453d3a06432b11df469e329272937f357a14470c0c.jpg",
+        "image_caption": [
+            "Figure 2: Visualization of a RL algorithm, DQN, as a computational graph which computes the loss $L ~ = ~ _ { \\circ } ( Q ( s _ { t } , a _ { t } ) ~ - ~ ( r _ { t } ~ + ~ \\gamma ~ *$ $\\mathbf { \\bar { m a x } } _ { a } Q _ { t a r g } ( s _ { t + 1 } , a ) ) ^ { 2 }$ . Input nodes are in blue, parameter nodes in gray, operation nodes in orange, and output in green. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            519,
+            588,
+            802,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "turn for that environment. We assume these are known ahead of time. This inner loop evaluation procedure $\\mathrm { E v a l } ( L , \\mathcal { E } )$ is outlined in Algorithm 1. To score an algorithm, we use the normalized average training return instead of the final behavior policy return because the former metric will factor in sample efficiency as well. ",
+        "bbox": [
+            174,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The goal of the meta-learner is to find the optimal loss function $L ( s _ { t } , a _ { t } , r _ { t } , s _ { t + 1 } , \\theta , \\gamma )$ to optimize $\\pi _ { \\theta }$ with maximal normalized average training return over the set of training environments. The full objective for the meta-learner is: ",
+        "bbox": [
+            173,
+            103,
+            825,
+            145
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/99e3533979c78b87a6b4d68a9f74e4f2e14555d4813f1b3a15991bcb868a67db.jpg",
+        "text": "$$\nL ^ { * } = \\arg \\operatorname* { m a x } _ { L } \\left[ \\sum _ { \\varepsilon } \\operatorname { E v a l } ( L , \\mathcal { E } ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            154,
+            609,
+            198
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$L$ is represented as a computational graph which we describe in the next section. ",
+        "bbox": [
+            173,
+            205,
+            700,
+            220
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 SEARCH LANGUAGE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            238,
+            357,
+            253
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our search language for the algorithm $L$ should be expressive enough to represent existing algorithms while enabling the learning of new algorithms which can obtain good generalization performance across a wide range of environments. Similar to Alet et al. (2020a), we describe the RL algorithm as general programs with a domain specific language, but we target updates to the policy rather than reward bonuses for exploration. Algorithms will map transitions $( s _ { t } , a _ { t } , s _ { t + 1 } , r _ { t } )$ , policy parameters $\\theta$ , and discount factor $\\gamma$ into a scalar loss to be optimized with gradient descent. We express $L$ as a computational graph or directed acyclic graph (DAG) of nodes with typed inputs and outputs. See Figure 2 for a visualization of DQN expressed in this form. Nodes are of several types: ",
+        "bbox": [
+            173,
+            265,
+            825,
+            377
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input nodes represent inputs to the program, and include elements from transitions $( s _ { t } , a _ { t } , s _ { t + 1 } , r _ { t } )$ and constants, such as the discount factor $\\gamma$ . ",
+        "bbox": [
+            174,
+            383,
+            820,
+            412
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Parameter nodes are neural network weights, which can map between various data types. For example, the weights for the Q-value network will map an input node with state data type to a list of real numbers for each action. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            460
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Operation nodes compute outputs given inputs from parent nodes. This includes applying parameter nodes, as well as basic math operators from linear algebra, probability, and statistics. A full list of operation nodes is provided in Appendix A. By default, we set the last node in the graph to compute the output of the program which is the scalar loss function to be optimized. Importantly, the inputs and outputs of nodes are typed among (state, action, vector, float, list, probability). This typing allows for programs to be applied to any domain. It also restricts the space of programs to ones with valid typing which reduces the search space. ",
+        "bbox": [
+            173,
+            468,
+            825,
+            566
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1: Input: RL Algorithm $L$ , Environment $\\varepsilon$ , training episodes $M$   \n2: Initialize: Q-value parameters $\\theta$ , target parameters $\\theta ^ { \\prime }$ empty replay   \nbuffer $\\mathcal { D }$   \n3: for $i = 1$ to $M$ do   \n4: for $t = 0$ to $T$ do   \n5: With probability \u000f, select a random action $a _ { t }$ ,   \n6: otherwise select $a _ { t } =$ arg maxa $Q ( s _ { t } , a )$   \n7: Step environmen $\\tau s _ { t + 1 } , r _ { t } \\sim \\mathcal { E } ( a _ { t } , s _ { t } )$   \n8: 9: D ← D ∪ {st, at, rt, st+1} Update parameters $\\begin{array} { r l } & { r _ { t } , s _ { t + 1 } \\big \\} } \\\\ & { \\theta  \\theta - \\nabla _ { \\theta } L ( s _ { t } , a _ { t } , r _ { t } , s _ { t + 1 } , \\theta , \\gamma ) } \\end{array}$   \n10: Update target $\\theta ^ { \\prime }  \\theta$   \n11: 12: end for Compute episode return $\\textstyle R _ { m } = \\sum _ { t = 0 } ^ { T } r _ { t }$   \n13: end for   \n14: Output: 15: Normalized training performance $\\begin{array} { r } { \\frac { 1 } { M } \\sum _ { m = 1 } ^ { M } \\frac { R _ { m } - R _ { m i n } } { R _ { m a x } - R _ { m i n } } } \\end{array}$ ",
+        "bbox": [
+            179,
+            602,
+            470,
+            751
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/b4b70381458f4e0e46bfe4b7f34fadaac48e24443afce158fd224d0c5fb118ac.jpg",
+        "table_caption": [
+            "Algorithm 1 Algorithm Evaluation, $\\mathrm { E v a l } ( L , \\mathcal { E } )$ ",
+            "Algorithm 2 Evolving RL Algorithms "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>1:Input: Training environments {ε}, hurdle environment εh,hurdle threshold α,optional existing algorithm A</td></tr><tr><td></td><td>2:Initialize:PopulationPof RL algorithms {L},historyH,random- ized inputs I. If bootstrapping,initialize P with A.</td></tr><tr><td></td><td>3:Score each LinP with H[L].score ←∑εEval(L,ε)</td></tr><tr><td></td><td>4:for c=OtoC do</td></tr><tr><td>5:</td><td>Sample tournament T~ Uniform(P)</td></tr><tr><td>6:</td><td>Parent algorithmL ← highest score algorithm in T</td></tr><tr><td>7:</td><td>Child algorithm L&#x27; ← Mutate(L)</td></tr><tr><td>8:</td><td>H[L&#x27;].hash←Hash(L&#x27;(I))</td></tr><tr><td>9:</td><td>ifH[L&#x27;].hash was new and Eval(L&#x27;,£h) &gt;α then</td></tr><tr><td>10:</td><td>H[L&#x27;].score←∑Eval(L&#x27;,ε)</td></tr><tr><td>11:</td><td>end if</td></tr><tr><td>12:</td><td>Add L&#x27;to population P</td></tr><tr><td>13: 14:</td><td>Remove oldest L from population</td></tr><tr><td colspan=\"2\">end for</td></tr><tr><td colspan=\"2\">15: Output:Algorithm L with highest score</td></tr></table>",
+        "bbox": [
+            483,
+            598,
+            779,
+            753
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 EVOLUTIONARY SEARCH METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            771,
+            457,
+            786
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Evaluating thousands of programs over a range of complex environments is prohibitively expensive, especially if done serially. We adapt a genetic programming (Koza, 1993) method for the search method and use regularized evolution (Real et al., 2019), a variant of classic evolutionary algorithms that employ tournament selection (Goldberg & Deb, 1991). Regularized evolution has been shown to work for learning supervised learning algorithms (Real et al., 2020) and can be parallelized across compute nodes. Tournament selection keeps a population of $P$ algorithms and improves the population through cycles. Each cycle picks a tournament of $T \\ < \\ P$ algorithms at random and selects the best algorithm in the tournament as a parent. The parent is mutated into a child algorithm which gets added to the population while the oldest algorithm in the population is removed. We use a single type of mutation which first chooses which node in the graph to mutate and then replaces it with a random operation node with inputs drawn uniformly from all possible inputs. ",
+        "bbox": [
+            173,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "There exists a combinatorially large number of graph configurations. Furthermore, evaluating a single graph, which means training the full inner loop RL algorithm, can take up a large amount of time compared to the supervised learning setting. Speeding up the search and avoiding needless computation are needed to make the problem more tractable. We extend regularized evolution with several techniques, detailed below, to make the optimization more efficient. The full training procedure is outlined in Algorithm 2. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            222
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Functional equivalence check (Real et al., 2020; Alet et al., 2020b). Before evaluating a program, we check if it is functionally equivalent to any previously evaluated program. This check is done by hashing the concatenated output of the program for 10 values of randomized inputs. If a mutated program is functionally equivalent to an older program, we still add it to the population, but use the saved score of the older program. Since some nodes of the graph do not always contribute to the output, parts of the mutated program may eventually contribute to a functionally different program. ",
+        "bbox": [
+            174,
+            229,
+            823,
+            313
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Early hurdles (So et al., 2019). We want poor performing programs to terminate early so that we can avoid unneeded computation. We use the CartPole environment as an early hurdle environment $\\mathcal { E } _ { h }$ by training a program for a fixed number of episodes. If an algorithm performs poorly, then episodes will terminate in a short number of steps (as the pole falls rapidly) which quickly exhausts the number of training episodes. We use $\\mathrm { E v a l } ( L , \\mathcal { E } _ { h } ) < \\alpha$ as the threshold for poor performance with $\\alpha$ chosen empirically. ",
+        "bbox": [
+            174,
+            320,
+            825,
+            404
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Program checks. We perform basic checks to rule out and skip training invalid programs. The loss function needs to be a scalar value so we check if the program output type is a float $( \\mathrm { t y p e } ( L ) = \\mathbb { R } ,$ ). Additionally, we check if each program is differentiable with respect to the policy parameters by checking if a path exists in the graph between the output and the policy parameter node. ",
+        "bbox": [
+            174,
+            410,
+            823,
+            467
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Learning from Scratch and Bootstrapping. Our method enables both learning from scratch and learning from existing knowledge by bootstrapping the initial algorithm population with existing algorithms. We learn algorithms from scratch by initializing the population of algorithms randomly. An algorithm is sampled by sampling each operation node sequentially in the DAG. For each node, an operation and valid inputs to that operation are sampled uniformly over all possible options. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            542
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While learning from scratch might uncover completely new algorithms that differ substantially from the existing methods, this method can take longer to converge to a reasonable algorithm. We would like to incorporate the knowledge we do have of good algorithms to bootstrap our search from a better starting point. We initialize our graph with the loss function of DQN (Mnih et al., 2013) so that the first 7 nodes represent the standard DQN loss, while the remaining nodes are initialized randomly. During regularized evolution, the nodes are not frozen, such that it is possible for the existing sub-graph to be completely replaced if a better solution is found. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            647
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 LEARNED RL ALGORITHM RESULTS AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            670,
+            642,
+            685
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We discuss the training setup and results of our experiments. We highlight two learned algorithms with good generalization performance, DQNClipped and DQNReg, and analyze their structure. ",
+        "bbox": [
+            174,
+            702,
+            823,
+            731
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 TRAINING SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            750,
+            336,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Meta-Training details: We search over programs with maximum 20 nodes, not including inputs or parameter nodes. A full list of node types is provided in Appendix A. We use a population size of 300, tournament size of 25, and choose these parameters based on the ones used in (Real et al., 2019). Mutations occur with probability 0.95. Otherwise a new random program is sampled. The search is done over 300 CPUs and run for roughly 72 hours, at which point around 20, 000 programs have been evaluated. The search is distributed such that any free CPU is allocated to a proposed individual such that there are no idle CPUs. Further meta-training details are in Appendix B. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training environments: The choice of training environments greatly affects the learned algorithms and their generalization performance. At the same time, our training environments should be not too computationally expensive to run as we will be evaluating thousands of RL algorithms. We use a range of 4 classical control tasks (CartPole, Acrobat, MountainCar, LunarLander) and a set of 12 multitask gridworld style environments from MiniGrid (Chevalier-Boisvert et al., 2018). These environments are computationally cheap to run but also chosen to cover a diverse set of situations. This includes dense and sparse reward, long time horizon, and tasks requiring solving a sequence of subgoals such as picking up a key and unlocking a door. More details are in Appendix C. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c70a0b8e305507be3ede3357e707a95798b64fa141f0eef580be2d99f118ac68.jpg",
+        "image_caption": [
+            "Figure 3: Left: Meta-training performance over different number of environments from scratch, and bootstrapping. Plotted as RL evaluation performance (sum of normalized training return across the training environments) over the number of candidate algorithms. Shaded region represents one standard deviation over 10 random seeds. More training environments leads to better algorithms. Bootstrapping from DQN speeds up convergence and higher final performance. Right: Meta-training performance histogram for bootstrapped training. Many of the top programs have similar structure (Appendix D). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            259,
+            90,
+            732,
+            234
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            344,
+            825,
+            415
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The training environments always include CartPole as an initial hurdle. If an algorithm succeeds on CartPole (normalized training performance greater than 0.6), it then proceeds to a harder set of training environments. For our experiments, we choose these training environments by sampling a set of 3 environments and leave the rest as test environments. For learning from scratch we also compare the effect of number of training environments on the learned algorithm by comparing training on just CartPole versus training on CartPole and LunarLander. ",
+        "bbox": [
+            173,
+            421,
+            825,
+            506
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "RL Training details: For training the RL agent, we use the same hyperparameters across all training and test environments except as noted. All neural networks are MLPs of size (256, 256) with ReLU activations. We use the Adam optimizer with a learning rate of 0.0001. $\\epsilon$ is decayed linearly from 1 to 0.05 over 1e3 steps for the classical control tasks and over 1e5 steps for the MiniGrid tasks. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            569
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 LEARNING CONVERGENCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            602,
+            401,
+            616
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 3a shows convergence over several training configurations. We find that at the end of training roughly $7 0 \\%$ of proposed algorithms are functionally equivalent to a previously evaluated program, while early hurdles cut roughly another $4 0 \\%$ of proposed non-duplicate programs. ",
+        "bbox": [
+            173,
+            633,
+            825,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Varying number of training environments: We compare learning from scratch with a single training environment (CartPole) versus with two training environments (CartPole and LunarLander). While both experiments reach the maximum performance on these environments (Figure 3a), the learned algorithms are different. The two-environment training setup learns the known TD loss ",
+        "bbox": [
+            174,
+            684,
+            825,
+            739
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7b7eed73fc35951f0a3e4723d4b4d8e63f29fe68a19228e54a44ed6f033c3716.jpg",
+        "text": "$$\nL _ { D Q N } = ( Q ( s _ { t } , a _ { t } ) - ( r _ { t } + \\gamma * \\operatorname* { m a x } _ { a } Q _ { t a r g } ( s _ { t } , a ) ) ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            760,
+            676,
+            782
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "while the single-environment training setup learns a slight variation $L ~ = ~ ( Q ( s _ { t } , a _ { t } ) ~ - ~ ( r _ { t } ~ +$ $\\begin{array} { r } { \\operatorname* { m a x } _ { a } Q _ { t a r g } ( \\bar { s _ { t } } , a ) ) ) ^ { 2 } } \\end{array}$ that does not use the discount, indicating that the range of difficulty on the training environments is important for learning algorithms which can generalize. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            848
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Learning from scratch versus bootstrapping: In Figure 3a, we compare training from scratch versus training from bootstrapping on four training environments (CartPole, KeyCorridorS3R1, DynamicObstacle-6x6, DoorKey-5x5). The training performance does not saturate, leaving room for improvement. Bootstrapping from DQN significantly improves both the convergence and performance of the meta-training, resulting in a $4 0 \\%$ increase in final training performance. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 LEARNED RL ALGORITHMS: DQNCLIPPED AND DQNREG ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            627,
+            118
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss two particularly interesting loss functions that were learned by our method, and that have good generalization performance on the test environments. Let ",
+        "bbox": [
+            171,
+            128,
+            825,
+            159
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dbcf38b4b5c389a5c36a5340df6e2e1b0c74b4fd18c6aecfe17a8d7dddf154f4.jpg",
+        "text": "$$\nY _ { t } = r _ { t } + \\gamma * \\operatorname* { m a x } _ { a } Q _ { t a r g } ( s _ { t } , a ) , \\mathrm { ~ a n d ~ } \\delta = Q ( s _ { t } , a _ { t } ) - Y _ { t }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            164,
+            684,
+            185
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The first loss function DQNClipped is ",
+        "bbox": [
+            176,
+            190,
+            424,
+            205
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0391793ff143223353725982703e10dd01f29807c683793b44dfaf36465562c4.jpg",
+        "text": "$$\nL _ { \\mathrm { D Q N C l i p p e d } } = \\operatorname* { m a x } \\left[ Q ( s _ { t } , a _ { t } ) , \\delta ^ { 2 } + Y _ { t } \\right] + \\operatorname* { m a x } \\left[ Q ( s _ { t } , a _ { t } ) - Y _ { t } , \\gamma ( \\operatorname* { m a x } _ { a } Q _ { t a r g } ( s _ { t } , a ) ) ^ { 2 } \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            205,
+            210,
+            790,
+            238
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "LDQNClipped was trained from bootstrapping off DQN using three training environments (LunarLander, MiniGrid-Dynamic-Obstacles- ${ . 5 } \\mathrm { x } 5$ , MiniGrid-LavaGapS5). It outperforms DQN and doubleDQN, DDQN, (van Hasselt et al., 2015) on both the training and unseen environments (Figure 4). The intuition behind this loss function is that, if the Q-values become too large (when $Q ( s _ { t } , a _ { t } ) > \\delta ^ { 2 } + Y _ { t } )$ , the loss will act to minimize $Q ( s _ { t } , a _ { t } )$ instead of the normal $\\delta ^ { 2 }$ loss. Alternatively, we can view this condition as $\\delta = Q ( s _ { t } , a _ { t } ) - Y _ { t } > \\delta ^ { 2 }$ . This means when $\\delta$ is small enough then $Q ( s _ { t } , a _ { t } )$ are relatively close and the loss is just to minimize $Q ( s _ { t } , a _ { t } )$ . ",
+        "bbox": [
+            173,
+            242,
+            825,
+            342
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/19e0f91013b594a6d371df6e6cb4ea9afd43f78ceb0f62f9c0df94fcd8ee6621.jpg",
+        "image_caption": [
+            "Figure 4: Performance of learned algorithms (DQNClipped and DQNReg) versus baselines (DQN and DDQN) on training and test environments as measured by episode return over 10 training seeds. A dashed line indicates that the algorithm was meta-trained on that environment while a solid line indicates a test environment. DQNReg can match or outperform the baselines on almost all the training and test environments. Shaded regions correspond to 1 standard deviation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            353,
+            820,
+            705
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The second learned loss function, which we call DQNReg, is given by ",
+        "bbox": [
+            174,
+            796,
+            633,
+            811
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5ef709bd5ae717a8ab263d348fd47456dcbbcec0ac77c097ca45ba16fd53a223.jpg",
+        "text": "$$\nL _ { \\mathrm { D Q N R e g } } = 0 . 1 * Q ( s _ { t } , a _ { t } ) + \\delta ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            816,
+            606,
+            835
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "DQNReg was trained from bootstrapping off DQN using three training environments (KeyCorridorS3R1, Dynamic-Obstacles-6x6, DoorKey-5x5). In comparison to DQNClipped, DQNReg directly regularizes the Q values with a weighted term that is always active. We note that both of these loss functions modify the original DQN loss function to regularize the Q-values to be lower in value. While DQNReg is quite simple, it matches or outperforms the baselines on all training and test environments including from classical control and Minigrid. It does particularly well on a few test environments (SimpleCrossingS9N1, DoorKey-6x6, and Unlock) and solves the tasks when other methods fail to attain any reward. It is also much more stable with lower variance between seeds, and more sample efficient on test environments (LavaGapS5, Empty-6x6, Empty-Random-5x5). ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Table 1, we evaluate DQNReg on a set of Atari games. We use the same architecture as in DQN (Mnih et al., 2013) and use the same no-op evaluation procedure which evaluates a trained policy every 1 million training steps over 200 test episodes. Even though meta-training was on computationally simple, non-image based environments, we find that DQNReg can generalize to image-based environments and outperform baselines. The results for the baselines are taken from their respective papers ",
+        "bbox": [
+            174,
+            154,
+            506,
+            291
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/249fba61f8c12c32b3064eb4becca377cfdd92abd9305197cd25bf930e97c047.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Env</td><td>DQN</td><td>DDQN</td><td>PPO</td><td>DQNReg</td></tr><tr><td>Asteroid</td><td>1364.5</td><td>734.7</td><td>2097.5</td><td>2390.4</td></tr><tr><td>Bowling</td><td>50.4</td><td>68.1</td><td>40.1</td><td>80.5</td></tr><tr><td>Boxing</td><td>88.0</td><td>91.6</td><td>94.6</td><td>100.0</td></tr><tr><td>RoadRunner</td><td>39544.0</td><td>44127.0</td><td>35466.0</td><td>65516.0</td></tr></table>",
+        "bbox": [
+            521,
+            170,
+            826,
+            229
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Performance of learned algorithm DQNReg against baselines on several Atari games. Baseline numbers taken from reported papers. ",
+        "bbox": [
+            519,
+            241,
+            823,
+            280
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(Mnih et al., 2013; van Hasselt et al., 2015; Schulman et al., 2017). ",
+        "bbox": [
+            181,
+            291,
+            612,
+            305
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "These algorithms are related to recently proposed RL algorithms, conservative Q-learning (CQL) (Kumar et al., 2020) and M-DQN (Vieillard et al., 2020). CQL learns a conservative Qfunction by augmenting the standard Bellman error objective with a simple Q-value regularizer: $\\begin{array} { r } { \\log \\sum _ { a } \\exp \\left( \\bar { Q ( s _ { t } , a ) } \\right) - \\bar { Q ( s _ { t } , a _ { t } ) } } \\end{array}$ which encourages the agent to stay close to the data distribution while maintaining a maximum entropy policy. DQNReg similarly augments the standard objective with a Q-value regularizer although does so in a different direction by preventing overestimation. M-DQN modifies DQN by adding the scaled log-policy (using the softmax Q-values) to the immediate reward. Both of these methods can be seen as ways to regularize a value-based policy. This resemblance indicates that our method can find useful structures automatically that are currently being explored manually, and could be used to propose new areas for researchers to explore. ",
+        "bbox": [
+            173,
+            313,
+            825,
+            452
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We discover that the best performing algorithms from the experiment which learned DQNReg are consistent, and in the form ${ \\cal L } = \\bar { \\delta ^ { 2 } } + \\bar { k } * { \\cal Q } ( s _ { t } , a _ { t } )$ . This loss could use further analysis and investigation, possibly environment-specific tuning of the parameter $k$ . See Appendix 3 for details. ",
+        "bbox": [
+            176,
+            458,
+            825,
+            501
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/ed053de3ca2f53ee5a2223b92cd81b6e6548ea33eadf6d088bcb1622e0469db7.jpg",
+        "image_caption": [
+            "4.4 ANALYSIS OF LEARNED ALGORITHMS ",
+            "Figure 5: Overestimated value estimates is generally problematic in value-based RL. Our method learns algorithms which regularize the Q-values helping with overestimation. We compare the estimated Q-values for our learned algorithms and baselines with the optimal ground truth Q-values across several environments during training. Estimate is for taking action zero from the initial state of the environment. While DQN overestimates the Q-values, our learned algorithms DQNClipped and DQNReg underestimate the Q-values. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            536,
+            792,
+            642
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We analyze the learned algorithms to understand their beneficial effect on performance. In Figure 5, we compare the estimated Q-values for each algorithm. We see that DQN frequently overestimates the Q values while DDQN consistently underestimates the Q values before converging to the ground truth Q value which are computed with a manually designed optimal policy. DQNClipped has similar performance to DDQN, in that it also consistently underestimates the Q values and does so slightly more aggressively than DDQN. DQNReg significantly undershoots the Q values and does not converge to the ground truth. Various works (van Hasselt et al., 2015; Haarnoja et al., 2018; Fujimoto et al., 2018) have shown that overestimated value estimates is problematic and restricting the overestimation improves performance. ",
+        "bbox": [
+            174,
+            726,
+            825,
+            851
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The loss function in DQNClipped is composed of the sum of two max operations, and so we can analyze when each update rule is active. We interpret DQNClipped as $\\operatorname* { m a x } ( v _ { 1 } , v _ { 2 } ) + \\operatorname* { m a x } ( v _ { 2 } , v _ { 3 } )$ with four cases: 1) $v _ { 1 } ~ > ~ v _ { 2 }$ and $v _ { 3 } > v _ { 4 } 2$ ) $v _ { 1 } > v _ { 2 }$ and $v _ { 3 } < v _ { 4 } 3$ ) $v _ { 1 } < v _ { 2 }$ and $v _ { 3 } < v _ { 4 } 4 )$ $v _ { 1 } < v _ { 2 }$ and $v _ { 3 } > v _ { 4 }$ . Case 2 corresponds to minimizing the $\\mathrm { Q }$ values. Case 3 would correspond to the normal DQN loss of $\\delta ^ { 2 }$ since the parameters of $Q _ { t a r g }$ are not updated during gradient descent. ",
+        "bbox": [
+            174,
+            858,
+            823,
+            929
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 6, we plot the proportion of when each case is active during training. We see that usually case 3 is generally the most active with a small dip in the beginning but then stays around $9 5 \\%$ . Meanwhile, case 2, which regularizes the $\\mathrm { Q }$ -values, has a small increase in the beginning and then decreases later, matching with our analysis in Figure 6, which shows that DQNClipped strongly underestimates the $\\mathrm { Q }$ -values in the beginning of training. This can be seen as a constrained optimization where the amount of Q-value regularization is tuned accordingly. The regularization is stronger in the beginning of training when overestimation is problematic $( Q ( \\bar { s _ { t } } , a _ { t } ) \\bar { > } \\delta ^ { 2 } + Y _ { t } )$ and gets weaker as $\\delta ^ { 2 }$ gets smaller. ",
+        "bbox": [
+            174,
+            104,
+            573,
+            270
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/6524cdbf2665146037b451be54123f7f39980d070493adc0580446f060dc2031.jpg",
+        "image_caption": [
+            "Figure 6: Our learned algorithm, DQNClipped, can be broken down into four update rules where each rule is active under certain conditions. Case 3 corresponds to normal TD learning while case 2 corresponds to minimizing the Q-values. Case 2 is more active in the beginning when value overestimation is a problem and then becomes less active as it is no longer needed. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            625,
+            88,
+            779,
+            174
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            290,
+            318,
+            306
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we have presented a method for learning reinforcement learning algorithms. We design a general language for representing algorithms which compute the loss function for value-based model-free RL agents to optimize. We highlight two learned algorithms which although relatively simple, can obtain good generalization performance over a wide range of environments. Our analysis of the learned algorithms sheds insight on their benefit as regularization terms which are similar to recently proposed algorithms. Our work is limited to discrete action and value-based RL algorithms that are close to DQN, but could easily be expanded to express more general RL algorithms such as actor-critic or policy gradient methods. How actions are sampled from the policy could also be part of the search space. The set of environments we use for both training and testing could also be expanded to include a more diverse set of problem types. We leave these problems for future work. ",
+        "bbox": [
+            173,
+            320,
+            825,
+            460
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            481,
+            366,
+            494
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We thank Luke Metz for helpful early discussions and feedback on the paper, Hanjun Dai for early discussions on related research ideas, and Xingyou Song, Krzysztof Choromanski, and Kevin Lee for help with infrastructure. We also thank Jongwook Choi for help with environment selection. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            553
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            573,
+            285,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ferran Alet, M. F. Schneider, Tomas Lozano-Perez, and L. Kaelbling. Meta-learning curiosity algorithms. ArXiv, abs/2003.05325, 2020a.   \nFerran Alet, Martin F. Schneider, Tomas Lozano-Perez, and Leslie Pack Kaelbling. Meta-learning curiosity algorithms. In International Conference on Learning Representations, 2020b. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ BygdyxHFDS.   \nIrwan Bello, Barret Zoph, Vijay Vasudevan, and Quoc V Le. Neural optimizer search with reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 459–468. JMLR. org, 2017.   \nS. Bengio, Yoshua Bengio, and J. Cloutier. Use of genetic programming for the search of a new learning rule for neural networks. Proceedings of the First IEEE Conference on Evolutionary Computation. IEEE World Congress on Computational Intelligence, pp. 324–327 vol.1, 1994.   \nYoshua Bengio, S. Bengio, and J. Cloutier. Learning a synaptic learning rule. IJCNN-91-Seattle International Joint Conference on Neural Networks, ii:969 vol.2–, 1991.   \nHan Cai, Tianyao Chen, Weinan Zhang, Yong Yu, and Jun Wang. Efficient architecture search by network transformation. In Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, (AAAI-18), the 30th innovative Applications of Artificial Intelligence (IAAI-18), and the 8th AAAI Symposium on Educational Advances in Artificial Intelligence (EAAI-18), New Orleans, Louisiana, USA, February 2-7, 2018, pp. 2787–2794, 2018.   \nYevgen Chebotar, Artem Molchanov, Sarah Bechtle, Ludovic Righetti, F. Meier, and Gaurav S. Sukhatme. Meta-learning via learned loss. ArXiv, abs/1906.05374, 2019. ",
+        "bbox": [
+            171,
+            595,
+            826,
+            928
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Maxime Chevalier-Boisvert, Lucas Willems, and Suman Pal. Minimalistic gridworld environment for openai gym. https://github.com/maximecb/gym-minigrid, 2018. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yan Duan, John Schulman, Xi Chen, Peter L. Bartlett, Ilya Sutskever, and P. Abbeel. Rl2: Fast reinforcement learning via slow reinforcement learning. ArXiv, abs/1611.02779, 2016. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas Elsken, Jan Hendrik Metzen, and Frank Hutter. Neural architecture search: A survey. arXiv preprint arXiv:1808.05377, 2018. ",
+        "bbox": [
+            173,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aleksandra Faust, Anthony Francis, and Dar Mehta. Evolving rewards to automate reinforcement learning. arXiv preprint arXiv:1905.07628, 2019. ",
+        "bbox": [
+            173,
+            217,
+            825,
+            247
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn and S. Levine. Meta-learning and universality: Deep representations and gradient descent can approximate any learning algorithm. ArXiv, abs/1710.11622, 2018. ",
+        "bbox": [
+            173,
+            256,
+            825,
+            285
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, P. Abbeel, and S. Levine. Model-agnostic meta-learning for fast adaptation of deep networks. ArXiv, abs/1703.03400, 2017. ",
+        "bbox": [
+            173,
+            292,
+            823,
+            323
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jorg K. H. Franke, Gregor K ¨ ohler, Andr ¨ e Biedenkapp, and Frank Hutter. Sample-efficient automated ´ deep reinforcement learning. 2020. ",
+        "bbox": [
+            173,
+            330,
+            823,
+            361
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Scott Fujimoto, H. V. Hoof, and David Meger. Addressing function approximation error in actorcritic methods. ArXiv, abs/1802.09477, 2018. ",
+        "bbox": [
+            173,
+            369,
+            821,
+            398
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David E Goldberg and Kalyanmoy Deb. A comparative analysis of selection schemes used in genetic algorithms. FOGA, 1991. ",
+        "bbox": [
+            174,
+            406,
+            821,
+            436
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Toumas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In ICML, 2018. ",
+        "bbox": [
+            173,
+            445,
+            823,
+            476
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John H. Holland. Adaptation in Natural and Artificial Systems. University of Michigan Press, Ann Arbor, MI, 1975. second edition, 1992. ",
+        "bbox": [
+            174,
+            483,
+            823,
+            513
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rein Houthooft, Richard Y. Chen, Phillip Isola, Bradly C. Stadie, F. Wolski, Jonathan Ho, and P. Abbeel. Evolved policy gradients. ArXiv, abs/1802.04821, 2018. ",
+        "bbox": [
+            174,
+            521,
+            823,
+            551
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Frank Hutter, Lars Kotthoff, and Joaquin Vanschoren (eds.). Automated Machine Learning: Methods, Systems, Challenges. Springer, 2018. In press, available at http://automl.org/book. ",
+        "bbox": [
+            173,
+            559,
+            823,
+            589
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shauharda Khadka and Kagan Tumer. Evolution-guided policy gradient in reinforcement learning. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 1188–1200. Curran Associates, Inc., 2018. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            655
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Louis Kirsch, Sjoerd van Steenkiste, and J. Schmidhuber. Improving generalization in meta reinforcement learning using learned objectives. ArXiv, abs/1910.04098, 2020. ",
+        "bbox": [
+            173,
+            662,
+            821,
+            693
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John Koza. Genetic programming - on the programming of computers by means of natural selection. In Complex adaptive systems, 1993. ",
+        "bbox": [
+            173,
+            702,
+            821,
+            731
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aviral Kumar, Aurick Zhou, G. Tucker, and Sergey Levine. Conservative q-learning for offline reinforcement learning. ArXiv, abs/2006.04779, 2020. ",
+        "bbox": [
+            171,
+            739,
+            823,
+            768
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chenxi Liu, Barret Zoph, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan L. Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. CoRR, abs/1712.00559, 2017. URL http://arxiv.org/abs/1712.00559. ",
+        "bbox": [
+            176,
+            776,
+            823,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin A. Riedmiller. Playing atari with deep reinforcement learning. ArXiv, abs/1312.5602, 2013. ",
+        "bbox": [
+            174,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Matteo Hessel, Wojciech Marian Czarnecki, Zhongwen Xu, Hado van Hasselt, Satinder Singh, and David Silver. Discovering reinforcement learning algorithms. ArXiv, abs/2007.08794, 2020. ",
+        "bbox": [
+            173,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. In ICML, 2018. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thomas Pierrot, Guillaume Ligner, Scott Reed, Olivier Sigaud, Nicolas Perrin, Alexandre Laterre, David Kas, Karim Beguir, and Nando de Freitas. Learning compositional neural programs with recursive tree search and planning. NeurIPS, 2019. ",
+        "bbox": [
+            178,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon Suematsu, Jie Tan, Quoc V. Le, and Alexey Kurakin. Large-scale evolution of image classifiers. In Proceedings of the 34th International Conference on Machine Learning - Volume 70, ICML’17, pp. 2902–2911. JMLR.org, 2017. ",
+        "bbox": [
+            173,
+            193,
+            826,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V. Le. Regularized evolution for image classifier architecture search. In AAAI, volume abs/1802.01548, 2019. ",
+        "bbox": [
+            173,
+            257,
+            823,
+            287
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Chen Liang, David So, and Quoc V. Le. Automl-zero: Evolving machine learning algorithms from scratch. In ICML, volume abs/2003.03384, 2020. ",
+        "bbox": [
+            174,
+            295,
+            823,
+            325
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Scott Reed and Nando De Freitas. Neural programmer-interpreters. arXiv preprint arXiv:1511.06279, 2015. ",
+        "bbox": [
+            174,
+            333,
+            823,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Juergen Schmidhuber. Evolutionary principles in self-referential learning. 1987. ",
+        "bbox": [
+            173,
+            371,
+            700,
+            387
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Juergen Schmidhuber. A self-referential weight matrix. 1993. ",
+        "bbox": [
+            173,
+            395,
+            581,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017. ",
+        "bbox": [
+            171,
+            419,
+            825,
+            448
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "D. So, Chen Liang, and Quoc V. Le. The evolved transformer. ArXiv, abs/1901.11117, 2019. ",
+        "bbox": [
+            169,
+            457,
+            782,
+            472
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xingyou Song, Krzysztof Choromanski, Jack Parker-Holder, Yunhao Tang, Wenbo Gao, Aldo Pacchiano, Tamas Sarlos, Deepali Jain, and Yuxiang Yang. Reinforcement learning with chromatic networks for compact architecture search. 2020. ",
+        "bbox": [
+            174,
+            481,
+            821,
+            523
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002. ",
+        "bbox": [
+            173,
+            532,
+            820,
+            561
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yunhao Tang and Krzysztof Choromanski. Online hyper-parameter tuning in off-policy learning via evolutionary strategies, 2020. ",
+        "bbox": [
+            173,
+            570,
+            821,
+            599
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "L. Trujillo and G. Olague. Synthesis of interest point detectors through genetic programming. In GECCO ’06, 2006. ",
+        "bbox": [
+            173,
+            607,
+            823,
+            637
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. In AAAI, 2015. ",
+        "bbox": [
+            173,
+            645,
+            821,
+            674
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nino Vieillard, Olivier Pietquin, and M. Geist. Munchausen reinforcement learning. ArXiv, abs/2007.14430, 2020. ",
+        "bbox": [
+            173,
+            683,
+            821,
+            712
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jane X. Wang, Zeb Kurth-Nelson, Hubert Soyer, Joel Z. Leibo, Dhruva Tirumala, Remi Munos, ´ Charles Blundell, D. Kumaran, and Matt M. Botvinick. Learning to reinforcement learn. ArXiv, abs/1611.05763, 2017. ",
+        "bbox": [
+            173,
+            720,
+            825,
+            763
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "S. Whiteson and P. Stone. Evolutionary function approximation for reinforcement learning. J. Mach. Learn. Res., 7:877–917, 2006. ",
+        "bbox": [
+            173,
+            772,
+            823,
+            801
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. In ICLR, 2016. ",
+        "bbox": [
+            171,
+            810,
+            821,
+            825
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 8697–8710, 2018. ",
+        "bbox": [
+            174,
+            834,
+            825,
+            877
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A SEARCH LANGUAGE DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            459,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Inputs and outputs to nodes in the computational graph have data types which include state $\\mathbb { S }$ , action $\\mathbb { Z }$ , float $\\mathbb { R }$ , list $\\boldsymbol { L i s t [ \\mathbb { X } ] }$ , probability $\\mathbb { P }$ , vector $\\mathbb { V }$ . The symbol $\\mathbb { X }$ indicates it can be of $\\mathbb { S } , \\mathbb { R }$ , or $\\mathbb { V }$ . We assume that vectors are of fixed length 32 and actions are integers. Operations will broadcast so that for example adding a float variable to a state variable will result in the float being added to each element of the state. This typing allows the learned program to be domain agnostic. The full list of operators is listed below. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            217
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/d558da2575bfc9e1083b2b3fb44b01731ca5fb3b3d506baec80980aa73d18596.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=2>Input Types</td><td rowspan=1 colspan=1>Output Type</td></tr><tr><td rowspan=1 colspan=1>Add</td><td rowspan=1 colspan=2>X,X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Subtract</td><td rowspan=1 colspan=2>X, X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Max</td><td rowspan=1 colspan=2>X, X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Min</td><td rowspan=1 colspan=2>X,X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>DotProduct</td><td rowspan=1 colspan=2>X,X</td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>Div</td><td rowspan=1 colspan=2>X,X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>L2Distance</td><td rowspan=1 colspan=2>X,X</td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>MaxList</td><td rowspan=1 colspan=1>List[R]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>MinList</td><td rowspan=1 colspan=1>List[R]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>ArgMaxList</td><td rowspan=1 colspan=1>List[R]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Z</td></tr><tr><td rowspan=1 colspan=1>SelectList</td><td rowspan=1 colspan=1>List[X],Z</td><td rowspan=1 colspan=1>Z</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>MeanList</td><td rowspan=1 colspan=1>List[X]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>VarianceList</td><td rowspan=1 colspan=1>List[X]</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Log</td><td rowspan=1 colspan=2>X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Exp</td><td rowspan=1 colspan=2>X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Abs</td><td rowspan=1 colspan=2>X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>(C)NN:S → List[R]</td><td rowspan=1 colspan=2>S</td><td rowspan=1 colspan=1>List[R]</td></tr><tr><td rowspan=1 colspan=1>(C)NN:S → R</td><td rowspan=1 colspan=2>S</td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>(C)NN:S → V</td><td rowspan=1 colspan=2>V</td><td rowspan=1 colspan=1>V</td></tr><tr><td rowspan=1 colspan=1>Softmax</td><td rowspan=1 colspan=2>List[R]</td><td rowspan=1 colspan=1>P</td></tr><tr><td rowspan=1 colspan=1>KLDiv</td><td rowspan=1 colspan=2>P,P</td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>Entropy</td><td rowspan=1 colspan=2>P</td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>Constant</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>1, 0.5, 0.2,0.1, 0.01</td></tr><tr><td rowspan=1 colspan=1>MultiplyTenth</td><td rowspan=1 colspan=2>X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Normal(0, 1)</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>R</td></tr><tr><td rowspan=1 colspan=1>Uniform(0, 1)</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>R</td></tr></table>",
+        "bbox": [
+            295,
+            231,
+            700,
+            622
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            638,
+            374,
+            656
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We describe the training details and hyperparameters used. For all environments we use the Adam optimzier with a learning rate of 0.0001. ",
+        "bbox": [
+            174,
+            671,
+            823,
+            700
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Common RL training details. All neural networks are MLPs of size (256, 256) with ReLU activations. For optimizing the Q-function parameters we use the Adam optimizer with a learning rate of 0.0001. Target update period is 100. These settings are used for all training and test environments. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            750
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Classical control environments. The value of $\\epsilon$ is decayed linearly from 1 to 0.05 over 1000 steps. CartPole, Acrobat, and MountainCar are trained for 400 episodes and LunarLander is trained for 1000 episodes. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            797
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "MiniGrid environments. The value of $\\epsilon$ is decayed linearly from 1 to 0.05 over $1 0 ^ { 5 }$ steps. During meta-training, MiniGrid environments are trained for $5 * 1 0 ^ { \\mathrm { 5 } }$ steps. ",
+        "bbox": [
+            169,
+            804,
+            823,
+            833
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Atari environments. We use the same neural network architecture as in Mnih et al. (2013). Target update period is $1 , 0 0 0$ . The value of $\\epsilon$ is decayed linearly from 1 to 0.1 over $1 0 ^ { 6 }$ steps. For evaluation, we use the no-op start condition as in Mnih et al. (2013) where the agent will output the no-op action for $x$ steps where $x$ is a random integer drawn between [1, 30]. The evaluation policy uses an $\\epsilon$ of 0.001 and is evaluated every $1 0 ^ { 6 }$ steps for 100 episodes. The best training snapshot is reported. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C ENVIRONMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            415,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/1738f29790e26a970de71e8ab106e8b4954f57ecea2e6dc63c9bf732eebcde63.jpg",
+        "table_caption": [
+            "We describe the classical control environments below. CartPole and LunarLander are dense reward while Acrobat and MountainCar are sparse reward. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Task ID</td><td>Description</td></tr><tr><td></td><td>CartPole-v0</td><td>The agent must balance a pole on top of a cart by applying a force of +l or -1 to the cart. A reward of +1 is provided for each timestep the pole remains upright.</td></tr><tr><td></td><td>LunarLander-v2</td><td>The agent controls a lander by firing one of four thrusters and must land it on the landing pad.</td></tr><tr><td></td><td>Acrobat-v1</td><td>The goal is to swing a 2-link system upright to a given height by applying 1,O,or -1 torque on the join between the two links.</td></tr><tr><td></td><td>MountainCar-vO</td><td>The goal is to drive up the mountain on the right by first driving back and forth to build up momentum.</td></tr></table>",
+        "bbox": [
+            178,
+            169,
+            816,
+            513
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We describe the MiniGrid environments below. The input to the agent is a fully observed grid which is encoded as an NxNx3 size array where $_ \\mathrm { N }$ is the grid size. The 1st channel contains the index of the object type at that location (out of 11 possible objects), the 2nd channel contains the color of the object (out of 6 possible colors), and the 3rd channel contains the orientation of the agent out of 4 cardinal directions. This encoding is then flattened and fed into an MLP. There are 7 possible actions (turn left, turn right, forward, pickup, drop, toggle, done). ",
+        "bbox": [
+            173,
+            520,
+            825,
+            604
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Unless stated otherwise, all tasks are sparse reward tasks with a reward of 1 for completing the task. Max steps is set to 100. A size such as 5x5 in the environment name refers to a grid size with width and height of 5 cells. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            654
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/941ca87dcf9662faf56867bec351c83da45a1d4833d4cdb6d7611a59ccfb6374.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Task ID</td><td>Description</td></tr><tr><td>自V日</td><td>KeyCorridorS3R1-v0</td><td>The agent has to find a key hidden in one room and then use it to pickup an object be- hind a locked door in another room． This tests sequential subgoal completion.</td></tr><tr><td>. 333333 ?</td><td>LavaGapS5-v0</td><td>The agent has to reach the green goal square without touching the lava which will termi- nate the episode with zero reward. This tests safety and safe exploration.</td></tr><tr><td></td><td>MultiRoom-N2-S4-v0</td><td>The agent must open a door to get to the green goal square in the next room.</td></tr></table>",
+        "bbox": [
+            181,
+            666,
+            820,
+            895
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/0d5612435d69d07f6640c6a3b9d2223a8ee53fd55e3ba16b8a44533c9fe1d63d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>SimpleCrossingS9N1- v0</td><td>The agent has to reach the green goal square on the other corner of the room and navigate around walls.</td></tr><tr><td>Empty-v0</td><td>The agent has to reach the green goal square in an empty room.</td></tr><tr><td>EmptyRandom-v0</td><td>The agent has to reach the green goal square in an empty room but is initialized to a ran- dom location.</td></tr><tr><td>Dynamic-Obstacles-v0</td><td>The agent has to reach the green goal square without colliding with any blue obstacles which move around randomly. If the agent collides with an obstacle it receives a reward of -1 and the episode terminates.</td></tr><tr><td>FourRooms-v0</td><td>The agent must navigate in a maze com- posed of four rooms. Both the agent and goal square are randomly placed in any of the four rooms.</td></tr><tr><td>DoorKey-v0</td><td>The agent must pick up a key to unlock a door to enter another room and get to the green goal square.</td></tr></table>",
+        "bbox": [
+            328,
+            74,
+            813,
+            580
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/00e0bc3d8324d6a6475d53ece87f0bdcf3e1da16a3fe55ae5c248aa65ad035dc.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            99,
+            287,
+            573
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D GRAPH DISTRIBUTION ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            490,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We look at the distribution of top performing graphs and find similarities in their structure. This is summarized in Table 3 where we describe the equations of learned algorithms for differing ranks (if sorted by score). The best performing algorithms from the experiment which learned DQNReg are all variants of adding $Q ( s _ { t } , a _ { t } )$ to the standard TD loss in some form, $\\delta ^ { 2 } + k * Q ( s _ { t } , a _ { t } )$ . We think this kind of loss could use further investigation and that while we did not tune the value of $k$ , this could also be tuned per environment. In Figure 3b, we show the distribution of scores for all nonduplicate programs that have been evaluated. We provide a full list of top performing algorithms from a few of our experiments at https://github.com/jcoreyes/evolvingrl. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            246
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/f64371ca1e906ef09c0d8295652f18cc98532b31177b218f7f19024bf90a1f84.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Raw Equation</td><td>Simplified Equation</td><td>Score</td><td>Rank</td></tr><tr><td>δ²+0.1*Q(st,at)+Tt-(γ*Qtarg-0.1*Q(st,at))</td><td>δ²+0.2*Q(st,at)</td><td>3.905</td><td>2</td></tr><tr><td>δ²+0.1*Q(st,at)-γ+Qtarg</td><td>δ²+0.1*Q(st,at)</td><td>3.904</td><td>3</td></tr><tr><td>δ²-(γ *Qtarg-0.1*Q(st,at))</td><td>δ²+0.1*Q(st,at)</td><td>3.903</td><td>4</td></tr><tr><td>δ²+Qtarg+0.1 * Q(st,at)-γ</td><td>δ²+0.1*Q(st,at)</td><td>3.902</td><td>5</td></tr><tr><td>δ²-(0.1*Q(st,at)-Yt)²</td><td>δ²-(0.1*Q(st,at)-Yt)²</td><td>3.898</td><td>6</td></tr><tr><td>δ²+((rt+γ*Qtarg+Q(st,at))*(γ-max(γ,0.1*Q(st,at)) -γ *Qtarg-0.1*Q(st,at))</td><td>NA</td><td>3.846</td><td>11146</td></tr><tr><td>δ²+(δ²+0.1*Q(st,at))²</td><td>NA</td><td>3.65</td><td>12146</td></tr><tr><td>δ²+Q(st,at)</td><td>8²+Q(st,at)</td><td>2.8</td><td>12446</td></tr><tr><td>2</td><td>82</td><td>2.28</td><td>13246</td></tr></table>",
+        "bbox": [
+            207,
+            256,
+            838,
+            377
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Other programs learned in learning DQNReg which is rank 1 with score 3.907. Rank is if scores are sorted in decreasing order. Score is the sum of normalized RL training performance across four environments. The simplified equations contains only the relevant parts for minimizing the equation output. $Q _ { t a r g }$ refers to $\\begin{array} { r } { \\operatorname* { m a x } _ { a } Q _ { t a r g } ( s _ { t + 1 } , a ) } \\end{array}$ . ",
+        "bbox": [
+            173,
+            387,
+            825,
+            445
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "E REPEATABILITY OF META TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            489,
+            514,
+            506
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In Figure 7, we plot the meta-training performance for bootstrapping from DQN with four training environments (CartPole, KeyCorridorS3R1, Dynamic-Obstacles-6x6, DoorKey-5x5) over ten trials. Four out of the ten trials reach the max training performance. Two out of 10 of these trials learns the same algorithm DQNReg while the other top two trials find other less interpretable algorithms. ",
+        "bbox": [
+            174,
+            521,
+            825,
+            578
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/9506b9b0e91f539451c35d6ceeb80fc879ecb6fa00d4fdf76addca3c58e47581.jpg",
+        "image_caption": [
+            "Figure 7: Meta-training performance for boot-strapping on 4 training environments for 10 random seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            339,
+            594,
+            655,
+            768
+        ],
+        "page_idx": 14
+    }
+]

parse/train/H1MW72AcK7/H1MW72AcK7.md

@@ -0,0 +1,412 @@
+# OPTIMAL CONTROL VIA NEURAL NETWORKS: ACONVEX APPROACH
+
+Yize Chen∗, Yuanyuan Shi∗, Baosen Zhang   
+Department of Electrical and Computer Engineering,   
+University of Washington,   
+Seattle, WA 98195, USA   
+{yizechen, yyshi, zhangbao}@uw.edu
+
+# ABSTRACT
+
+Control of complex systems involves both system identification and controller design. Deep neural networks have proven to be successful in many identification tasks, however, from model-based control perspective, these networks are difficult to work with because they are typically nonlinear and nonconvex. Therefore many systems are still identified and controlled based on simple linear models despite their poor representation capability. In this paper we bridge the gap between model accuracy and control tractability faced by neural networks, by explicitly constructing networks that are convex with respect to their inputs. We show that these input convex networks can be trained to obtain accurate models of complex physical systems. In particular, we design input convex recurrent neural networks to capture temporal behavior of dynamical systems. Then optimal controllers can be achieved via solving a convex model predictive control problem. Experiment results demonstrate the good potential of the proposed input convex neural network based approach in a variety of control applications. In particular we show that in the MuJoCo locomotion tasks, we could achieve over $10 \%$ higher performance using $5 \times$ less time compared with state-of-the-art model-based reinforcement learning method; and in the building HVAC control example, our method achieved up to $20 \%$ energy reduction compared with classic linear models.
+
+# 1 INTRODUCTION
+
+Decisions on how to best operate and control complex physical systems such as the power grid, commercial and industrial buildings, transportation networks and robotic systems are of critical societal importance. These systems are often challenging to control because they tend to have complicated and poorly understood dynamics, sometimes with legacy components are built over a long period of time (Wolf, 2009). Therefore detailed models for these systems may not be available or may be intractable to construct. For instance, since buildings account for $40 \%$ of the global energy consumption (Cheng et al., 2008), many approaches have been proposed to operate buildings more efficiently by controlling their heating, ventilation, and air conditioning (HVAC) systems (Zhang et al., 2017). Most of these methods, however, suffer from two drawbacks. On one hand, a detailed physics model of a building can be used to accurately describe its behavior, but this model can take years to develop. On the other hand, simple control algorithms have been developed by using linear (RC circuit) models (Ma et al., 2012) to represent buildings, but the performance of these models may be poor since the building dynamics can be far from linear (Shaikh et al., 2014).
+
+In this paper, we leverage the availability of data to strike a balance between requiring painstaking manual construction of physics based models and the risk of not capturing rich and complex system dynamics through models that are too simplistic. In recent years—with the growing deployment of sensors in physical and robotics systems—large amount of operational data have been collected, such as in smart buildings (Suryadevara et al., 2015), legged robotics (Meger et al., 2015) and manipulators (Deisenroth et al., 2011). Using these data, the system dynamics can be learned directly and then automatically updated at periodic intervals. One popular method is to parameterize these complex system dynamics using deep neural networks to capturing complex relationships (He et al., 2016; Vaswani et al., 2017), yet few research investigated how to integrate deep learning models into real-time closed-loop control of physical systems.
+
+A key reason that deep neural networks have not been directly applied in control is that even though they provide good performances in learning system behaviors, optimization on top of these networks is challenging (Kawaguchi, 2016). Neural networks, because of their structures, are generally not convex from input to output. Therefore, many control applications (e.g., where real-time decisions need to be made) choose to favor the computational tractability offered by linear models despite their poor fitting performances.
+
+In this paper we tackle the modeling accuracy and control tractability tradeoff by building on the input convex neural networks (ICNN) in (Amos et al., 2017) to both represent system dynamics and to find optimal control policies. By making the neural network convex from input to output, we are able to obtain both good predictive accuracies and tractable computational optimization problems. The overall methodology is shown in Fig. 1. Our proposed method (shown in Fig. 1 (b)) firstly utilizes an input convex network model to learn the system dynamics and then computes the best control decisions via solving a convex model predictive control (MPC) problem, which is tractable and has optimality guarantees. This is different from existing methods that uses model-free end-to-end controller which directly maps input to output (shown in Fig. 1 (a)). Another major contribution of our work is that we explicitly prove that ICNN can represent all convex functions and systems dynamics, and is exponentially more efficient than widely used convex piecewise linear approximations (Magnani & Boyd, 2009).
+
+![](images/97b28d412c0e504b22757e4eacc5dcfc5a1d9698924463e863d4919e2bddf2a8.jpg)  
+Figure 1: Our proposed model-based method, (a) an input convex neural network is first trained to learn the system dynamics, then (b) we solve a convex predictive control problem to find the optimal actions which are input convex neural networks’ inputs. The optimization steps are also based on objectives and dynamics constraints represented by the trained networks.
+
+# 1.1 RELATED WORK
+
+The work in (Amos et al., 2017) was an impetus for this paper. The key differences are that the goal in (Amos et al., 2017) is to show that ICNN can achieve similar classification performances as conventional neural networks and how the former can be used in inference and prediction problems. Our goal is to use these networks for optimization and closed-loop control, and in a sense that we are more interested in the overall system performances and not directly the performance of the networks. We also extend the class of networks to include RNNs to capture dynamical systems.
+
+Control and decision-making have used deep learning mainly in model-free end-to-end controller settings (shown in Fig. 1 (a)), such as sequential decision making in game (Mnih et al., 2013), robotics manipulation (Levine & Koltun, 2014; Levine et al., 2016), and control of cyber-physical systems (Wei et al., 2017; O’Neill et al., 2010). However, much of the success relies heavily on a reinforcement learning setup where the optimal state-action relationship can be learned via a large number of samples. However, many physical systems do not fit into the reinforcement learning process, where both the sample collection is limited by real-time operations, and there are physical model constraints hard to represent efficiently.
+
+To address the above sample efficiency, safety and model constraints incompatibility concerns faced by model-free reinforcement learning algorithms in physical system control, we consider a model-based control approach in this work. Model-based control algorithms often involve two stages – system identification and controller design. For the system identification stage, the goal is to learn a fixed form of system model to minimize some prediction error (Ljung, 1998). Most efficient model-based control algorithms have used a relatively simple function estimator for the system dynamics identification (Nagabandi et al., 2018), such as linear model (Ma et al., 2012) and Gaussian processes (Meger et al., 2015; Deisenroth et al., 2011). These simplified models are sample-efficient to learn, and can be nicely incorporated in the sub-sequent optimal control problems. However, such simple models may not have enough representation capacity in modeling large-scale or high-dimension systems with nonlinear dynamics. Deep neural networks (DNNs) feature powerful representation capability, while the main challenge of using DNNs for system identification is that such models are typically highly non-linear and non-convex (Kawaguchi, 2016), which causes great difficulty for following decision making. A recent work from (Nagabandi et al., 2018) is close in spirit as our proposed method. Similarly, the authors use a model-based approach for robotics control, where they first fit a neural network for the system dynamics and then use the fitted network in an MPC loop. However, since (Nagabandi et al., 2018) use conventional NN for system identification, they cannot solve the MPC problem to global optimality. Our work shows how the proposed ICNN control algorithm achieves the benefits from both sides of the world. The optimization with respect to inputs can be implemented using off-the-shelf deep learning optimizers, while we are able to obtain good identification accuracies and tractable computational optimization problems by using proposed method at the same time.
+
+# 2 CLOSED-LOOP CONTROL WITH INPUT CONVEX NEURAL NETWORKS
+
+In this paper, we consider the settings where a neural network is used in a closed-loop system. The fundamental goal is to optimize system performance which is beyond the learning performance of network on its own. In this section we describe how input convex neural networks (ICNN) can be extremely useful in these systems by considering two related problems. First, we show how ICNN perform in single-shot optimization problems. Then we extend the results to an input convex recurrent neural networks (ICRNN), which allows us to both capture systems’ complex dynamics and make time-series decisions.
+
+![](images/14c0f871aead409676edce2e1cc8357e16c5b230fe25ca8397f144d6ded44702.jpg)  
+Figure 2: Input convex neural network. Input convex neural network. (a) Input convex feed-forward neural networks (ICNN). One notable addition is the direct “passthrough” layers $\mathbf { D } _ { 2 : k }$ that connect the inputs to hidden units for better model representation ability. (b) The proposed input convex recurrent neural networks (ICRNN) architectures. In our control settings, we keep all weights in both networks nonnegative, while expanding the inputs with $- \mathbf { u }$ .
+
+# 2.1 SINGLE-SHOT PROBLEM
+
+The following proposition states a simple sufficient condition for a neural network to be input convex:
+
+Proposition 1. The feedforward neural network in Fig. 2(a) is convex from input to output given that all weights between layers $\mathbf { W } _ { 1 : k }$ and weights in the “passthrough” layers $\mathbf { D } _ { 2 : k }$ are non-negative, and all of the activation functions are convex and nondecreasing (e.g. ReLU).
+
+The structure of the input convex neural network (ICNN) structure in Proposition 1 is motivated by the structure in (Amos et al., 2017) but modified to be more suitable to control of dynamical systems. In (Amos et al., 2017) it only requires $\mathbf { W } _ { 2 : k }$ to be non-negative while having no restrictions on weights $\mathbf { W } _ { 1 }$ and $\mathbf { D } _ { 2 : k }$ . Our construction achieves the exact representation by expanding the inputs to include both u $( \in \mathbb { R } ^ { d } )$ and $- \mathbf { u }$ . Then any negative weights in $\mathbf { W } _ { 1 }$ and $\mathbf { D } _ { 2 : k }$ in (Amos et al., 2017)’s ICNN structure is set to zero and its negation (which is positive) is added as the weight for corresponding $- \mathbf { u }$ . The reason for our construction is to allow the network to be “rolled out in time” when we are dealing with dynamical systems and multiple networks need to be composed together.
+
+An simple example that demonstrates how the proposed ICNN can be used to fit a convex function comes form fitting the $| u |$ function. This function is convex and both decreasing and increasing. Let the activation function be $R e L U ( \cdot ) = \operatorname* { m a x } ( \cdot , 0 )$ . We can write $| u | = - u + 2 R e L U ( u )$ (Amos et al., 2017). However, in this representation, we need a negative weight, the $^ { - 1 }$ in front of $u$ , and this would be troublesome if we compose several networks together. In our proposed ICNN structure with all positive weights and input negation duplicates, we can write $| \boldsymbol { u } | = \overset { \cdot } { \boldsymbol { \nu } } + 2 R e L U ( \boldsymbol { u } )$ , where we impose a constraint $\nu = - u$ . Such doubline on the number of input variables may potentially make the network harder to train. Yet during control, having all of the weights positive maintains the convexity between inputs and outputs even if multiple steps are considered which will be discussed in Section 2.2. The constraint $\nu = - u$ is linear and can be easily included in any convex optimization.
+
+This proposition follows directly from composition of convex functions (Boyd & Vandenberghe, 2004). Although it allows for any increasing convex activation functions, in this paper we work with the popular ReLU activation function. Two notable additions in ICNN compared with conventional feedforward neural networks are: 1) Addition of the direct “passthrough” layers connecting inputs to hidden layers and conventional feedforward layers connecting hidden layers for better representation power. 2) the expanded inputs that include both u and $- \mathbf { u }$ . The proposed ICNN structure is shown in Fig. 2(a). Note that such construction guarantees that the network is convex and non-decreasing with respect to the expanded inputs $\hat { \mathbf { u } } = \left[ \begin{array} { l } { \mathbf { u } } \\ { - \mathbf { u } } \end{array} \right]$ , while the output can achieve either decreasing or non-decreasing functions over u.
+
+Fundamentally, ICNN allows us to use neural networks in decision making processes by guaranteeing the solution is unique and globally optimal. Since many complex input and output relationships can be learned through deep neural networks, it is natural to consider using the learned network in an optimization problem in the form of
+
+$$
+\begin{array} { l } { \displaystyle \operatorname* { m i n } _ { \mathbf { u } } f ( \mathbf { u } ; \mathbf { W } ) } \\ { \displaystyle \mathrm { s . t . } \ \mathbf { u } \in \mathcal { U } , } \end{array}
+$$
+
+where $\boldsymbol { \mathcal U }$ is a convex feasible space. Then if $f$ is an ICNN, optimizing over $\mathbf { u }$ is a convex problem, which can be solved efficiently to global optimality. Note that we will always duplicate the variables by introducing $\mathbf { v } = - \mathbf { u }$ , but again this does not change the convexity of the problem. Of course, since the weights of the network are restricted to be nonnegative, the performance of the network (e.g., classification) may be worse. A common thread we observe in this paper is that trading off classification performance with tractability can be preferable.
+
+# 2.2 CLOSED-LOOP CONTROL AND RECURRENT NEURAL NETWORKS
+
+In addition to the single-shot optimization problem in (1), we are interested in optimally controlling a dynamical system. To model the temporal dependency of the system dynamics, we propose to use recurrent neural networks (instead of feed-forward neural networks). Recurrent networks carry an internal state of the system, which introduces coupling with previous inputs to the system. Fig. 2(b) shows the proposed input convex recurrent neural networks (ICRNN) structure. This network maps from input $\hat { \mathbf { u } }$ to output $y$ with memory unit $\mathbf { z }$ according to the following Eq. (2),
+
+$$
+\begin{array} { r l } & { \mathbf { z } _ { t } = \sigma _ { 1 } \left( \mathbf { U } \hat { \mathbf { u } } _ { t } + \mathbf { W } \mathbf { z } _ { t - 1 } + \mathbf { D } _ { 2 } \hat { \mathbf { u } } _ { t - 1 } \right) , } \\ & { y _ { t } = \sigma _ { 2 } \left( \mathbf { V } \mathbf { z } _ { t } + \mathbf { D } _ { 1 } \mathbf { z } _ { t - 1 } + \mathbf { D } _ { 3 } \hat { \mathbf { u } } _ { t } \right) , } \end{array}
+$$
+
+where $\hat { \mathbf { u } } = \left[ \mathbf { \Pi } _ { - \mathbf { u } } ^ { \mathbf { u } } \right]$ , and $D _ { 1 } , D _ { 2 } , D _ { 3 }$ are added direct “passthrough” layers for augmenting representation power. If we unroll the dynamics with respect to time, we have $y _ { t } = f ( \hat { \mathbf { u } } _ { 1 } , \hat { \mathbf { u } } _ { 2 } , . . . , \hat { \mathbf { u } } _ { t } ; \boldsymbol { \theta } )$ where $\theta =$
+
+$[ \mathbf { U } , \mathbf { V } , \mathbf { W } , \mathbf { D } _ { 1 } , \mathbf { D } _ { 2 } , \mathbf { D } _ { 3 } ]$ are network parameters, and $\sigma _ { 1 } , \sigma _ { 2 }$ denote the nonlinear activation functions.   
+The next proposition states a sufficient condition for the network to be input convex.
+
+Proposition 2. The network shown in Fig. $2 ( b )$ is a convex function from inputs to output if all weights $U , V , W , D _ { 1 } , D _ { 2 } , D _ { 3 }$ are non-negative, and all activation functions are convex and nondecreasing (e.g. ReLU).
+
+The proof of this proposition again follows directly from the composition rule of convex functions. Similarly to the ICNN case, by expanding the inputs vector to include both $\mathbf { u }$ and $- \mathbf { u }$ and restricting all weights to be non-negative, the resulted ICRNN structure is a convex and non-decreasing mapping from inputs to output.
+
+The proposed ICRNN structure can be leveraged to represent system dynamics for close-loop control. Consider a physical system with discrete-time dynamics, at time step $t$ , let’s define $\mathbf { s } _ { t }$ as the system states, $\mathbf { u } _ { t }$ as the control actions, and $y _ { t }$ as the system output. For example, for the real-time control of a building system, $\mathbf { s } _ { t }$ includes the room temperature, humidity, etc; $\mathbf { u } _ { t }$ denotes the building appliance scheduling, room temperature set-points, etc; and output $y _ { t }$ is the building energy consumption. In addition, there maybe exogenous variables that impact the output of the system, for example, outside temperature will impact the energy consumption of the building. However, since the exogenous variables are not impacted by any of the control actions we take, we suppress them in the formulation below. The time evolution of a system is described by
+
+$$
+\begin{array} { r } { y _ { t } = f ( \mathbf { s } _ { t } , \mathbf { u } _ { t } ) , } \\ { \mathbf { s } _ { t + 1 } = g ( \mathbf { s } _ { t } , \mathbf { u } _ { t } ) } \end{array}
+$$
+
+where (4b) describes the coupling between the current inputs to the future system states. Physical systems described by (4) may have significant inertia in the sense that the outcome of any control actions is delayed in time and there are significant couplings across time periods.
+
+Since we use ICRNNs to represent both the system dynamics $g ( \cdot )$ and the output $f ( \cdot )$ , the control variable u expands as uˆ . The optimal receding horizon control problem at time $t$ can be written as,
+
+$$
+\begin{array} { r l } { \underset { \mathbf { u } , \mathbf { u } + 1 , \mathbf { u } + 1 } { \mathrm { m i n i m i z e } } } & { C ( \hat { \mathbf { x } } , \mathbf { y } ) = \overset { t + T } { \underset { \mathbf { u } \in \mathcal { I } } { \sum } } J ( \hat { \mathbf { x } } _ { \tau } , y _ { \tau } ) } \\ { \mathrm { s u b j e c t ~ t o } } & { y _ { \tau } = f ( \hat { \mathbf { x } } _ { \tau - n _ { w } } , \hat { \mathbf { x } } _ { \tau - n _ { w } + 1 } , \dots , \hat { \mathbf { x } } _ { \tau } ) , \forall \tau \in [ t , t + T ] } \\ & { \mathbf { s } _ { \tau } = g ( \hat { \mathbf { x } } _ { \tau - n _ { w } } , \hat { \mathbf { x } } _ { \tau - n _ { w } + 1 } , \dots , \hat { \mathbf { x } } _ { \tau - 1 } , \hat { \mathbf { u } } _ { \tau } ) , \forall \tau \in [ t , t + T ] } \\ & { \hat { \mathbf { x } } _ { \tau } = \left[ \underset { \mathbf { u } \tau } { \hat { \mathbf { s } } _ { \tau } } \right] , \ \hat { \mathbf { u } } _ { \tau } = \left[ \mathbf { u } _ { \tau } \right] , \forall \tau \in [ t , t + T ] } \\ & { \mathbf { v } _ { \tau } = - \mathbf { u } _ { \tau } , \forall \tau \in [ t , t + T ] } \\ & { \mathbf { s } _ { \tau } \in \mathcal { I } _ { f o o s h b l e } , \forall \tau \in [ t , t + T ] } \\ & { \mathbf { u } _ { \tau } \in \mathcal { U } _ { f o o s h b l e } , \forall \tau \in [ t , t + T ] } \end{array}
+$$
+
+where a new variable $\hat { \mathbf { x } } = \left[ \mathbf { s } _ { t } , \hat { \mathbf { u } } _ { t } \right]$ is introduced for notational simplicity, which called system inputs. It is the collection of system states $\mathbf { s } _ { t }$ and duplicated control actions $\mathbf { u } _ { t }$ and $- \mathbf { u } _ { t }$ , therefore ensuring the mapping from ${ \bf u } _ { t }$ to any future states and outputs remains convex. $J ( \hat { \mathbf { x } } _ { \tau } , y _ { \tau } )$ is the control system cost incurs at time $\tau$ , that is a function of both the system inputs $\hat { \mathbf { x } } _ { \tau }$ and output $y _ { \tau }$ . The functions $f ( \cdot )$ and $g ( \cdot )$ in Eq. (5b)-(5c) are parameterized as ICRNNs, which represent the system dynamics from sequence of inputs $\big ( \hat { \mathbf { x } } _ { \tau - n _ { w } } , \hat { \mathbf { x } } _ { \tau - n _ { w } + 1 } , . . . , \hat { \mathbf { x } } _ { \tau } \big )$ to the system output $y _ { \tau }$ , and the dynamics from control actions to system states, respectively. $n _ { w }$ is the memory window length of the recurrent neural network. The equations (5d) and (5e) duplicate the input variables $\mathbf { u }$ and enforce the consistency condition between $\mathbf { u }$ and its negation v. Lastly, (5f) and $( 5 \mathrm { g } )$ are the constraints on feasible system states and control actions respectively. Note that as a general formulation, we do not include the duplication tricks on state variables, so the dynamics fitted by (5b) and (5c) are non-decreasing over state space, which are not equivalent to those dynamics represented by linear systems. However, since we are not restricting the control space, and we have explicitly included multiple previous states in the system transition dynamics, so the non-decreasing constraint over state space should not restrict the representation capacity by much. In Section.3 we theoretically prove the representability of proposed networks.
+
+Optimization problem in (5) is a convex optimization with respect to (w.r.t.) inputs $\mathbf { u } = [ \mathbf { u } _ { t } , . . . , \mathbf { u } _ { t + T } ]$ provided the cost function $J ( \hat { \mathbf { x } } _ { \tau } , y _ { \tau } ) = J ( \mathbf { s } _ { \tau } , \hat { \mathbf { u } } _ { \tau } , y _ { \tau } )$ is convex w.r.t. $\hat { \mathbf { u } } _ { \tau }$ , and convex, nondecreasing w.r.t. $\mathbf { s } _ { \tau }$ and $y _ { \tau }$ . A problem is convex if and only if both the objective function and constraints are convex. In the above problem, $J ( \mathbf { s } _ { \tau } , \hat { \mathbf { u } } _ { \tau } , y _ { \tau } )$ is convex and nondecreasing w.r.t. $\mathbf { s } _ { \tau }$ and $y _ { \tau } ; \mathbf { s } _ { \tau }$ and $y _ { \tau }$ are parameterized as ICRNNs, i.e., (5a) and (5b), such that they are convex w.r.t. $\hat { \mathbf { u } } _ { \tau }$ . Therefore following the composition rule of convex functions, the objective function is convex w.r.t. inputs $\mathbf { u } = [ \mathbf { u } _ { t } , . . . , \mathbf { u } _ { t + T } ]$ . Besides, all the equality constraints (5d) and (5e) are affine. Suppose both the state feasibile set (5f) and action feasibile set $( 5 \mathrm { g } )$ are convex, the overall optimization is convex.
+
+The convexity of the problem in (5) guarantees that it can be solved efficiently and optimally using gradient descend method. Since both the objective function (5a) and the constraints (5b)-(5c) are parameterized as neural networks, and their gradients can be calculated via back-propagation with the modification where cost is propagated to the input rather than the weights of the network. For implementation, the gradients can be convinently calculated via existing modules such as Tensorflow viaback-propagation. Let $\mathbf { u } ^ { * } = \{ \mathbf { u } _ { t } ^ { * } , \mathbf { u } _ { t + 1 } ^ { * } , . . . , \mathbf { u } _ { t + T } ^ { * } \}$ be the optimal solution of the optimization problem at time $t$ . Then the first element of $\mathbf { u } ^ { * }$ is implemented to the real-time system control, that is $\mathbf { u } _ { t } ^ { * }$ . The optimization problem is repeated at time $t + 1$ , based on the updated state prediction using $\mathbf { u } _ { t } ^ { * }$ , yielding a model predictive control strategy.
+
+# 3 EFFICIENCY AND REPRESENTATION POWER OF ICNN
+
+Besides the computational traceability of the input convex networks, as an system identification model, we are also interested its predictive accuracies and capacity. This section provides theoretical analysis on the representation ability and efficiency of input convex neural networks.
+
+# 3.1 REPRESENTATION POWER OF INPUT CONVEX NEURAL NETWORK
+
+Definition 1. Given a function $f : \mathbb { R } ^ { d }  \mathbb { R }$ , we say that the function $\hat { f }$ approximate $f$ within ε if $| f ( \mathbf { x } ) - { \hat { f } } ( \mathbf { x } ) | \leq \varepsilon$ for all $\mathbf { X }$ in the domain of $f$ .
+
+Theorem 1. [Representation power of ICNN] For any Lipschitz convex function over a compact domain, there exists a neural network with nonnegative weights and ReLU activation functions that approximates it within $\varepsilon$ .
+
+Lemma 1. Given a continuous Lipschitz convex function $f : \mathbb { R } ^ { d }  \mathbb { R }$ with compact domain and $\varepsilon > 0$ , it can be approximated within ε by maximum of a finite number of affine functions. That is, there exists $\hat { f } ( \mathbf { x } ) \stackrel {  } { = } \mathrm { m a x } _ { i = 1 , \ldots , N } \{ { \mu _ { \mathrm { i } } } ^ { T } \mathbf { x } + b _ { i } \}$ such that $| { \dot { f } } ( \mathbf { x } ) { \dot { - } } { \hat { f } } ( \mathbf { x } ) | \leq \varepsilon$ for all $\mathbf { x } \in d o m f$ .
+
+Sketch of proof for Theorem 1. Supposing Lemma 1 is true, the proof of Theorem 1 boils down to showing that neural network with nonnegative weights and ReLU activation functions can exactly represent a maximum of affine functions. The proof is constructive. We first construct a neural network with ReLU activation functions and both positive and negative weights, then we show that the weights between different layers of the network can be restricted to be nonnegative by a simple duplication trick. Specifically, since the weights in the input layer and passthrough layers in the ICNN can be negative, we simply add a negation of each input variable (e.g. both $\mathbf { X }$ and $- \mathbf { X }$ are given as inputs) to the network. These variables need satisfy a consistency constraint since one is the negation of the other. Since this constraint is linear, it preserves the convexity of optimization problems. The details of the proofs are given in the Appendix B.
+
+This proof is similar in spirit to theorems in (Hanin, 2017; Arora et al., 2016). The key new result is a simpler construction than the one used in (Hanin, 2017) and the restriction to nonnegative weights between the layers. □
+
+Similar to Theorem 1, an analogous result about the representation power of ICRNN can be shown for systems with convex dynamics. Given a dynamical system described by rolled out system dynamics $y _ { t } = f ( \mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { t } )$ is convex, then there exists a recurrent neural network with nonnegative weights and ReLU activation functions that approximates it within ε. A broad range of systems can be captured by this model. For example, the linear quadratic (Gaussian) regulator problem can be described using a ICRNN if we identify $y$ as the cost of the regulator (Skogestad & Postlethwaite, 2007; Boyd et al., 1994).1 An example of a nonlinear system is the control of electrochemical batteries. It can be shown from first principles that the degradation of these types of batteries is convex in their charge and discharge actions (Shi et al., 2018) and our framework offers a powerful data-driven way to control batteries found in electric vehicles, cell phones, and power systems.
+
+# 3.2 ICNN VS. CONVEX PIECEWISE LINEAR FITTING
+
+In the proof of Theorem 1, we first approximate a convex function by a maximum of affine functions then construct a neural network according to this maximum. Then a natural question is why learn a neural network and not directly the affine functions in the maximum? This approach was taken in (Magnani & Boyd, 2009), where a convex piecewise-linear function (max of affine functions) are directly learned from data through a regression problem.
+
+A key reason that we propose to use ICNN (or ICRNN) to fit a function rather than directly finding a maximum of affine functions is that the former is a much more efficient parameterization than the latter. As stated in Theorem 2, a maximum of $K$ affine functions can be represented by an ICNN with $K$ layers, where each layer only requires a single ReLU activation function. However, given a single layer ICNN with $K$ ReLU activation functions, it may take a maximum of $2 ^ { K }$ affine functions to represent it exactly. Therefore in practice, it would be much easier to train a good ICNN than finding a good set of affine functions.
+
+Theorem 2. [Efficiency of Representation]
+
+1. Let fICNN : $\mathbb { R } ^ { d } \to \mathbb { R }$ be an input convex neural network with K ReLU activation functions. Then $\Omega ( 2 ^ { K } )$ functions are required to represent fICNN using a max of affine functions. 2. Let $f _ { C P L } : \mathbb { R } ^ { d }  \mathbb { R }$ be a max of $K$ affine functions. Then $O ( K )$ activation functions are sufficient to represent fCPL exactly with an ICNN.
+
+The proof of this theorem is given in Appendix C.
+
+# 4 EXPERIMENTS
+
+In this section, we verify the effectiveness of ICNN and ICRNN by presenting experimental results on two decision-making problems: continuous control benchmarks on MuJoco locomotion tasks (Todorov et al., 2012) and energy management of reference large-scale commercial building (Crawley et al., 2001), respectively. The proposed method can be used as a flexible building block in decision making problems, where we use ICNN to represent system dynamics for MuJoco simulators, and we use ICRNN in an end-to-end fashion to find the optimal control inputs. Both examples demonstrate that proposed method: 1) discovers the connection between controllable variables and the system dynamics or cost objectives; 2) is lightweight and sample-efficient; 3) achieves generalizable and more stable control performances compared with previous model-based reinforcement learning and simplified linear control approaches.
+
+# 4.1 MUJOCO LOCOMOTION TASKS
+
+Experimental Setup We consider four simulated robotic locomotion tasks: swimmer, half-cheetah, hopper, ant implemented in MuJoCo under the OpenAI rllab framework (Duan et al., 2016). We train and represent the locomotion state transition dynamics $\mathbf { s } _ { t + 1 } = g ( \mathbf { s } _ { t } , \mathbf { u } _ { t } ) ^ { 2 }$ using a 2-layer ICNN with ReLU activations, which could be integrated into the following finite-horizon control problem to find the optimal action sequence $\mathbf { u } _ { t } , . . . , \mathbf { u } _ { t + T }$ for fixed looking ahead horizon $T$ :
+
+$$
+\begin{array} { r l } { \underset { \mathbf { u } _ { t } , \ldots , \mathbf { u } _ { t + T } } { \mathrm { m i n i m i z e } } } & { - \underset { \tau = t } { \overset { t + T } { \sum } } r ( \mathbf { s } _ { \tau } , \mathbf { u } _ { \tau } ) } \\ { \mathrm { s u b j e c t ~ t o } } & { \mathbf { s } _ { \tau + 1 } = g ( \mathbf { s } _ { \tau } , \mathbf { u } _ { \tau } ) , \forall \tau \in [ t , t + T ] } \\ & { \mathbf { u } _ { \tau } \in \mathcal { U } _ { f e a s i b l e } , \forall \tau \in [ t , t + T ] } \end{array}
+$$
+
+where the objective (6a) is convex because $r ( \mathbf { s } _ { \tau } , \mathbf { u } _ { \tau } )$ is a concave reward function related to system states such as velocity and control actions (the detailed forms of $r ( \mathbf { s } _ { \tau } , \mathbf { u } _ { \tau } )$ for different locomotion tasks are listed in Appendix D). To achieve better model generalization on locomotion dynamics, we also followed (Nagabandi et al., 2018), and applied DAGGER (Ross et al., 2011) to iteratively collect labeled robotic rollouts and train the supervised dyamics model (6b) using on-policy locomotion samples. See Appendix D for furthur simulation hyperparameters and experimental details. For each aggregated iterations of collecting rollouts data and training ICNN model, we validate the controller performance on standalone validation rollouts by optimally solving (6).
+
+![](images/faab94a202549cd129e2fe22764a38366843bc667357122041f304116571b54d.jpg)  
+Figure 3: Average rollout reward for random-shooting method vs ICNN on four MuJoCo tasks. The horizontal axis indicates the aggregated iteration, and vertical axis indicates average reward. Plotted curves are averaged over 3 random seeds, and the shaded region shows the standard deviation.
+
+Baselines We compare our system modeling and continuous control method with state-of-the-art model-based RL algorithm (Nagabandi et al., 2018), where the authors used a normal multi-layer perceptrons (MLP) model to parameterize the system dynamics (6b). We refer to their method as random-shooting algorithm, since they can not solve (6) to optimality, and they used pre-defined number of random-shooting control sequences (denoted as $K$ ) to query the trained MLP and find a best sequence as the rollout policy. Such a method is able to find good control policies in the degree of $\mathrm { \dot { 1 } 0 ^ { 4 } }$ timesteps, which are much more sample-efficient than model-free RL methods (Duan et al., 2016; Mnih et al., 2015). To make fair comparisons with baseline method, we keep the same setup on the rollouts number and initial random action training. Our framework makes the neural networks convex w.r.t input by adding passthrough links to the 2-layer model and keeping all the layer weights nonnegative. We evaluate the performance of both algorithms on three randomly selected fixed random seeds for four tasks. Similar to the fine tuning steps in (Nagabandi et al., 2018), control policies found by ICNN can also be plugged in as initialized policies for subsequent model-free reinforcement learning algorithms.
+
+Continuous Control Performance During training, we found both ICNN and MLP are able to predict robotic states quite accurately based on (6b). This provides a good system dynamics model which is beneficial to solve control policies. The control performances are shown in Fig. 3, where we compare the average reward of proposed method and random-shooting method with $K = 1 0 0$ over 10 validation rollouts during each aggregated iteration (see Fig. 8 in Appendix D.4 for random shooting performance with varying $K _ { \cdot }$ ). The policy found by ICNN outperforms the random-shooting method in all settings with varying horizon $T$ for all of the four locomotion tasks.
+
+Intuitively, ICNN should perform better when the action space is larger, since random-shooting method can not search through the action space efficiently with a fixed $K$ . This is illustrated in the example of ant, where with more training samples aggregated and MLP model representing more accurate dynamics, random-shooting gets stuck to find better control policies and there is little improvement reflected in the control performance. Moreover, since we are skipping the expensive process on calculating rewards of each random shooting trajectory and finding the best one, our method only implements ICNN inference step based on (6) and is much faster than random shooting methods in most settings, especially when $K$ is large (see Table. 2 for wall-clock time in Appendix D.3). For instance, in the case of Swimmer, our proposed method only uses $\frac { 1 } { 5 }$ of time compared to (Nagabandi et al., 2018). This also indicates that our method is even much more sample-efficient than off-the-shelf model-free RL methods, where we use two orders of magnitude less training data to reach similar validation rewards (Duan et al., 2016; Mnih et al., 2015) (see Fig. 9 in Appendix D.4).
+
+# 4.2 BUILDING ENERGY MANAGEMENT
+
+Experimental Setup We now move on to optimally control a dynamical system with significant inertia. We consider the real-time control problem of building’s HVAC (heating, ventilation, and air conditioning) system to reduce its energy consumption. Building energy management remains to be a hard problem in control area. The exact system dynamics are unknown and hard to model due to the complex heating transfer dynamics, time-varying environments and the scale of the system in terms of states and actions (Kouro et al., 2009). At time $t$ , we assume the building’s running profile $\mathbf { x } _ { t } : = \left[ \mathbf { s } _ { t } , \mathbf { u } _ { t } \right]$ is available, where $\mathbf { s } _ { t }$ denotes building system states, including outside temperature, room temperature measurements, zone occupancies and etc. $\mathbf { u } _ { t }$ denotes a collection of control actions such as room temperature set points and appliance schedule. Output is the electricity consumption $P _ { t }$ .
+
+This is a model predictive control problem in the sense that we want to find the best control inputs that minimize the overall energy consumption of building by looking ahead several time steps. To achieve this goal, we firstly learn an ICRNN model $f ( \cdot )$ of the building dynamics, which is trained to minimize the error between $P _ { t }$ and $f \left( \mathbf { x } _ { t - n _ { w } } , . . . , \mathbf { x } _ { t } \right)$ , while $n _ { w }$ denotes the memory window of recurrent neural networks. Then we solve:
+
+$$
+\begin{array} { r l } { \underset { \mathbf { u } _ { t } , . . . , \mathbf { u } _ { t + T } } { \mathrm { m i n i m i z e } } } & { \overset { t + T } { \underset { \tau = t } { \sum } } f \big ( \mathbf { x } _ { \tau - n _ { w } } , . . . , \mathbf { x } _ { \tau } \big ) } \\ { \mathrm { s u b j e c t ~ t o } } & { \mathbf { s } _ { \tau } = g \big ( \mathbf { x } _ { \tau - n _ { w } } , . . . , \mathbf { x } _ { \tau - 1 } , \mathbf { u } _ { \tau } \big ) , \forall \tau \in [ t , t + T ] } \\ & { \mathbf { u } _ { \tau } \leq \mathbf { u } _ { \tau } \leq \bar { \mathbf { u } } _ { \tau } , \forall \tau \in [ t , t + T ] } \\ & { \mathbf { s } _ { \tau } \leq \mathbf { s } _ { \tau } \leq \bar { \mathbf { s } } _ { \tau } , \forall \tau \in [ t , t + T ] } \end{array}
+$$
+
+where the objective (7a) is minimizing the total energy consumption in future $T$ steps ( $T$ is the model predictive control horizon), and (7b) is used for modeling building states, in which $g ( \cdot )$ are parameterized as ICRNNs. Note that the formulation (7) is also flexible with different loss functions. For instance, in practice, we could reuse trained dynamics model (7b), and integrate electricity prices into the overall objective so that we could directly learn real-time actions to minimize electricity bills (please refer to Appendix E for more results). The constraints on control actions ${ \bf u } _ { t }$ and system states $\mathbf { s } _ { t }$ are given in (7c) and (7d). For instance, the temperature set points as well as real measurements should not exceed user-defined comfort regions.
+
+![](images/47eff508ac0f13e1c6d7a14126d0a6ed93e8a755e1c35146991e94cb732eac9b.jpg)  
+Figure 4: Results for constrained optimization of building energy management. (a) ICRNN is able to model the building dynamics as accurately as conventional RNN; (b) Compared to conventional RNN model, ICRNN finds control actions which lead to $1 1 . 5 2 \%$ more of energy savings, and (c) ICRNN provides stable control actions while decisions generated by conventional RNN vary dramatically.
+
+To test the performance of the proposed method, we set up a 12-story large office building, which is a reference EnergyPlus commercial building model from US Department of Energy (DoE) 3, with a total floor area of 498,584 square feet which is divided into 16 separate zones. By using the whole year’s weather profile, we simulate the building running through the year and record $( \mathbf { x } _ { t } , P _ { t } )$ with a resolution of 10 minutes. We use 10 months’ data to train the ICRNN and subsequent 2 months’ data for testing. We use 39 building system state variables $\mathbf { s } _ { t }$ (uncontrollable), along with 16 control variables $\mathbf { u } _ { t }$ . Output is a single value of building energy consumption at each time step. We set the model predictive control horizon $T = 3 6$ (six hours). We employ an ICRNN with recurrent layer of dimension 200 to fit the building input-output dynamics $f ( \cdot )$ . The model is trained to minimize the MSE between its predictions and the actual building energy consumption using stochastic gradient descent. We use the same network structure and training scheme to fit state transition dynamics $g ( \cdot )$
+
+Baseline We set the model-based forecasting and optimization benchmark using an linear resistorcircuit (RC) circuit model to represent the heat transfer in building systems, and solve for the optimal control actions via MPC (Ma et al., 2012). At each step, MPC algorithm takes into account the forecasted states of the building based on the fitted RC model and implements the current step control actions. We also compare the performance of ICRNN against the conventionally trained RNN in terms of building dynamics fitting performance and control performance. To solve the MPC problem with conventional RNN models, we also use gradient-based method with respect to controls. However, since conventional RNN models are generally not convex from input to output, there is no guarantee to reach a global optimum (or even a local one).
+
+Results In terms of the fitting performance, ICRNN provides a competitive result compared to conventional RNN model. The overall test root mean square error (RMSE) is 0.054 for ICRNN and 0.051 for conventional RNN, both of which are much smaller than the error made by RC model (0.240). Fig. 4(a) shows the fitting performance on 5 working days in test data. This illustrates the good performance of ICRNN in modeling building HVAC system dynamics. Then by using the learned ICRNN model of building dynamics, we obtain the suggested room control actions ${ \boldsymbol u } _ { t } ^ { * }$ by solving the optimal building control problem (7). As shown in Fig. 4(b), with the same constraints on building temperature interval of $[ 1 9 ^ { \circ } C , 2 4 ^ { \circ } C ]$ , the building energy consumption is reduced by $2 3 . 2 5 \%$ after implementing the new temperature set points calculated by ICRNN. On the contrary, since there is no guarantee for finding optimal control actions by optimizing over conventional RNN’s input, the control solutions given by conventional RNN could only reduce $1 1 . 7 3 \%$ of electricity. Solutions given by RC model only saves $4 . 0 7 \%$ of electricity. More importantly, in Fig. 4(c) we demonstrate the control actions outputted by our method against MPC with conventional RNN in two randomly selected building zones, the building basement and top floor central area. It shows that our proposed approach is able to find a group of stable control actions for the building system control. While in the conventional RNN case, it generates control set points which have undesirable, drastic variations.
+
+# 5 SUMMARY AND DISCUSSION
+
+In this work we proposed a novel optimal control framework that uses deep neural networks engineered to be convex from the input to the output. This framework bridges machine learning and control by representing system dynamics using input convex (recurrent) neural networks. We show that many interesting data-driven control problems can be cast as convex optimization problems using the proposed network architecture. Experiments on both benchmark MuJoCo locomotion tasks and building energy management demonstrate our methodology’s potential in a variety of control and optimization problems.
+
+# REFERENCES
+
+Brandon Amos, Lei Xu, and J Zico Kolter. Input convex neural networks. In International Conference on Machine Learning, pp. 146–155, 2017.
+
+Raman Arora, Amitabh Basu, Poorya Mianjy, and Anirbit Mukherjee. Understanding deep neural networks with rectified linear units. arXiv preprint arXiv:1611.01491, 2016.
+
+Stephen Boyd and Lieven Vandenberghe. Convex optimization. Cambridge university press, 2004.
+
+Stephen Boyd, Laurent El Ghaoui, Eric Feron, and Venkataramanan Balakrishnan. Linear matrix inequalities in system and control theory, volume 15. Siam, 1994.
+
+Chia-Chin Cheng, S Pouffary, N Svenningsen, and John M Callaway. The kyoto protocol, the clean development mechanism and the building and construction sector: A report for the unep sustainable buildings and construction initiative, 2008.
+
+Morris G Cox. An algorithm for approximating convex functions by means by first degree splines. The Computer Journal, 14(3):272–275, 1971.
+
+Drury B Crawley, Linda K Lawrie, Frederick C Winkelmann, Walter F Buhl, Y Joe Huang, Curtis O Pedersen, Richard K Strand, Richard J Liesen, Daniel E Fisher, Michael J Witte, et al. Energyplus: creating a new-generation building energy simulation program. Energy and buildings, 33(4): 319–331, 2001.
+
+Marc Peter Deisenroth, Carl Edward Rasmussen, and Dieter Fox. Learning to control a low-cost manipulator using data-efficient reinforcement learning. 2011.
+
+Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In International Conference on Machine Learning, pp. 1329–1338, 2016.
+
+Momcilo M Gavrilovi ˇ c. Optimal approximation of convex curves by functions which are piecewise´ linear. Journal of Mathematical Analysis and Applications, 52(2):260–282, 1975.
+
+Boris Hanin. Universal function approximation by deep neural nets with bounded width and relu activations. arXiv preprint arXiv:1708.02691, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Kenji Kawaguchi. Deep learning without poor local minima. In Advances in Neural Information Processing Systems, pp. 586–594, 2016.
+
+Samir Kouro, Patricio Cortés, René Vargas, Ulrich Ammann, and José Rodríguez. Model predictive control—a simple and powerful method to control power converters. IEEE Transactions on industrial electronics, 56(6):1826–1838, 2009.
+
+Sergey Levine and Vladlen Koltun. Learning complex neural network policies with trajectory optimization. In International Conference on Machine Learning, pp. 829–837, 2014.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. The Journal of Machine Learning Research, 17(1):1334–1373, 2016.
+
+Lennart Ljung. System identification. In Signal analysis and prediction, pp. 163–173. Springer, 1998.
+
+Yudong Ma, Anthony Kelman, Allan Daly, and Francesco Borrelli. Predictive control for energy efficient buildings with thermal storage: Modeling, stimulation, and experiments. IEEE Control Systems, 32(1):44–64, 2012.
+
+Alessandro Magnani and Stephen P Boyd. Convex piecewise-linear fitting. Optimization and Engineering, 10(1):1–17, 2009.
+
+David Meger, Juan Camilo Gamboa Higuera, Anqi Xu, Philippe Giguere, and Gregory Dudek. Learning legged swimming gaits from experience. In Robotics and Automation (ICRA), 2015 IEEE International Conference on, pp. 2332–2338. IEEE, 2015.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.
+
+Anusha Nagabandi, Gregory Kahn, Ronald S Fearing, and Sergey Levine. Neural network dynamics for model-based deep reinforcement learning with model-free fine-tuning. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pp. 7559–7566. IEEE, 2018.
+
+Daniel O’Neill, Marco Levorato, Andrea Goldsmith, and Urbashi Mitra. Residential demand response using reinforcement learning. In Smart Grid Communications (SmartGridComm), 2010 First IEEE International Conference on, pp. 409–414. IEEE, 2010.
+
+Stéphane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and structured prediction to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 627–635, 2011.
+
+HL Royden and PM Fitzpatrick. Real analysis. 4th, 2010.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International Conference on Machine Learning, pp. 1889–1897, 2015.
+
+Pervez Hameed Shaikh, Nursyarizal Bin Mohd Nor, Perumal Nallagownden, Irraivan Elamvazuthi, and Taib Ibrahim. A review on optimized control systems for building energy and comfort management of smart sustainable buildings. Renewable and Sustainable Energy Reviews, 34: 409–429, 2014.
+
+Y. Shi, B. Xu, Y. Tan, D. Kirschen, and B. Zhang. Optimal battery control under cycle aging mechanisms in pay for performance settings. IEEE Transactions on Automatic Control, pp. 1–1, 2018. ISSN 0018-9286. doi: 10.1109/TAC.2018.2867507.
+
+Sigurd Skogestad and Ian Postlethwaite. Multivariable feedback control: analysis and design, volume 2. Wiley New York, 2007.
+
+Nagender Kumar Suryadevara, Subhas Chandra Mukhopadhyay, Sean Dieter Tebje Kelly, and Satinder Pal Singh Gill. Wsn-based smart sensors and actuator for power management in intelligent buildings. IEEE/ASME transactions on mechatronics, 20(2):564–571, 2015.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 6000–6010, 2017.
+
+Shuning Wang. General constructive representations for continuous piecewise-linear functions. IEEE Transactions on Circuits and Systems I: Regular Papers, 51(9):1889–1896, 2004.
+
+T. Wei, Y. Wang, and Q. Zhu. Deep reinforcement learning for building hvac control. In The Design and Automation Conference, 2017.
+
+W. Wolf. Cyber-physical systems. Computer, 42:88–89, 2009.
+
+Zhaohui Zhang, Ruilong Deng, Tao Yuan, and S Joe Qin. Distributed optimization of multi-building energy systems with spatially and temporally coupled constraints. In American Control Conference (ACC), 2017, pp. 2913–2918. IEEE, 2017.
+
+# APPENDIX
+
+# A. TOY EXAMPLE
+
+Consider a synthetic example which contains two circles of noisy input data $\mathbf { u } \in \mathbb { R } ^ { 2 }$ , along with discrete data label $y \in \{ 0 , 1 \}$ which is based on input coming from inner loop $( y = 0 )$ or outer loop $( y = 1$ ). Suppose a decision maker is interested in finding the u that maximizes the probability of $y$ being 0. This optimization problem can be solved by firstly learning a neural network classifier from $\mathbf { u }$ to $y$ , and then to find the $\mathbf { u }$ point which minimizes the output of the neural network. More specifically, let $f _ { N N }$ be a conventional neural network and fICNN be an ICNN. Then the objective becomes minimizing $f _ { N N } ( { \mathbf { u } } )$ or $f _ { I C N N } ( \mathbf { u } )$ .
+
+Figure 5 shows the decision boundaries for $f _ { N N }$ and fICNN, respectively. These networks are composed of 2 hidden layers, with 200 neurons in each layer, and are trained using the same random seed, same number of samples (100) until loss convergence. The decision boundaries of a conventional network have many “zigzags”, which makes solving (1) challenging, especially if u is constrained. In contrast, the ICNN has convex level sets (by construction) as decision boundaries, which leads to a convex optimization problem.
+
+![](images/49e277941647ae8e5a9b8fc40e0d42ede6687f3bb757c23988ffde6400536879.jpg)  
+Figure 5: Toy example on classifying circle data with label 0 (blue cross) and label 1 (red cross) along with conventional neural networks (left) and ICNN (right) decision contour lines. A decision maker is interested in finding a $\mathbf { u }$ that has the highest probability of being labeled 0.
+
+APPENDIX B. PROOF OF THEOREM 1
+
+Proof. Lemma 1 follows from well established facts in function analysis stating that piecewise linear functions are dense in the space of all continuous functions over compact sets (Royden & Fitzpatrick, 2010) and convex piecewise linear functions are dense in the space of all convex continuous functions (Cox, 1971; Gavrilovic, 1975). Using the fact that convex piecewise linear ´ functions can be represented as a maximum of affine functions (Magnani & Boyd, 2009; Wang, 2004) gives the desired result in the lemma.
+
+Lemma 1 shows that all continuous Lipschitz convex functions $f ( \mathbf { x } ) : \mathbb { R } ^ { d }  \mathbb { R }$ over convex compact sets can be approximated using maximum of affine functions. Then it suffices to show that an ICNN can exactly represent a maximum of affine functions. To do this, we first construct a neural network with ReLU activation function with both positive and negative weights that can represent a maximum of affine functions. Then we show how to restrict all weights to be nonnegative.
+
+As a starting example, consider a maximum of two affine functions
+
+$$
+f _ { C P L } ( \mathbf { x } ) = \operatorname* { m a x } \{ \mathbf { a } _ { 1 } ^ { T } \mathbf { x } + b _ { 1 } , \mathbf { a } _ { 2 } ^ { T } \mathbf { x } + b _ { 2 } \} .
+$$
+
+To obtain the exact same function using a neural network, we first rewrite it as
+
+$$
+f _ { C P L } ( \boldsymbol { x } ) = ( \mathbf { a } _ { 2 } ^ { T } \mathbf { x } + b _ { 2 } ) + \operatorname* { m a x } \left( ( \mathbf { a } _ { 1 } - \mathbf { a } _ { 2 } ) ^ { T } \mathbf { x } + ( b _ { 1 } - b _ { 2 } ) , 0 \right) .
+$$
+
+Now define a two-layer neural network with layers $\mathbf { z } _ { 1 }$ and $\mathbf { z } _ { 2 }$ as shown in Fig. 6:
+
+$$
+\begin{array} { r l } & { z _ { 1 } = \sigma \left( ( { \bf a } _ { 1 } - { \bf a } _ { 2 } ) ^ { T } { \bf x } + ( b _ { 1 } - b _ { 2 } ) \right) , } \\ & { z _ { 2 } = z _ { 1 } + { \bf a } _ { 2 } ^ { T } { \bf x } + b _ { 2 } } \end{array}
+$$
+
+where $\sigma$ is the ReLU activation function and the second layer is linear. By construction, this neural network is the same function as $f _ { C P L }$ given in (8).
+
+![](images/ff17e048302446ed5c48f1a02a9e8119d0f8be7f8e096066b0d9e1e0a1566e7d.jpg)  
+Figure 6: A simple two-layer neural networks. In alignment with (10), $W _ { 1 }$ denotes the first-layer weights ${ \bf a } _ { 1 } - { \bf a } _ { 2 }$ and bias $b _ { 1 } - b _ { 2 }$ , and $W _ { 2 }$ denotes the linear second layer. Direct layer is denoted as $D _ { 2 }$ for weights $\mathbf { a } _ { 2 }$ and bias $b _ { 2 }$ .
+
+The above argument extends directly to a maximum of $K$ linear functions. Suppose
+
+$$
+f _ { C P L } ( \mathbf { x } ) = \operatorname* { m a x } \{ \mathbf { a } _ { 1 } ^ { T } \mathbf { x } + b _ { 1 } , . . . , \mathbf { a } _ { K } ^ { T } \mathbf { x } + b _ { K } \}
+$$
+
+Again the trick is to rewrite $f _ { C P L } ( \mathbf { x } )$ as a nested maximum of affine functions. For notational convenience, let $L _ { i } = \mathbf { a } _ { i } ^ { T } \mathbf { x } + b _ { i }$ , $L _ { i } ^ { \prime } = L _ { i } - L _ { i + 1 }$ . Then
+
+$$
+\begin{array} { r l } { f _ { C P L } = \operatorname* { m a x } \{ L _ { 1 } , L _ { 2 } , . . . , L _ { K } \} } \\ { = \operatorname* { m a x } \{ \operatorname* { m a x } \{ L _ { 1 } , L _ { 2 } , . . . , L _ { K - 1 } \} , L _ { K } \} } \\ { = L _ { K } + \sigma \left( \operatorname* { m a x } \{ L _ { 1 } , L _ { 2 } , . . . , L _ { K - 1 } \} - L _ { K } \right) } \\ { } & { = L _ { K } + \sigma \left( \operatorname* { m a x } \{ \operatorname* { m a x } \{ L _ { 1 } , L _ { 2 } , . . . , L _ { K - 2 } \} , L _ { K - 1 } \} - L _ { K } , 0 \right) } \\ { } & { = L _ { K } + \sigma \left( L _ { K - 1 } - L _ { K } + \sigma \left( \operatorname* { m a x } \{ L _ { 1 } , L _ { 2 } , . . . , L _ { K - 2 } \} - L _ { K - 1 } , 0 \right) , 0 \right) } \\ { } & { = . . . } \\ { } & { = L _ { K } + \sigma \left( L _ { K - 1 } ^ { \prime } + \sigma \left( L _ { K - 2 } ^ { \prime } + \sigma \left( L _ { - } ^ { \prime } \sigma \left( L _ { 2 } ^ { \prime } + \sigma \left( L _ { 1 } - L _ { 2 } , 0 \right) , 0 \right) , . . . , 0 \right) , 0 \right) , 0 \right) . } \end{array}
+$$
+
+The last equation describes a $K$ layer neural network, where the layers are:
+
+$$
+\begin{array} { r l } & { z _ { 1 } = \sigma \left( L _ { 1 } - L _ { 2 } , 0 \right) = \sigma \left( \left( \mathbf { a } _ { 1 } - \mathbf { a } _ { 2 } \right) ^ { T } \mathbf { x } + \left( b _ { 1 } - b _ { 2 } \right) \right) , } \\ & { z _ { 2 } = \sigma \left( L _ { 2 } ^ { \prime } + z _ { 1 } , 0 \right) = \sigma \left( z _ { 1 } + \left( \mathbf { a } _ { 2 } - \mathbf { a } _ { 3 } \right) ^ { T } \mathbf { x } + \left( b _ { 2 } - b _ { 3 } \right) \right) , } \\ & { . . . . . . } \\ & { z _ { i } = \sigma \left( L _ { i } ^ { \prime } + z _ { i - 1 } , 0 \right) = \sigma \left( z _ { i - 1 } + \left( \mathbf { a } _ { i } - \mathbf { a } _ { i + 1 } \right) ^ { T } \mathbf { x } + \left( b _ { i } - b _ { i + 1 } \right) \right) , } \\ & { . . . . . . } \\ & { z _ { K } = z _ { K - 1 } + L _ { K } = h _ { K } \left( z _ { K - 1 } + L _ { K } \right) = \left( z _ { K - 1 } + \mathbf { a } _ { K } ^ { T } \mathbf { x } + b _ { K } \right) . } \end{array}
+$$
+
+Each layer of of this neural network uses only a single activation function.
+
+Although the above neural network exactly represent a maximum of linear functions, it is not convex since the coefficients between layers could be negative. In particular, each layer involves an inner product of the form $( \mathbf { a } _ { i } - \mathbf { a } _ { i + 1 } ) ^ { T } \mathbf { x }$ and the coefficients are not necessarily nonnegative. To overcome this, we simply expand the input to include $\mathbf { X }$ and $- \mathbf { X }$ . Namely, define a new input $\hat { \mathbf { x } } \in \mathbb { R } ^ { 2 d }$ as
+
+$$
+\hat { \mathbf { x } } = \left[ \begin{array} { l } { \mathbf { x } } \\ { - \mathbf { x } } \end{array} \right] .
+$$
+
+Then any inner product of the form $\mathbf { h } ^ { T } \mathbf { x }$ can be written as
+
+$$
+{ \begin{array} { r l } & { \mathbf { h } ^ { T } \mathbf { x } = { \displaystyle \sum _ { j = 1 } ^ { d } h _ { i } x _ { i } } } \\ & { \qquad = \displaystyle \sum _ { i : h _ { i } \geq 0 } h _ { i } x _ { i } + \displaystyle \sum _ { i : h _ { i } < 0 } h _ { i } x _ { i } } \\ & { \qquad = \displaystyle \sum _ { i : h _ { i } \geq 0 } h _ { i } x _ { i } + \displaystyle \sum _ { i : h _ { i } < 0 } ( - h _ { i } ) ( - x _ { i } ) } \\ & { \qquad = \displaystyle \sum _ { i : h _ { i } \geq 0 } h _ { i } { \hat { x } } _ { i } + \displaystyle \sum _ { i : h _ { i } \leq 0 } ( - h _ { i } ) ( { \hat { x } } _ { i + d } ) , } \end{array} }
+$$
+
+where all coefficients are nonnegative in the above sum.
+
+Therefore any inner product between a coefficient vector and the input $\mathbf { X }$ can be written as an inner product between a nonnegative coefficient vector and the expanded input $\hat { \mathbf { x } }$ . Therefore, without loss of generality, we can limit all of the weights between layers to be nonnegative, and thus the neural network to be input convex. Note that in optimization problems, we need to enforce consistency in $\hat { \mathbf { x } }$ be including (12) as a constraint. However, this is a linear equality constraint, which maintains the convexity of the optimization problem.
+
+# APPENDIX C. PROOF OF THEOREM 2
+
+Proof. The second statement of Theorem 2 directly follows the construction in the proof of Theorem 1, which shows that a maximum of $K$ affine functions can be represent by a $K$ -layer ICNN (with a single ReLU function in each layer). So it remains to show the first statement of Theorem 2.
+
+To show that a maximum of affine functions can require exponential number of pieces to approximate a function specified by an ICNN with $K$ activation functions, consider a network with 1 hidden layer of K nodes and the weights of direct “passthrough” layers are set to 0:
+
+$$
+f _ { I C N N } ( \mathbf { x } ) = \sum _ { i = 1 } ^ { K } w _ { 1 i } \pmb { \sigma } ( \mathbf { w } _ { 0 i } ^ { T } \mathbf { x } + b _ { i } ) ,
+$$
+
+It contains $3 K$ parameters: $\mathbf { w } _ { 0 i } , w _ { 1 i }$ and $b _ { i }$ , where $\mathbf { w } _ { 0 i } \in \mathbb { R } ^ { d }$ and $w _ { 1 i } , b _ { i } \in \mathbb { R }$ .
+
+In order to represent the same function by a maximum of affine functions, we need to assess the value of every activation unit $\sigma ( \mathbf { w } _ { 0 i } ^ { T } \mathbf { x } + b _ { i } )$ . If $\mathbf { w } _ { 0 i } ^ { T } \mathbf { x } + b _ { i } \geq 0 , \sigma ( \mathbf { w } _ { 0 i } ^ { T } \mathbf { x } + b _ { i } ) = \mathbf { w } _ { 0 i } ^ { T } \mathbf { x } + b _ { i }$ ; otherwise, $\sigma ( \mathbf { w } _ { 0 i } ^ { T } \mathbf { x } + b _ { i } ) = 0$ . In total, we have $2 ^ { K }$ potential combinations of piecewise-linear function, including
+
+$$
+\begin{array} { r l } { L _ { 1 } } & { = \left( \displaystyle \sum _ { i = 1 } ^ { K } w _ { 1 i } \mathbf { w } _ { 0 i } \right) ^ { T } \mathbf { x } + \displaystyle \sum _ { i = 1 } ^ { K } w _ { 1 i } b _ { i } , \mathrm { i f ~ a l l ~ } \mathbf { w } _ { 0 i } ^ { T } \mathbf { x } + b _ { i } \geq 0 } \\ { L _ { 2 } } & { = \left( \displaystyle \sum _ { i = 2 } ^ { K } w _ { 1 i } \mathbf { w } _ { 0 i } \right) ^ { T } \mathbf { x } + \displaystyle \sum _ { i = 2 } ^ { K } w _ { 1 i } b _ { i } , \mathrm { i f ~ } \mathbf { w } _ { 0 1 } ^ { T } \mathbf { x } + b _ { 1 } < 0 \mathrm { ~ a n d ~ a l l ~ o t h e r ~ } \mathbf { w } _ { 0 i } ^ { T } \mathbf { x } + b _ { i } \geq 0 } \\ { L _ { 3 } } & { = \left( w _ { 1 1 } \mathbf { w } _ { 0 1 } + \displaystyle \sum _ { i = 3 } ^ { K } w _ { 1 i } \mathbf { w } _ { 0 i } \right) ^ { T } \mathbf { x } + w _ { 1 i } b _ { i } + \displaystyle \sum _ { i = 3 } ^ { K } w _ { 1 i } b _ { i } , \mathrm { i f ~ } \mathbf { w } _ { 0 2 } ^ { T } \mathbf { x } + b _ { 2 } < 0 \mathrm { ~ a n d ~ o t h e r ~ } \mathbf { w } _ { 0 i } ^ { T } \mathbf { x } + b _ { i } \geq 0 } \\ & { \qquad \quad \cdots \cdots . } \end{array}
+$$
+
+So the following maximum over $2 ^ { K }$ pieces is required to represent the single linear ICNN:
+
+$$
+\operatorname* { m a x } \{ L _ { 1 } , L _ { 2 } , . . . , L _ { 2 ^ { K } } \} .
+$$
+
+Table 1: Environment and training details for four MuJoCo locomotion tasks.   
+
+<table><tr><td>Environment</td><td>Swimmer</td><td>Half-Cheetah</td><td>Hopper</td><td>Ant</td></tr><tr><td>Reward Function</td><td>-0.511312</td><td>s1-0.0512</td><td>1+1- 0.005||2012</td><td>s1+0.5- 0.00511012</td></tr><tr><td>Rollout Horizon</td><td>333</td><td>1000</td><td>200</td><td>1000</td></tr><tr><td>Rollout Numbers</td><td>25</td><td>10</td><td>30</td><td>400</td></tr><tr><td>Training Epochs</td><td>60</td><td>60</td><td>40</td><td>60</td></tr></table>
+
+APPENDIX D. EXPERIMENTAL DETAILS ON MUJOCO TASKS
+
+# D.1 DATA COLLECTION
+
+Rollout Samples To train the neural network dynamics model (both ICNN and MLP), we first collect initial rollout data using fully random action sequences $\mathbf { u } _ { t } \sim \mathrm { U n i f o r m } [ \mathbf { - 1 } , \mathbf { 1 } ]$ with a random chosen initial state. During the data collection process in aggregated iterations, to improve model generalization and explore larger state spaces, we add Gaussian noise to the optimal control policies $\mathbf { u } _ { t } = \mathbf { u } _ { t } + \mathcal { N } ( 0 , 0 . 0 0 1 )$ .
+
+Neural Networks Training We represent the MuJoCo dynamics with a 2-hidden-layer neural networks with hidden sizes 512 − 512. The passthrough links of ICNN are of same size of corresponding added layers. We train both models using Adam optimizer with a learning rate 0.001 and a mini-batch size of 512. Due to the different complexity of MuJoCo tasks, we vary training epochs and summarize the training details in Table. 1.
+
+# D.2 ENVIRONMENT DETAILS
+
+In all of the MuJoCo locomotion tasks, s includes state variables such as robot positions, velocity along each axis; u includes action efforts for the agent. We use standard reward functions $r ( \mathbf { s } _ { t } , \mathbf { u } _ { t } )$ for moving tasks, which could be also promptly calculated in (6a) as the control objective. For the ease of neural network training and action sampling, we normalize all the action and states in the range of $[ - 1 , \mathbf { 1 } ]$ . We use DAGGER (Ross et al., 2011) for 6 aggregated iterations for all cases, and during aggregated iteration, we use a split of $10 \%$ random rollouts collected as described in 5, and other $90 \%$ coming from past iterations’ control policies (on-policy rollouts). Note that we use 10 random control sequences in our method to initialize the policy finding approach and avoid the long computation time for taking gradients on finding optimal ${ \bf u } _ { t }$ . Other environment parameters are described in Table. 1.
+
+# D.3 WALL-CLOCK TIME
+
+In Table.2, we show the average run time for the total of 6 aggregation iterations over 3 runs. Finding control policies via ICNN is using less or equal training time compared to random-shooting method with $K = 1 0 0$ , while achieving better task rewards than $K = 1 0 0 0$ for different control horizons. All the experiments are running on a computer with 8 cores Intel I7 6700 CPU. Note that we do not use GPU for accelerating ICNN optimization step (6), which could furthur improve our method’s efficiency.
+
+# D.4 DETAILS OF SIMULATION RESULTS
+
+MuJoCo Dynamics Modeling In Fig. 7, we compare the ICNN and normal MLP fitting performance of the MuJoCo dynamics modeling (6b), which illustrates that both MLP and ICNN are able to find a data-driven dynamics model for ant MuJoCo agent, which is of the most complex dynamics we considered for locomotion tasks. The multi-step prediction errors of ICNN is comparable to normal MLP used in (Nagabandi et al., 2018) for different length of rollout steps.
+
+<table><tr><td rowspan="2"></td><td colspan="3">Swimmer</td><td rowspan="2">ICNN</td></tr><tr><td>K=100</td><td>K=300</td><td>K=1000</td></tr><tr><td>H=4</td><td>18.36</td><td>18.48</td><td>40.20</td><td>16.41</td></tr><tr><td>H=10</td><td>21.74</td><td>25.41</td><td>71.49</td><td>18.71</td></tr><tr><td>H=50</td><td>40.01</td><td>70.31</td><td>169.49</td><td>36.24</td></tr><tr><td colspan="3">Half-Cheetah</td><td>K=1000</td><td>ICNN</td></tr><tr><td>H=4</td><td>K=100 34.40</td><td>K=300 47.72</td><td>88.49</td><td></td></tr><tr><td>H=10</td><td>48.86</td><td>74.60</td><td>181.34</td><td>34.93 36.39</td></tr><tr><td>H=50</td><td>113.58</td><td>275.61</td><td>816.32</td><td>83.66</td></tr><tr><td colspan="3"></td><td></td><td></td></tr><tr><td rowspan="2">H=4</td><td>K=100</td><td>Hopper K=300</td><td>K=1000</td><td>ICNN</td></tr><tr><td>5.48</td><td>6.30</td><td>7.76</td><td>5.61</td></tr><tr><td>H=10</td><td>5.97</td><td>7.89</td><td>9.34</td><td>5.14</td></tr><tr><td>H=50</td><td>10.89</td><td>14.77</td><td>38.02</td><td>9.16</td></tr><tr><td rowspan="2"></td><td></td><td>Ant</td><td></td><td></td></tr><tr><td>K=100</td><td>K=300</td><td>K=1000</td><td>ICNN</td></tr><tr><td>H=4</td><td>399.39</td><td>415.51</td><td>433.35</td><td>349.13</td></tr><tr><td>H=10</td><td>480.60</td><td>481.34</td><td>511.93</td><td>459.63</td></tr><tr><td>H=50</td><td>979.73</td><td>1024.5</td><td>1075.52</td><td>929.5</td></tr></table>
+
+![](images/2fdefb495e5bec0a8b39d5e00b741be9ca057a9ab03ad277ee2e7e299e9abf55.jpg)  
+Table 2: Average wall clock time (in minutes) for random-shooting model-based reinforcement learning method and ICNN.   
+Figure 7: Multistep prediction errors by ICNN and MLP. $\mathrm { X }$ -Axis and Y-Axis are of log scale.
+
+More Simulation Results In Fig. 8, we compare our control method with random-shooting approach with varying settings on shooting number $K$ , which shows that our approach is more efficient in finding control policies.
+
+In Fig. 9, we compare our control method with the rllab implementation of trust region policy optimization (TRPO) (Schulman et al., 2015), an end-to-end deep reinforcement learning approach for mujoco locomotion tasks. More specifically, we compare the algorithms’ performances with relatively few available rollout samples. While our approach quickly learns the dynamics and then find control actions via optimization steps, TRPO is hard to learn the actions directly with few provided rollouts. Similarly to the model-based and model-free (Mb-Mf) approach described in (Nagabandi et al., 2018), our control method could provide good initialization samples for the model-free algorithms, which could greatly accelerate the training process of model-free algorithms.
+
+![](images/f650d13e17146dd8e66dfc3c7e039dd238999774e2525838ef366f6d381dee50.jpg)  
+Figure 8: Cumulative reward for one validation rollout of random shooting method vs ICNN
+
+![](images/593c9a8ecd0da3845c9d9b8bbef51f9d59d63d4ff793d3c28c360aa2a2d489ca.jpg)  
+Figure 9: Average return for control of Mujoco tasks by ICNN, random-shooting method (Nagabandi et al., 2018) and TRPO (Schulman et al., 2015).
+
+APPENDIX E. DETAILS ON BUILDING ENERGY MANAGEMENT
+
+# E.1 MINIMIZING ELECTRICITY COSTS
+
+To further demonstrate the potential of our proposed control framework in dealing with different real world tasks, we modify the setting of the building control example in Section 4.2 to a more complicated case. Instead of directly minimize the total energy consumption of building, we aim to minimize the total energy cost of building which subject to a varying time-of-use electrical price $\lambda$ The optimization problem in (7) should be re-written as,
+
+$$
+\begin{array} { r l } { \underset { \mathbf { u } _ { t } , \ldots , \mathbf { u } _ { t + T } } { \mathrm { m i n i m i z e } } } & { \displaystyle \sum _ { \tau = 0 } ^ { T } \lambda _ { \tau } \cdot f \big ( \mathbf { x } _ { t + \tau - n _ { w } } , \ldots , \mathbf { x } _ { t + \tau } \big ) } \\ { \mathrm { s u b j e c t ~ t o } } & { \mathbf { s } _ { t + \tau } = g \big ( \mathbf { x } _ { t + \tau - n _ { w } } , \ldots , \mathbf { x } _ { t + \tau - 1 } , \mathbf { u } _ { t + \tau } \big ) , \forall \tau } \\ & { \mathbf { u } _ { t + \tau } \le \mathbf { u } _ { t + \tau } \le \overline { { \mathbf { u } } } _ { t + \tau } , \forall \tau } \\ & { \mathbf { s } _ { t + \tau } \le \mathbf { s } _ { t + \tau } \le \overline { { \mathbf { s } } } _ { t + \tau } , \forall \tau } \end{array}
+$$
+
+where the objective (14a) is minimizing the total energy cost of building in future $T$ steps ( $T$ is the model predictive control horizon) subject to time-of-use electricity price $\lambda _ { \tau }$ , and (14b) is used for modeling building states, in which $g ( \cdot )$ are parameterized as ICRNNs. Same as the previous building control case, we have constraints on both control actions ${ \bf u } _ { t }$ and system states $\mathbf { s } _ { t }$ are given in (14c) and (14d). For instance, the temperature set points as well as real measurements should not exceed user-defined comfort regions. In Fig. 10 we visualize our model flexibility by using Seattle’s Time-of-Use (TOU) price from Seattle City Light 4, and minimizing one week’s electricity bills. We could see ICRNN capture the long term relationships between control variables and final costs, and raise the energy consumption during off-peak price a little, but reduce the energy consumption during peak hours.
+
+![](images/bb71ac663e4be85a9c497ab19faae76199256d4e10930d65e19e8645416bfdac.jpg)  
+Figure 10: (a) 24 hour price signal along with (b) optimization results on one-week electricity usage of building using ICRNN.
+
+# E.2 CONTROL CONSTRAINTS EFFECTS
+
+In Fig. 11 we add one more comparison on the control constraints effects on the final control performance by using ICRNN. Interestingly, with different set point constraints, the ICRNN finds similar solutions for off-peak electricity usage, which may correspond to necessary energy consumptions, such as lightning and ventilation. Moreover, when we set no constraints on the system, it would cut down more than $80 \%$ of total energy during peak hours.
+
+![](images/ccbe5ecadd681bfae6471a9c48aaddba02c81e8a571d8e8b03fffb055290dd88.jpg)  
+Figure 11: Results on one-week electricity usage of building using input convex neural network control method based upon different control constrains.

parse/train/HJ94fqApW/HJ94fqApW.md

@@ -0,0 +1,288 @@
+# RETHINKING THE SMALLER-NORM-LESSINFORMATIVE ASSUMPTION IN CHANNEL PRUNING OF CONVOLUTION LAYERS
+
+Jianbo $\mathbf { Y e ^ { * } }$   
+College of Information Sciences and Technology   
+The Pennsylvania State University   
+jxy198@ist.psu.edu   
+Xin Lu, Zhe Lin   
+Adobe Research   
+{xinl,zlin}@adobe.com   
+James Z. Wang   
+College of Information Sciences and Technology   
+The Pennsylvania State University   
+jwang@ist.psu.edu
+
+# ABSTRACT
+
+Model pruning has become a useful technique that improves the computational efficiency of deep learning, making it possible to deploy solutions in resourcelimited scenarios. A widely-used practice in relevant work assumes that a smallernorm parameter or feature plays a less informative role at the inference time. In this paper, we propose a channel pruning technique for accelerating the computations of deep convolutional neural networks (CNNs) that does not critically rely on this assumption. Instead, it focuses on direct simplification of the channel-tochannel computation graph of a CNN without the need of performing a computationally difficult and not-always-useful task of making high-dimensional tensors of CNN structured sparse. Our approach takes two stages: first to adopt an end-toend stochastic training method that eventually forces the outputs of some channels to be constant, and then to prune those constant channels from the original neural network by adjusting the biases of their impacting layers such that the resulting compact model can be quickly fine-tuned. Our approach is mathematically appealing from an optimization perspective and easy to reproduce. We experimented our approach through several image learning benchmarks and demonstrate its interesting aspects and competitive performance.
+
+# 1 INTRODUCTION
+
+Not all computations in a deep neural network are of equal importance. In a typical deep learning pipeline, an expert crafts a neural architecture, which is trained using a prepared dataset. The success of training a deep model often requires trial and error, and such loop usually has little control on prioritizing the computations happening in the neural network. Recently researchers started to develop model-simplification methods for convolutional neural networks (CNNs), bearing in mind that some computations are indeed non-critical or redundant and hence can be safely removed from a trained model without substantially degrading the model’s performance. Such methods not only accelerate computational efficiency but also possibly alleviate the model’s overfitting effects.
+
+Discovering which subsets of the computations of a trained CNN are more reasonable to prune, however, is nontrivial. Existing methods can be categorized from either the learning perspective or from the computational perspective. From the learning perspective, some methods use a dataindependent approach where the training data does not assist in determining which part of a trained CNN should be pruned, e.g. He et al. (2017) and Zhang et al. (2016), while others use a datadependent approach through typically a joint optimization in generating pruning decisions, e.g., Han et al. (2015) and Anwar et al. (2017). From the computational perspective, while most approaches focus on setting the dense weights of convolutions or linear maps to be structured sparse, we propose here a method adopting a new conception to achieve in effect the same goal.
+
+Instead of regarding the computations of a CNN as a collection of separate computations sitting at different layers, we view it as a network flow that delivers information from the input to the output through different channels across different layers. We believe saving computations of a CNN is not only about reducing what are calculated in an individual layer, but perhaps more importantly also about understanding how each channel is contributing to the entire information flow in the underlying passing graph as well as removing channels that are less responsible to such process. Inspired by this new conception, we propose to design a “gate” at each channel of a CNN, controlling whether its received information is actually sent out to other channels after processing. If a channel “gate” closes, its output will always be a constant. In fact, each designed “gate” will have a prior intention to close, unless it has a “strong” duty in sending some of its received information from the input to subsequent layers. We find that implementing this idea in pruning CNNs is unsophisticated, as will be detailed in Sec 4.
+
+Our method neither introduces any extra parameters to the existing CNN, nor changes its computation graph. In fact, it only introduces marginal overheads to existing gradient training of CNNs. It also possess an attractive feature that one can successively build multiple compact models with different inference performances in a single round of resource-intensive training (as in our experiments). This eases the process to choose a balanced model to deploy in production. Probably, the only applicability constraint of our method is that all convolutional layers and fully-connected layer (except the last layer) in the CNN should be batch normalized (Ioffe & Szegedy, 2015). Given batch normalization has becomes a widely adopted ingredient in designing state-of-the-art deep learning models, and many successful CNN models are using it, we believe our approach has a wide scope of potential impacts.1
+
+In this paper, we start from rethinking a basic assumption widely explored in existing channel pruning work. We point out several issues and gaps in realizing this assumption successfully. Then, we propose our alternative approach, which works around several numerical difficulties. Finally, we experiment our method across different benchmarks and validate its usefulness and strengths.
+
+# 2 RELATED WORK
+
+Reducing the size of neural network for speeding up its computational performance at inference time has been a long-studied topic in the communities of neural network and deep learning. Pioneer works include Optimal Brain Damage (LeCun et al., 1990) and Optimal Brain Surgeon (Hassibi & Stork, 1993). More recent developments focused on either reducing the structural complexity of a provided network or training a compact or simplified network from scratch. Our work can be categorized into the former, thus the literature review below revolves around reducing the structural complexity.
+
+To reduce the structural complexity of deep learning models, previous work have largely focused on sparsifying the weights of convolutional kernels or the feature maps across multiple layers in a network (Anwar et al., 2017; Han et al., 2015). Some recent efforts proposed to impose structured sparsity on those vector components motivated from the implementation perspective on specialized hardware (Wen et al., 2016; Zhou et al., 2016; Alvarez & Salzmann, 2016; Lebedev & Lempitsky, 2016). Yet as argued by Molchanov et al. (2017), regularization-based pruning techniques require per layer sensitivity analysis which adds extra computations. Their method relies on global rescaling of criteria for all layers and does not require sensitivity estimation, a beneficial feature that our approach also has. To our knowledge, it is also unclear how widely useful those works are in deep learning. In Section 3, we discuss in details the potential issues in regularization-based pruning techniques potentially hurting them being widely applicable, especially for those that regularize high-dimensional tensor parameters or use magnitude-based pruning methods. Our approach works around the mentioned issues by constraining the anticipated pruning operations only to batchnormalized convolutional layers. Instead of posing structured sparsity on kernels or feature maps, we enforce sparsity on the scaling parameter $\gamma$ in batch normalization operator. This blocks the sample-wise information passing through part of the channels in convolution layer, and in effect implies one can safely remove those channels.
+
+A recent work by Huang & Wang (2017) used a similar technique as ours to remove unimportant residual modules in ResNet by introducing extra scaling factors to the original network. However, some optimization subtleties as to be pointed out in our paper were not well explained. Another recent work called Network-Slimming (Liu et al., 2017) also aims to sparsify the scaling parameters of batch normalization. But instead of using off-the-shelf gradient learning like theirs, we propose a new algorithmic approach based on ISTA and rescaling trick, improving robustness and speed of the undergoing optimization. In particular, the work of Liu et al. (2017) was able to prune VGG-A model on ImageNet. It is unclear how their work would deal with the $\gamma { - } W$ rescaling effect and whether their approach can be adopted to large pre-trained models, such as ResNets and Inceptions. We experimented with the pre-trained ResNet-101 and compared to most recent work that were shown to work well with large CNNs. We also experimented with an image segmentation model which has an inception-like module (pre-trained on ImageNet) to locate foreground objects.
+
+# 3 RETHINKING THE SMALLER-NORM-LESS-INFORMATIVE ASSUMPTION
+
+In most regularized linear regressions, a large-norm coefficient is often a strong indicator of a highly informative feature. This has been widely perceived in statistics and machine learning communities. Removing features which have a small coefficient does not substantially affect the regression errors. Therefore, it has been an established practice to use tractable norm to regularize the parameters in optimizing a model and pick the important ones by comparing their norms after training. However, this assumption is not unconditional. By using Lasso or ridge regression to select important predictors in linear models, one always has to first normalize each predictor variable. Otherwise, the result might not be explanatory. For example, ridge regression penalizes more the predictors which has low variance, and Lasso regression enforces sparsity of coefficients which are already small in OLS. Such normalization condition for the right use of regularization is often unsatisfied for nonconvex learning. For example, one has to carefully consider two issues outlined below. We provides these two cases to exemplify how regularization could fail or be of limited usage. There definitely exist ways to avoid the described failures.
+
+Model Reparameterization. In the first case, we show that it is not easy to have fine-grained control of the weights’ norms across different layers. One has to either choose a uniform penalty in all layers or struggle with the reparameterization patterns. Consider to find a deep linear (convolutional) network subject to a least square with Lasso: for $\lambda > 0$ ,
+
+$$
+\operatorname* { m i n } _ { \{ W _ { i } \} _ { i = 1 } ^ { 2 n } } \mathbb { E } _ { ( x , y ) \sim \mathcal { D } } \| W _ { 2 n } \ast \ldots \ast W _ { 2 } \ast W _ { 1 } \ast x - y \| ^ { 2 } + \lambda \sum _ { i = 1 } ^ { n } \| W _ { 2 i } \| _ { 1 } .
+$$
+
+The above formulation is not a well-defined problem because for any parameter set 0 2n $\{ W _ { i } \} _ { i = 1 } ^ { 2 n }$ , one i=1can always find another parameter set {W i } i=1 such that it achieves a smaller total loss while keeping the corresponding $l _ { 0 }$ norm unchanged by actually setting
+
+$$
+W _ { i } ^ { \prime } = \alpha W _ { i } , i = 1 , 3 , \ldots , 2 n - 1 \mathrm { ~ a n d ~ } W _ { i } ^ { \prime } = W _ { i } / \alpha , i = 2 , 4 , \ldots , 2 n .
+$$
+
+where $\alpha > 1$ . In another word, for any $\epsilon > 0$ , one can always find a parameter set $\{ W _ { i } \} _ { i = 1 } ^ { 2 n }$ (which is usually non-sparse) that minimizes the first least square loss while having its second Lasso term less than $\epsilon$ .
+
+We note that gradient-based learning is highly inefficient in exploring such model reparameterization patterns. In fact, there are some recent discussions around this (Dinh et al., 2017). If one adopts a pre-trained model, and augments its original objective with a new norm-based parameter regularization, the new gradient updates may just increase rapidly or it may take a very long time for the variables traveling along the model’s reparameterization trajectory. This highlights a theoretical gap questioning existing sparsity-inducing formulation and actual computational algorithms whether they can achieve widely satisfactory parameter sparsification for deep learning models.
+
+Transform Invariance. In the second case, we show that batch normalization is not compatible with weight regularization. The example is penalizing $l _ { 1 }$ - or $l _ { 2 }$ -norms of filters in convolution layer which is then followed by a batch normalization: at the $l$ -th layer, we let
+
+$$
+x ^ { l + 1 } = \operatorname* { m a x } \{ \gamma \cdot \mathbf { B N } _ { \mu , \sigma , \epsilon } ( W ^ { l } * x ^ { l } ) + \beta , 0 \} ,
+$$
+
+where $\gamma$ and $\beta$ are vectors whose length is the number of channels. Likewise, one can clearly see that any uniform scaling of $W ^ { l }$ which changes its $l _ { 1 }$ - and $l _ { 2 }$ -norms would have no effects on the output $x ^ { l + 1 }$ . Alternatively speaking, if one is interested in minimizing the weight norms of multiple layers together, it becomes unclear how to choose proper penalty for each layer. Theoretically, there always exists an optimizer that can change the weight to one with infinitesimal magnitude without hurting any inference performance. As pointed by one of the reviewers, one can tentatively avoid this issue by projecting the weights to the surface of unit ball. Then one has to deal with a non-convex feasible set of parameters, causing extra difficulties in developing optimization for data-dependent pruning methods. It is also worth noting that some existing work used such strategy in a layer-by-layer greedy way (He et al., 2017; Zhang et al., 2016).
+
+Based on this discussion, many existing works which claim to use Lasso, group Lasso (e.g. Wen et al. (2016); Anwar et al. (2017)), or thresholding (e.g. Molchanov et al. (2017)) to enforce parameter sparsity have some theoretical gaps to bridge. In fact, many heuristic algorithms in neural net pruning actually do not naturally generate a sparse parameterized solution. More often, thresholding is used to directly set certain subset of the parameters in the network to zeros, which can be problematic. The reason is in essence around two questions. First, by setting parameters less than a threshold to zeros, will the functionality of neural net be preserved approximately with certain guarantees? If yes, then under what conditions? Second, how should one set those thresholds for weights across different layers? Not every layer contributes equally in a neural net. It is expected that some layers act critically for the performance but only use a small computation and memory budget, while some other layers help marginally for the performance but consume a lot resources. It is naturally more desirable to prune calculations in the latter kind of layers than the former.
+
+In contrast with these existing approaches, we focus on enforcing sparsity of a tiny set of parameters in CNN — scale parameter $\gamma \mathbf { s }$ in all batch normalization. Not only placing sparse constraints on $\gamma$ is simpler and easier to monitor, but more importantly, we have two strong reasons:
+
+1. Every $\gamma$ always multiplies a normalized random variable, thus the channel importance becomes comparable across different layers by measuring the magnitude values of $\gamma$ ;   
+2. The reparameterization effect across different layers is avoided if its subsequent convolution layer is also batch-normalized. In other words, the impacts from the scale changes of $\gamma$ parameter are independent across different layers.
+
+Nevertheless, our current work still falls short of a strong theoretical guarantee. We believe by working with normalized feature inputs and their regularized coefficients together, one is closer to a more robust and meaningful approach. Sparsity is not the goal, but to find less important channels using sparsity inducing formulation is.
+
+# 4 CHANNEL PRUNING OF BATCH-NORMALIZED CNN
+
+We describe the basic principle and algorithm of our channel pruning technique.
+
+# 4.1 PRELIMINARIES
+
+Pruning constant channels. Consider convolution with batch normalization:
+
+$$
+x ^ { l + 1 } = \operatorname* { m a x } \left\{ \gamma ^ { l } \cdot { \mathrm { B N } } _ { \mu ^ { l } , \sigma ^ { l } , \epsilon ^ { l } } ( W ^ { l } * x ^ { l } ) + \beta ^ { l } , 0 \right\} .
+$$
+
+For the ease of notation, we let $\gamma = \gamma ^ { l }$ . Note that if some element in $\gamma$ is set to zero, say, $\gamma [ k ] = 0$ , its output image xl+1:,:,:,k becomes a constant $\beta _ { k }$ , and a convolution of a constant image channel is almost everywhere constant (except for padding regions, an issue to be discussed later). Therefore, we show those constant image channels can be pruned while the same functionality of network is approximately kept:
+
+• If the subsequent convolution layer does not have batch normalization,
+
+$$
+x ^ { l + 2 } = \operatorname* { m a x } \left\{ W ^ { l + 1 } * x ^ { l + 1 } + b ^ { l + 1 } , 0 \right\} ,
+$$
+
+its values (a.k.a. elements in $\beta$ ) is absorbed into the bias term by the following equation
+
+$$
+b _ { n e w } ^ { l + 1 } : = b ^ { l + 1 } + I ( \gamma = 0 ) \cdot \mathrm { R e L U } ( \beta ) ^ { T } \mathrm { s u m . r e d u c e d } ( W _ { : , : , \cdot } ^ { l + 1 } , ) ,
+$$
+
+such that
+
+$$
+x ^ { l + 2 } \approx \mathrm { m a x } \left\{ W ^ { l + 1 } * _ { \gamma } x ^ { l + 1 } + b _ { n e w } ^ { l + 1 } , 0 \right\} ,
+$$
+
+where $\ast _ { \gamma }$ denotes the convolution operator which is only calculated along channels indexed by non-zeros of $\gamma$ . Remark that $W ^ { * } =$ sum reduced $( W _ { : , : , \cdot , \cdot } )$ if $\begin{array} { r } { W _ { a , b } ^ { * } = \sum _ { i , j } W _ { i , j , a , b } } \end{array}$ .
+
+• If the subsequent convolution layer has batch normalization,
+
+$$
+x ^ { l + 2 } = \operatorname * { m a x } \left\{ \gamma ^ { l + 1 } \cdot { \bf B } { \bf N } _ { \mu ^ { l + 1 } , \sigma ^ { l + 1 } , \epsilon ^ { l + 1 } } \left( W ^ { l + 1 } * x ^ { l + 1 } \right) + \beta ^ { l + 1 } , 0 \right\} ,
+$$
+
+instead its moving average is updated as
+
+$$
+\begin{array} { r } { \mu _ { n e w } ^ { l + 1 } : = \mu ^ { l + 1 } - I ( \gamma = 0 ) \cdot \mathrm { R e L U } ( \beta ) ^ { T } \mathrm { s u m . r e d u c e d } ( W _ { : , : , \cdot , \cdot } ^ { l + 1 } ) , } \end{array}
+$$
+
+such that
+
+$$
+x ^ { l + 2 } \approx \operatorname * { m a x } \left\{ \gamma ^ { l + 1 } \cdot { \bf B N } _ { \mu _ { n e w } ^ { l + 1 } , \sigma ^ { l + 1 } , \epsilon ^ { l + 1 } } \left( W ^ { l + 1 } * _ { \gamma } x ^ { l + 1 } \right) + \beta ^ { l + 1 } , 0 \right\} .
+$$
+
+Remark that the approximation $( \approx )$ is strictly equivalence $( = )$ if no padding is used in the convolution operator $^ *$ , a feature that the parallel work Liu et al. (2017) does not possess. When the original model uses padding in computing convolution layers, the network function is not strictly preserved after pruning. In our practice, we fine-tune the pruned network to fix such performance degradation at last. In short, we formulate the network pruning problem as simple as to set more elements in $\gamma$ to zero. It is also much easier to deploy the pruned model, because no extra parameters or layers are introduced into the original model.
+
+To better understand how it works in an entire CNN, imagine a channel-to-channel computation graph formed by the connections between layers. In this graph, each channel is a node, their inference dependencies are represented by directed edges. The $\gamma$ parameter serves as a “dam” at each node, deciding whether let the received information “flood” through to other nodes following the graph. An end-to-end training of channel pruning is essentially like a flood control system. There suppose to be rich information of the input distribution, and in two ways, much of the original input information is lost along the way of CNN inference, and the useful part — that is supposed to be preserved by the network inference — should be label sensitive. Conventional CNN has one way to reduce information: transforming feature maps (non-invertible) via forward propagation. Our approach introduces the other way: block information at each channel by forcing its output being constant using ISTA.
+
+ISTA. Despite the gap between Lasso and sparsity in the non-convex settings, we found that ISTA (Beck & Teboulle, 2009) is still a useful sparse promoting method. But we just need to use it more carefully. Specifically, we adopt ISTA in the updates of $\gamma \mathbf { s }$ . The basic idea is to project the parameter at every step of gradient descent to a potentially more sparse one subject to a proxy problem: let $l$ denote the training loss of interest, at the $( t + 1 )$ -th step, we set
+
+$$
+\gamma _ { t + 1 } = \operatorname* { m i n } _ { \gamma } \frac { 1 } { \mu _ { t } } \| \gamma - \gamma _ { t } + \mu _ { t } \nabla _ { \gamma } l _ { t } \| ^ { 2 } + \lambda \| \gamma \| _ { 1 } \mathrm { ~ , ~ }
+$$
+
+where $\nabla _ { \gamma } l _ { t }$ is the derivative with respect to $\gamma$ computed at step $t$ , $\mu _ { t }$ is the learning rate, $\lambda$ is the penalty. In the stochastic learning, $\nabla _ { \gamma } l _ { t }$ is estimated from a mini-batch at each step. Eq. (1) has closed form solution as
+
+$$
+\gamma _ { t + 1 } = \mathrm { p r o x } _ { \mu _ { t } \lambda } \bigl ( \gamma _ { t } - \mu _ { t } \nabla _ { \gamma } l _ { t } \bigr ) ,
+$$
+
+where $\mathrm { p r o x } _ { \eta } ( x ) = \operatorname* { m a x } \{ | x | - \eta , 0 \} \cdot \mathrm { s g n } ( x )$ . The ISTA method essentially serves as a “flood control system” in our end-to-end learning, where the functionality of each $\gamma$ is like that of a dam. When $\gamma$ is zero, the information flood is totally blocked, while $\gamma \neq 0$ , the same amount of information is passed through in form of geometric quantities whose magnitudes are proportional to $\gamma$ .
+
+Scaling effect. One can also see that if $\gamma$ is scaled by $\alpha$ meanwhile $W ^ { l + 1 }$ is scaled by $1 / \alpha$ , that is,
+
+$$
+\gamma : = \alpha \gamma , \qquad W ^ { l + 1 } : = \frac { 1 } { \alpha } W ^ { l + 1 }
+$$
+
+the output $x ^ { l + 2 }$ is unchanged for the same input $x ^ { l }$ . Despite not changing the output, scaling of $\gamma$ and $W ^ { l + 1 }$ also scales the gradients $\nabla _ { \gamma } l$ and $\nabla _ { W ^ { l + 1 } } l$ by $1 / \alpha$ and $\alpha$ , respectively. As we observed, the parameter dynamics of gradient learning with ISTA depends on the scaling factor $\alpha$ if one decides to choose it other than 1.0. Intuitively, if $\alpha$ is large, the optimization of $\bar { W } ^ { l + 1 }$ is progressed much slower than that of $\gamma$ .
+
+# 4.2 THE ALGORITHM
+
+We describe our algorithm below. The following method applies to both training from scratch or re-training from a pre-trained model. Given a training loss $l$ , a convolutional neural net $\mathcal { N }$ , and hyper-parameters $\rho , \alpha , \mu _ { 0 }$ , our method proceeds as follows:
+
+1. Computation of sparse penalty for each layer. Compute the memory cost per channel for each layer denoted by $\setminus { l }$ and set the ISTA penalty for layer $l$ to $\rho \lambda ^ { l }$ . Here
+
+$$
+\lambda ^ { l } = \frac { 1 } { I _ { w } ^ { i } \cdot I _ { h } ^ { i } } \left[ k _ { w } ^ { l } \cdot k _ { h } ^ { l } \cdot c ^ { l - 1 } + \sum _ { l ^ { \prime } \in \mathcal { T } ( l ) } k _ { w } ^ { l ^ { \prime } } \cdot k _ { h } ^ { l ^ { \prime } } \cdot c ^ { l ^ { \prime } } + I _ { w } ^ { l } \cdot I _ { h } ^ { l } \right] ,
+$$
+
+where
+
+• $I _ { w } ^ { i } \cdot I _ { h } ^ { i }$ is the size of input image of the neural network.   
+• $k _ { w } ^ { l } \cdot k _ { h } ^ { l }$ is the kernel size of the convolution at layer $l$ . Likewise, $k _ { w } ^ { l ^ { \prime } } \cdot k _ { h } ^ { l ^ { \prime } }$ is the kernel size of subsequent convolution at layer $l ^ { \prime }$ .   
+• $\tau ( l )$ represents the set of the subsequent convolutional layers of layer $l$   
+• $c ^ { l - 1 }$ denotes the channel size of the previous layer, which the $l$ -th convolution operates over; and $c ^ { l ^ { \prime } }$ denotes the channel size of one subsequent layer $l ^ { \prime }$ .   
+• $I _ { w } ^ { l } \cdot I _ { h } ^ { l }$ is the image size of the feature map at layer $l$ .
+
+2. $\gamma { = } W$ rescaling trick. For layers whose channels are going to get reduced, scale all $\gamma ^ { l } \mathbf { s }$ i n batch normalizations by $\alpha$ meanwhile scale weights in their subsequent convolutions by $1 / \alpha$ .
+
+3. End-to-End training with ISTA on $\gamma$ . Train $\mathcal { N }$ by the regular SGD, with the exception that $\gamma ^ { l } \mathbf { s }$ are updated by ISTA, where the initial learning rate is $\mu _ { 0 }$ . Train $\mathcal { N }$ until the loss $l$ plateaus, the total sparsity of $\gamma ^ { l } \mathbf { s }$ converges, and Lasso $\textstyle { \dot { \rho } } \sum _ { l } \lambda ^ { l } \| \gamma ^ { l } \| _ { 1 }$ converges.   
+4. Post-process to remove constant channels. Prune channels in layer $l$ whose elements in $\gamma ^ { l }$ are zero and output the pruned model $\widetilde { \mathcal { N } }$ by absorbing all constant channels into subsequent layers (as described in the earlier section.).   
+5. $\gamma { = } W$ rescaling trick. For $\gamma ^ { l } \mathbf { s }$ and weights in $\widetilde { \mathcal { N } }$ which were scaled in Step 2 before training, scale them by $1 / \alpha$ and $\alpha$ respectively (scaling back).   
+6. Fine-tune $\widetilde { \mathcal { N } }$ using regular stochastic gradient learning.
+
+Remark that choosing a proper $\alpha$ as used in Steps 2 and 5 is necessary for using a large $\mu _ { t } \cdot \rho$ in ISTA, which makes the sparsification progress of $\gamma ^ { l } \mathbf { s }$ faster.
+
+# 4.3 GUIDELINES FOR TUNING HYPER-PARAMETERS
+
+We summarize the sensitivity of hyper-parameters and their impacts for optimization below:
+
+• $\mu$ (learning rate): larger $\mu$ leads to fewer iterations for convergence and faster progress of sparsity. But if if $\mu$ too large, the SGD approach wouldn’t converge. • $\rho$ (sparse penalty): larger $\rho$ leads to more sparse model at convergence. If trained with a very large $\rho$ , all channels will be eventually pruned.
+
+• $\alpha$ (rescaling): we use $\alpha$ other than 1. only for pretrained models, we typically choose $\alpha$ from $\{ 0 . 0 0 1 , 0 . 0 1 , 0 . 1 , 1 \}$ and smaller $\alpha$ warms up the progress of sparsity.
+
+We recommend the following parameter tuning strategy. First, check the cross-entropy loss and the regularization loss, select $\rho$ such that these two quantities are comparable at the beginning. Second, choose a reasonable learning rate. Third, if the model is pretrained, check the average magnitude of $\gamma \mathbf { s }$ in the network, choose $\alpha$ such that the magnitude of rescaled $\gamma ^ { l }$ is around $1 0 0 \bar { \mu } \lambda ^ { l } \rho$ . We found as long as one choose those parameters in the right range of magnitudes, the optimization progress is enough robust. Again one can monitor the mentioned three quantities during the training and terminate the iterations when all three quantities plateaus.
+
+There are several patterns we found during experiments that may suggest the parameter tuning has not been successful. If during the first few epochs the Lasso-based regularization loss keeps decreasing linearly while the sparsity of $\gamma \mathbf { s }$ stays near zero, one may decrease $\alpha$ and restart. If during the first few epochs the sparsity of $\gamma \mathbf { s }$ quickly raise up to $100 \%$ , one may decrease $\rho$ and restart. If during the first few epochs the cross-entropy loss keeps at or increases dramatically to a non-informative level, one may decrease $\mu$ or $\rho$ and restart.
+
+# 5 EXPERIMENTS
+
+# 5.1 CIFAR-10 EXPERIMENT
+
+We experiment with the standard image classification benchmark CIFAR-10 with two different network architectures: ConvNet and ResNet-20 (He et al., 2016). We resize images to $3 2 \times 3 2$ and zero-pad them to $4 0 \times 4 0$ . We pre-process the padded images by randomly cropping with size $3 2 \times 3 2$ , randomly flipping, randomly adjusting brightness and contrast, and standardizing them such that their pixel values have zero mean and one variance.
+
+ConvNet For reducing the channels in ConvNet, we are interested in studying whether one can easily convert a over-parameterized network into a compact one. We start with a standard 4-layer convolutional neural network whose network attributes are specified in Table 1. We use a fixed learning rate $\mu _ { t } = 0 . 0 1$ , scaling parameter $\alpha = 1 . 0$ , and set batch size to 125.
+
+Model A is trained from scratch using the base model with an initial warm-up $\rho ~ = ~ 0 . 0 0 0 2$ for $3 0 \mathrm { k }$ steps, and then is trained by raising up $\rho$ to 0.001. After the termination criterion are met, we prune the channels of the base model to generate a smaller network called model A. We evaluate the classification performance of model A with the running exponential average of its parameters. It is found that the test accuracy of model A is even better than the base model. Next, we start from the pre-trained model A to create model B by raising $\rho$ up to 0.002. We end up with a smaller network called model B, which is about $1 \%$ worse than model A, but saves about one third parameters. Likewise, we start from the pre-trained model B to create model C. The detailed statistics and its pruned channel size are reported in Table 1. We also train a reference ConvNet from scratch whose channel sizes are 32-64-64-128 with totally 224,008 parameters and test accuracy being $8 6 . 3 \%$ . The referenced model is not as good as Model B, which has smaller number of parameters and higher accuracy.
+
+We have two major observations from the experiment: (1) When the base network is overparameterized, our approach not only significantly reduces the number of channels of the base model but also improves its generalization performance on the test set. (2) Performance degradation seems unavoidable when the channels in a network are saturated, and our approach gives satisfactory tradeoff between test accuracy and model efficiency.
+
+ResNet-20 We also want to verify our second observation with the state-of-art models. We choose the popular ResNet-20 as our base model for the CIFAR-10 benchmark, whose test accuracy is $92 \%$ . We focus on pruning the channels in the residual modules in ResNet-20, which has 9 convolutions in total. As detailed in Table 2, model A is trained from scratch using ResNet-20’s network structure as its base model. We use a warm-up $\rho = 0 . 0 0 1$ for 30k steps and then train with $\rho = 0 . 0 0 5$ . We are able to remove $37 \%$ parameters from ResNet-20 with only about 1 percent accuracy loss. Likewise, Model B is created from model A with a higher penalty $\rho = 0 . 0 1$ .
+
+Table 1: Comparisons between different pruned networks and the base network.   
+
+<table><tr><td colspan="4">base</td><td>model A</td><td>model B</td><td></td><td>model C</td></tr><tr><td>layer</td><td>output</td><td>kernel</td><td>channel</td><td>channel</td><td>channel</td><td></td><td>channel</td></tr><tr><td>conv1</td><td>32 × 32</td><td>5×5</td><td>96</td><td>53</td><td>41</td><td></td><td>31</td></tr><tr><td>pool1</td><td>16 ×16</td><td>3×3</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>conv2</td><td>16 ×16</td><td>5×5</td><td>192</td><td>86</td><td></td><td>64</td><td>52</td></tr><tr><td>pool2</td><td>8×8</td><td>3×3</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>conv3</td><td>8×8</td><td>3×3</td><td>192</td><td>67</td><td></td><td>52</td><td>40</td></tr><tr><td>pool4</td><td>4×4</td><td>3×3</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>fc</td><td>1×1</td><td>4×4</td><td>384</td><td>128</td><td>128</td><td></td><td>127</td></tr><tr><td>p</td><td></td><td></td><td></td><td></td><td>0.001</td><td>0.002</td><td>0.008</td></tr><tr><td>param. size</td><td></td><td></td><td>1,986,760</td><td>309,655</td><td></td><td>207,583</td><td>144,935</td></tr><tr><td>test accuracy (%)</td><td></td><td></td><td>89.0</td><td>89.5</td><td></td><td>87.6</td><td>86.0</td></tr></table>
+
+Table 2: Comparisons between ResNet-20 and its two pruned versions. The last columns are the number of channels of each residual modules after pruning.   
+
+<table><tr><td></td><td>group - block</td><td>1-1</td><td>1-2</td><td>1-3</td><td>2-1</td><td>2-2</td><td>2-3</td><td>3-1</td><td>3-2</td><td>3-3</td></tr><tr><td>ResNet-20</td><td>channels param size.= 281,304 test accuracy (%) = 92.0</td><td>16</td><td>16</td><td>16</td><td>32</td><td>32</td><td>32</td><td>64</td><td>64</td><td>64</td></tr><tr><td>model A</td><td>channels param size. = 176,596 test accuracy (%) = 90.9</td><td>12</td><td>6</td><td>11</td><td>32</td><td>28</td><td>28</td><td>47</td><td></td><td>3425</td></tr><tr><td>model B</td><td>channels param size.= 90,504 test accuracy (%) = 88.8</td><td>8</td><td>2</td><td>今</td><td></td><td>271816</td><td></td><td>25</td><td>9</td><td>8</td></tr></table>
+
+# 5.2 ILSVRC2012 EXPERIMENT
+
+We experiment our approach with the pre-trained ResNet-101 on ILSVRC2012 image classification dataset (He et al., 2016). ResNet-101 is one of the state-of-the-art network architecture in ImageNet Challenge. We follow the standard pipeline to pre-process images to $2 2 4 \times 2 2 4$ for training ResNets. We adopt the pre-trained TensorFlow ResNet-101 model whose single crop error rate is $2 3 . 6 \%$ with about $4 . 4 7 \times 1 0 ^ { 7 }$ parameters.2 We set the scaling parameter $\alpha = 0 . 0 1$ , the initial learning rate $\mu _ { t } = 0 . 0 0 1$ , the sparsity penalty $\rho = 0 . 1$ , and the batch $\mathrm { s i z e } = 1 2 8$ (across 4 GPUs). The learning rate is decayed every four epochs with rate 0.86. We create two pruned models from the different iterations of training ResNet-101: one has $2 . 3 6 \times 1 0 ^ { 7 }$ parameters and the other has $1 . 7 3 \times 1 0 ^ { 7 }$ parameters. We then fine-tune these two models using the standard way for training ResNet-101, and report their error rates. The Top-5 error rate increases of both models are less than $0 . 5 \%$ . The Top-1 error rates are summarized in Table 3. To our knowledge, only a few works have reported their performance on this very large-scale benchmark w.r.t. the Top-1 errors. We compare our approach with some recent works in terms of model parameter size, flops, and error rates. As shown in Table 3, our model v2 has achieved a compression ratio more than 2.5 while maintaining more than $1 \%$ lower error rates than that of other state-of-the-art models at comparable size of parameters.
+
+In the first experiment (CIFAR-10), we train the network from scratch and allocate enough steps for both $\gamma$ and $W$ adjusting their own scales. Thus, initialization of an improper scale of $\gamma { - } W$ is not really an issue given we optimize with enough steps. But for the pre-trained models which were originally optimized without any constraints of $\gamma$ , the $\gamma \mathbf { s }$ scales are often unanticipated. It actually takes as many steps as that of training from scratch for $\gamma$ to warm up. By adopting the rescaling trick setting $\alpha$ to a smaller value, we are able to skip the warm-up stage and quick start to sparsify $\gamma \mathbf { s }$ . For example, it might take more than a hundred epoch to train ResNet-101, but it only takes about 5-10 epochs to complete the pruning and a few more epochs to fine-tune.
+
+<table><tr><td>network</td><td>param size.</td><td>fops</td><td>error (%)</td><td>ratio</td></tr><tr><td>resnet-50 pruned (Huang &amp; Wang,2017)</td><td>~1.65×107</td><td>3.03×109</td><td>~26.8</td><td>66%</td></tr><tr><td>resnet-101 pruned (v2,ours)</td><td>1.73 ×107</td><td>3.69×109</td><td>25.44</td><td>39%</td></tr><tr><td>resnet-34 pruned (Li et al., 2017)</td><td>1.93 ×107</td><td>2.76 ×109</td><td>27.8</td><td>89%</td></tr><tr><td>resnet-34</td><td>2.16 ×107</td><td>3.64×109</td><td>26.8</td><td>1</td></tr><tr><td>resnet-101 pruned (v1, ours)</td><td>2.36×107</td><td>4.47 ×109</td><td>24.73</td><td>53%</td></tr><tr><td>resnet-50</td><td>2.5×107</td><td>4.08 ×109</td><td>24.8</td><td>1</td></tr><tr><td>resnet-101</td><td>4.47 × 107</td><td>7.8×109</td><td>23.6</td><td>1</td></tr></table>
+
+Table 3: Attributes of different versions of ResNet and their single crop errors on ILSVRC2012 benchmark. The last column means the parameter size of pruned model vs. the base model.
+
+# 5.3 IMAGE FOREGROUND-BACKGROUND SEGMENTATION EXPERIMENT
+
+As we have discussed about the two major observations in Section 5.1, a more appealing scenario is to apply our approach in pruning channels of over-parameterized model. It often happens when one adopts a pre-trained network on a large task (such as ImageNet classification) and fine-tunes the model to a different and smaller task (Molchanov et al., 2017). In this case, one might expect that some channels that have been useful in the first pre-training task are not quite contributing to the outputs of the second task.
+
+We describe an image segmentation experiment whose neural network model is composed from an inception-like network branch and a densenet network branch. The entire network takes a $2 2 4 \times 2 2 4$ image and outputs binary mask at the same size. The inception branch is mainly used for locating the foreground objects while the densenet network branch is used to refine the boundaries around the segmented objects. This model was originally trained on multiple datasets.
+
+In our experiment, we attempt to prune channels in both the inception branch and densenet branch. We set $\alpha = 0 . 0 1$ , $\rho = 0 . 5$ , $\bar { \mu _ { t } } = \bar { 2 } \times 1 0 ^ { - 5 }$ , and batch size $= 2 4$ . We train the pre-trained base model until all termination criterion are met, and build the pruned model for fine-tuning. The pruned model saves $86 \%$ parameters and $81 \%$ flops of the base model. We also compare the fine-tuned pruned model with the pre-trained base model across different test benchmark. Mean IOU is used as the evaluation metric.3 It shows that pruned model actually improves over the base model on four of the five test datasets with about $2 \% \sim 5 \%$ , while it performs worse than the base model on the most challenged dataset DUT-Omron, whose foregrounds might contain multiple objects.
+
+Table 4: mIOU reported on different test datasets for the base model and the pruned model.   
+
+<table><tr><td></td><td>base model</td><td>pruned model</td></tr><tr><td>test dataset (#images)</td><td>mIOU</td><td>mIOU</td></tr><tr><td>MSRA10K (Liu et al., 2011) (2,500)</td><td>83.4%</td><td>85.5%</td></tr><tr><td>DUT-Omron (Yang et al., 2013) (1,292)</td><td>83.2%</td><td>79.1%</td></tr><tr><td>Adobe Flickr-portrait (Shen et al., 20i6) (150)</td><td>88.6%</td><td>93.3%</td></tr><tr><td>Adobe Flickr-hp (Shen et al., 2016) (300)</td><td>84.5%</td><td>89.5%</td></tr><tr><td>COCO-person (Lin et al.,2014) (50)</td><td>84.1%</td><td>87.5%</td></tr><tr><td>param.size</td><td>1.02 ×107</td><td>1.41 × 106</td></tr><tr><td>flops</td><td>5.68 ×109</td><td>1.08 × 109</td></tr></table>
+
+# 6 CONCLUSIONS
+
+We proposed a model pruning technique that focuses on simplifying the computation graph of a deep convolutional neural network. Our approach adopts ISTA to update the $\gamma$ parameter in batch normalization operator embedded in each convolution. To accelerate the progress of model pruning, we use a $\gamma { - } W$ rescaling trick before and after stochastic training. Our method cleverly avoids some possible numerical difficulties such as mentioned in other regularization-based related work, hence is easier to apply for practitioners. We empirically validated our method through several benchmarks and showed its usefulness and competitiveness in building compact CNN models.
+
+# REFERENCES
+
+Jose M Alvarez and Mathieu Salzmann. Learning the number of neurons in deep networks. In Advances in Neural Information Processing Systems, pp. 2270–2278, 2016.
+
+Sajid Anwar, Kyuyeon Hwang, and Wonyong Sung. Structured pruning of deep convolutional neural networks. ACM Journal on Emerging Technologies in Computing Systems (JETC), 13(3):32, 2017.
+
+Amir Beck and Marc Teboulle. A fast iterative shrinkage-thresholding algorithm for linear inverse problems. SIAM Journal on Imaging Sciences, 2(1):183–202, 2009.
+
+Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp minima can generalize for deep nets. In Proceedings of International Conference on Machine Learning, 2017.
+
+Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In Advances in Neural Information Processing Systems, pp. 1135–1143, 2015.
+
+Babak Hassibi and David G Stork. Second order derivatives for network pruning: Optimal brain surgeon. In Advances in Neural Information Processing Systems, pp. 164–171, 1993.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 770–778, 2016.
+
+Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of International Conference on Computer Vision, 2017.
+
+Zehao Huang and Naiyan Wang. Data-driven sparse structure selection for deep neural networks. arXiv preprint arXiv:1707.01213, 2017.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015.
+
+Vadim Lebedev and Victor Lempitsky. Fast convnets using group-wise brain damage. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2554–2564, 2016.
+
+Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. In Advances in Neural Information Processing Systems, pp. 598–605, 1990.
+
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. In International Conference on Learning Representations, 2017.
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and ´ C Lawrence Zitnick. Microsoft coco: Common objects in context. In European conference on computer vision, pp. 740–755. Springer, 2014.
+
+Tie Liu, Zejian Yuan, Jian Sun, Jingdong Wang, Nanning Zheng, Xiaoou Tang, and Heung-Yeung Shum. Learning to detect a salient object. IEEE Transactions on Pattern analysis and machine intelligence, 33(2): 353–367, 2011.
+
+Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. arXiv preprint arXiv:1708.06519, 2017.
+
+Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient transfer learning. In International Conference on Learning Representations, 2017.
+
+Xiaoyong Shen, Aaron Hertzmann, Jiaya Jia, Sylvain Paris, Brian Price, Eli Shechtman, and Ian Sachs. Automatic portrait segmentation for image stylization. In Computer Graphics Forum, volume 35, pp. 93–102. Wiley Online Library, 2016.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances in Neural Information Processing Systems, pp. 2074–2082, 2016.
+
+Chuan Yang, Lihe Zhang, Huchuan Lu, Xiang Ruan, and Ming-Hsuan Yang. Saliency detection via graphbased manifold ranking. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3166–3173, 2013.
+
+Xiangyu Zhang, Jianhua Zou, Kaiming He, and Jian Sun. Accelerating very deep convolutional networks for classification and detection. IEEE Transactions on Pattern Analysis and Machine Intelligence, 38(10): 1943–1955, 2016.
+
+Hao Zhou, Jose M Alvarez, and Fatih Porikli. Less is more: Towards compact cnns. In European Conference on Computer Vision, pp. 662–677. Springer, 2016.
+
+![](images/9f3a9db4aa3de8ff16f04d70491a4b364af864f221ad2e7ad9dee6582b55f869.jpg)  
+Figure 1: Visualization of the number of pruned channels at each convolution in the inception branch. Colored regions represents the number of channels kept. The height of each bar represents the size of feature map, and the width of each bar represents the size of channels. It is observed that most of channels in the bottom layers are kept while most of channels in the top layers are pruned.

parse/train/HJ94fqApW/HJ94fqApW_content_list.json

@@ -0,0 +1,1420 @@
+[
+    {
+        "type": "text",
+        "text": "RETHINKING THE SMALLER-NORM-LESSINFORMATIVE ASSUMPTION IN CHANNEL PRUNING OF CONVOLUTION LAYERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jianbo $\\mathbf { Y e ^ { * } }$   \nCollege of Information Sciences and Technology   \nThe Pennsylvania State University   \njxy198@ist.psu.edu   \nXin Lu, Zhe Lin   \nAdobe Research   \n{xinl,zlin}@adobe.com   \nJames Z. Wang   \nCollege of Information Sciences and Technology   \nThe Pennsylvania State University   \njwang@ist.psu.edu ",
+        "bbox": [
+            183,
+            195,
+            504,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            609,
+            195,
+            813,
+            238
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            184,
+            272,
+            504,
+            328
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            364,
+            544,
+            380
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Model pruning has become a useful technique that improves the computational efficiency of deep learning, making it possible to deploy solutions in resourcelimited scenarios. A widely-used practice in relevant work assumes that a smallernorm parameter or feature plays a less informative role at the inference time. In this paper, we propose a channel pruning technique for accelerating the computations of deep convolutional neural networks (CNNs) that does not critically rely on this assumption. Instead, it focuses on direct simplification of the channel-tochannel computation graph of a CNN without the need of performing a computationally difficult and not-always-useful task of making high-dimensional tensors of CNN structured sparse. Our approach takes two stages: first to adopt an end-toend stochastic training method that eventually forces the outputs of some channels to be constant, and then to prune those constant channels from the original neural network by adjusting the biases of their impacting layers such that the resulting compact model can be quickly fine-tuned. Our approach is mathematically appealing from an optimization perspective and easy to reproduce. We experimented our approach through several image learning benchmarks and demonstrate its interesting aspects and competitive performance. ",
+        "bbox": [
+            233,
+            395,
+            764,
+            630
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            655,
+            336,
+            671
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Not all computations in a deep neural network are of equal importance. In a typical deep learning pipeline, an expert crafts a neural architecture, which is trained using a prepared dataset. The success of training a deep model often requires trial and error, and such loop usually has little control on prioritizing the computations happening in the neural network. Recently researchers started to develop model-simplification methods for convolutional neural networks (CNNs), bearing in mind that some computations are indeed non-critical or redundant and hence can be safely removed from a trained model without substantially degrading the model’s performance. Such methods not only accelerate computational efficiency but also possibly alleviate the model’s overfitting effects. ",
+        "bbox": [
+            174,
+            686,
+            823,
+            797
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Discovering which subsets of the computations of a trained CNN are more reasonable to prune, however, is nontrivial. Existing methods can be categorized from either the learning perspective or from the computational perspective. From the learning perspective, some methods use a dataindependent approach where the training data does not assist in determining which part of a trained CNN should be pruned, e.g. He et al. (2017) and Zhang et al. (2016), while others use a datadependent approach through typically a joint optimization in generating pruning decisions, e.g., Han et al. (2015) and Anwar et al. (2017). From the computational perspective, while most approaches focus on setting the dense weights of convolutions or linear maps to be structured sparse, we propose here a method adopting a new conception to achieve in effect the same goal. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Instead of regarding the computations of a CNN as a collection of separate computations sitting at different layers, we view it as a network flow that delivers information from the input to the output through different channels across different layers. We believe saving computations of a CNN is not only about reducing what are calculated in an individual layer, but perhaps more importantly also about understanding how each channel is contributing to the entire information flow in the underlying passing graph as well as removing channels that are less responsible to such process. Inspired by this new conception, we propose to design a “gate” at each channel of a CNN, controlling whether its received information is actually sent out to other channels after processing. If a channel “gate” closes, its output will always be a constant. In fact, each designed “gate” will have a prior intention to close, unless it has a “strong” duty in sending some of its received information from the input to subsequent layers. We find that implementing this idea in pruning CNNs is unsophisticated, as will be detailed in Sec 4. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            304
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our method neither introduces any extra parameters to the existing CNN, nor changes its computation graph. In fact, it only introduces marginal overheads to existing gradient training of CNNs. It also possess an attractive feature that one can successively build multiple compact models with different inference performances in a single round of resource-intensive training (as in our experiments). This eases the process to choose a balanced model to deploy in production. Probably, the only applicability constraint of our method is that all convolutional layers and fully-connected layer (except the last layer) in the CNN should be batch normalized (Ioffe & Szegedy, 2015). Given batch normalization has becomes a widely adopted ingredient in designing state-of-the-art deep learning models, and many successful CNN models are using it, we believe our approach has a wide scope of potential impacts.1 ",
+        "bbox": [
+            174,
+            313,
+            825,
+            450
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we start from rethinking a basic assumption widely explored in existing channel pruning work. We point out several issues and gaps in realizing this assumption successfully. Then, we propose our alternative approach, which works around several numerical difficulties. Finally, we experiment our method across different benchmarks and validate its usefulness and strengths. ",
+        "bbox": [
+            176,
+            458,
+            825,
+            513
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            534,
+            344,
+            549
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Reducing the size of neural network for speeding up its computational performance at inference time has been a long-studied topic in the communities of neural network and deep learning. Pioneer works include Optimal Brain Damage (LeCun et al., 1990) and Optimal Brain Surgeon (Hassibi & Stork, 1993). More recent developments focused on either reducing the structural complexity of a provided network or training a compact or simplified network from scratch. Our work can be categorized into the former, thus the literature review below revolves around reducing the structural complexity. ",
+        "bbox": [
+            174,
+            565,
+            823,
+            662
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To reduce the structural complexity of deep learning models, previous work have largely focused on sparsifying the weights of convolutional kernels or the feature maps across multiple layers in a network (Anwar et al., 2017; Han et al., 2015). Some recent efforts proposed to impose structured sparsity on those vector components motivated from the implementation perspective on specialized hardware (Wen et al., 2016; Zhou et al., 2016; Alvarez & Salzmann, 2016; Lebedev & Lempitsky, 2016). Yet as argued by Molchanov et al. (2017), regularization-based pruning techniques require per layer sensitivity analysis which adds extra computations. Their method relies on global rescaling of criteria for all layers and does not require sensitivity estimation, a beneficial feature that our approach also has. To our knowledge, it is also unclear how widely useful those works are in deep learning. In Section 3, we discuss in details the potential issues in regularization-based pruning techniques potentially hurting them being widely applicable, especially for those that regularize high-dimensional tensor parameters or use magnitude-based pruning methods. Our approach works around the mentioned issues by constraining the anticipated pruning operations only to batchnormalized convolutional layers. Instead of posing structured sparsity on kernels or feature maps, we enforce sparsity on the scaling parameter $\\gamma$ in batch normalization operator. This blocks the sample-wise information passing through part of the channels in convolution layer, and in effect implies one can safely remove those channels. ",
+        "bbox": [
+            174,
+            669,
+            825,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A recent work by Huang & Wang (2017) used a similar technique as ours to remove unimportant residual modules in ResNet by introducing extra scaling factors to the original network. However, some optimization subtleties as to be pointed out in our paper were not well explained. Another recent work called Network-Slimming (Liu et al., 2017) also aims to sparsify the scaling parameters of batch normalization. But instead of using off-the-shelf gradient learning like theirs, we propose a new algorithmic approach based on ISTA and rescaling trick, improving robustness and speed of the undergoing optimization. In particular, the work of Liu et al. (2017) was able to prune VGG-A model on ImageNet. It is unclear how their work would deal with the $\\gamma { - } W$ rescaling effect and whether their approach can be adopted to large pre-trained models, such as ResNets and Inceptions. We experimented with the pre-trained ResNet-101 and compared to most recent work that were shown to work well with large CNNs. We also experimented with an image segmentation model which has an inception-like module (pre-trained on ImageNet) to locate foreground objects. ",
+        "bbox": [
+            173,
+            152,
+            825,
+            319
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 RETHINKING THE SMALLER-NORM-LESS-INFORMATIVE ASSUMPTION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            342,
+            792,
+            358
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In most regularized linear regressions, a large-norm coefficient is often a strong indicator of a highly informative feature. This has been widely perceived in statistics and machine learning communities. Removing features which have a small coefficient does not substantially affect the regression errors. Therefore, it has been an established practice to use tractable norm to regularize the parameters in optimizing a model and pick the important ones by comparing their norms after training. However, this assumption is not unconditional. By using Lasso or ridge regression to select important predictors in linear models, one always has to first normalize each predictor variable. Otherwise, the result might not be explanatory. For example, ridge regression penalizes more the predictors which has low variance, and Lasso regression enforces sparsity of coefficients which are already small in OLS. Such normalization condition for the right use of regularization is often unsatisfied for nonconvex learning. For example, one has to carefully consider two issues outlined below. We provides these two cases to exemplify how regularization could fail or be of limited usage. There definitely exist ways to avoid the described failures. ",
+        "bbox": [
+            174,
+            396,
+            825,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Model Reparameterization. In the first case, we show that it is not easy to have fine-grained control of the weights’ norms across different layers. One has to either choose a uniform penalty in all layers or struggle with the reparameterization patterns. Consider to find a deep linear (convolutional) network subject to a least square with Lasso: for $\\lambda > 0$ , ",
+        "bbox": [
+            174,
+            583,
+            825,
+            640
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf30da62cdb89ba519d29c3fcb896212767f0cdb49bcd00f8b7721e8d224ac03.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\{ W _ { i } \\} _ { i = 1 } ^ { 2 n } } \\mathbb { E } _ { ( x , y ) \\sim \\mathcal { D } } \\| W _ { 2 n } \\ast \\ldots \\ast W _ { 2 } \\ast W _ { 1 } \\ast x - y \\| ^ { 2 } + \\lambda \\sum _ { i = 1 } ^ { n } \\| W _ { 2 i } \\| _ { 1 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            648,
+            727,
+            690
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The above formulation is not a well-defined problem because for any parameter set 0 2n $\\{ W _ { i } \\} _ { i = 1 } ^ { 2 n }$ , one i=1can always find another parameter set {W i } i=1 such that it achieves a smaller total loss while keeping the corresponding $l _ { 0 }$ norm unchanged by actually setting ",
+        "bbox": [
+            174,
+            699,
+            826,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/edccdb4b51faeb29b762938674a7a46e2656b743fa4f7c12d42ca5cbefd52b70.jpg",
+        "text": "$$\nW _ { i } ^ { \\prime } = \\alpha W _ { i } , i = 1 , 3 , \\ldots , 2 n - 1 \\mathrm { ~ a n d ~ } W _ { i } ^ { \\prime } = W _ { i } / \\alpha , i = 2 , 4 , \\ldots , 2 n .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            751,
+            722,
+            768
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha > 1$ . In another word, for any $\\epsilon > 0$ , one can always find a parameter set $\\{ W _ { i } \\} _ { i = 1 } ^ { 2 n }$ (which is usually non-sparse) that minimizes the first least square loss while having its second Lasso term less than $\\epsilon$ . ",
+        "bbox": [
+            176,
+            776,
+            821,
+            819
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We note that gradient-based learning is highly inefficient in exploring such model reparameterization patterns. In fact, there are some recent discussions around this (Dinh et al., 2017). If one adopts a pre-trained model, and augments its original objective with a new norm-based parameter regularization, the new gradient updates may just increase rapidly or it may take a very long time for the variables traveling along the model’s reparameterization trajectory. This highlights a theoretical gap questioning existing sparsity-inducing formulation and actual computational algorithms whether they can achieve widely satisfactory parameter sparsification for deep learning models. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Transform Invariance. In the second case, we show that batch normalization is not compatible with weight regularization. The example is penalizing $l _ { 1 }$ - or $l _ { 2 }$ -norms of filters in convolution layer which is then followed by a batch normalization: at the $l$ -th layer, we let ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f53c08fd75fbd021d87ab05ba66d28e527216c2897f6239b2dda995f6a326941.jpg",
+        "text": "$$\nx ^ { l + 1 } = \\operatorname* { m a x } \\{ \\gamma \\cdot \\mathbf { B N } _ { \\mu , \\sigma , \\epsilon } ( W ^ { l } * x ^ { l } ) + \\beta , 0 \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            150,
+            642,
+            169
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\gamma$ and $\\beta$ are vectors whose length is the number of channels. Likewise, one can clearly see that any uniform scaling of $W ^ { l }$ which changes its $l _ { 1 }$ - and $l _ { 2 }$ -norms would have no effects on the output $x ^ { l + 1 }$ . Alternatively speaking, if one is interested in minimizing the weight norms of multiple layers together, it becomes unclear how to choose proper penalty for each layer. Theoretically, there always exists an optimizer that can change the weight to one with infinitesimal magnitude without hurting any inference performance. As pointed by one of the reviewers, one can tentatively avoid this issue by projecting the weights to the surface of unit ball. Then one has to deal with a non-convex feasible set of parameters, causing extra difficulties in developing optimization for data-dependent pruning methods. It is also worth noting that some existing work used such strategy in a layer-by-layer greedy way (He et al., 2017; Zhang et al., 2016). ",
+        "bbox": [
+            173,
+            171,
+            825,
+            313
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Based on this discussion, many existing works which claim to use Lasso, group Lasso (e.g. Wen et al. (2016); Anwar et al. (2017)), or thresholding (e.g. Molchanov et al. (2017)) to enforce parameter sparsity have some theoretical gaps to bridge. In fact, many heuristic algorithms in neural net pruning actually do not naturally generate a sparse parameterized solution. More often, thresholding is used to directly set certain subset of the parameters in the network to zeros, which can be problematic. The reason is in essence around two questions. First, by setting parameters less than a threshold to zeros, will the functionality of neural net be preserved approximately with certain guarantees? If yes, then under what conditions? Second, how should one set those thresholds for weights across different layers? Not every layer contributes equally in a neural net. It is expected that some layers act critically for the performance but only use a small computation and memory budget, while some other layers help marginally for the performance but consume a lot resources. It is naturally more desirable to prune calculations in the latter kind of layers than the former. ",
+        "bbox": [
+            173,
+            332,
+            825,
+            498
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In contrast with these existing approaches, we focus on enforcing sparsity of a tiny set of parameters in CNN — scale parameter $\\gamma \\mathbf { s }$ in all batch normalization. Not only placing sparse constraints on $\\gamma$ is simpler and easier to monitor, but more importantly, we have two strong reasons: ",
+        "bbox": [
+            176,
+            506,
+            825,
+            547
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Every $\\gamma$ always multiplies a normalized random variable, thus the channel importance becomes comparable across different layers by measuring the magnitude values of $\\gamma$ ;   \n2. The reparameterization effect across different layers is avoided if its subsequent convolution layer is also batch-normalized. In other words, the impacts from the scale changes of $\\gamma$ parameter are independent across different layers. ",
+        "bbox": [
+            209,
+            559,
+            825,
+            633
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Nevertheless, our current work still falls short of a strong theoretical guarantee. We believe by working with normalized feature inputs and their regularized coefficients together, one is closer to a more robust and meaningful approach. Sparsity is not the goal, but to find less important channels using sparsity inducing formulation is. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            700
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 CHANNEL PRUNING OF BATCH-NORMALIZED CNN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            719,
+            635,
+            736
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We describe the basic principle and algorithm of our channel pruning technique. ",
+        "bbox": [
+            178,
+            750,
+            702,
+            765
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            781,
+            326,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Pruning constant channels. Consider convolution with batch normalization: ",
+        "bbox": [
+            174,
+            806,
+            679,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/04cd4e188c2b2a468913f8d8d7c758dbc9dc8120ce40d4ffd5370c5f931641d4.jpg",
+        "text": "$$\nx ^ { l + 1 } = \\operatorname* { m a x } \\left\\{ \\gamma ^ { l } \\cdot { \\mathrm { B N } } _ { \\mu ^ { l } , \\sigma ^ { l } , \\epsilon ^ { l } } ( W ^ { l } * x ^ { l } ) + \\beta ^ { l } , 0 \\right\\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            825,
+            661,
+            845
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For the ease of notation, we let $\\gamma = \\gamma ^ { l }$ . Note that if some element in $\\gamma$ is set to zero, say, $\\gamma [ k ] = 0$ , its output image xl+1:,:,:,k becomes a constant $\\beta _ { k }$ , and a convolution of a constant image channel is almost everywhere constant (except for padding regions, an issue to be discussed later). Therefore, we show those constant image channels can be pruned while the same functionality of network is approximately kept: ",
+        "bbox": [
+            173,
+            849,
+            826,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• If the subsequent convolution layer does not have batch normalization, ",
+        "bbox": [
+            215,
+            103,
+            694,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f5a564cd4fa6d6470f54d98e3f1dc3060d950f36ae8bcfd9a5e6319907171190.jpg",
+        "text": "$$\nx ^ { l + 2 } = \\operatorname* { m a x } \\left\\{ W ^ { l + 1 } * x ^ { l + 1 } + b ^ { l + 1 } , 0 \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            125,
+            660,
+            145
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "its values (a.k.a. elements in $\\beta$ ) is absorbed into the bias term by the following equation ",
+        "bbox": [
+            228,
+            151,
+            807,
+            166
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/915b8d91157731cabfaa9c6af2a0a7ee15158a6389df0c40793d434c8b19ea42.jpg",
+        "text": "$$\nb _ { n e w } ^ { l + 1 } : = b ^ { l + 1 } + I ( \\gamma = 0 ) \\cdot \\mathrm { R e L U } ( \\beta ) ^ { T } \\mathrm { s u m . r e d u c e d } ( W _ { : , : , \\cdot } ^ { l + 1 } , ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            172,
+            728,
+            193
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "such that ",
+        "bbox": [
+            232,
+            200,
+            294,
+            214
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d55e4ff3522e0acb485326fa4ca8471b3097e3a56cae265aec20d6ce0ef3fec2.jpg",
+        "text": "$$\nx ^ { l + 2 } \\approx \\mathrm { m a x } \\left\\{ W ^ { l + 1 } * _ { \\gamma } x ^ { l + 1 } + b _ { n e w } ^ { l + 1 } , 0 \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            212,
+            665,
+            232
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\ast _ { \\gamma }$ denotes the convolution operator which is only calculated along channels indexed by non-zeros of $\\gamma$ . Remark that $W ^ { * } =$ sum reduced $( W _ { : , : , \\cdot , \\cdot } )$ if $\\begin{array} { r } { W _ { a , b } ^ { * } = \\sum _ { i , j } W _ { i , j , a , b } } \\end{array}$ . ",
+        "bbox": [
+            227,
+            234,
+            830,
+            265
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• If the subsequent convolution layer has batch normalization, ",
+        "bbox": [
+            215,
+            270,
+            629,
+            285
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/88c84686a44ed4ed7a402dce20168d7e84c75d2103d2a1536ed3d666ac0f11a1.jpg",
+        "text": "$$\nx ^ { l + 2 } = \\operatorname * { m a x } \\left\\{ \\gamma ^ { l + 1 } \\cdot { \\bf B } { \\bf N } _ { \\mu ^ { l + 1 } , \\sigma ^ { l + 1 } , \\epsilon ^ { l + 1 } } \\left( W ^ { l + 1 } * x ^ { l + 1 } \\right) + \\beta ^ { l + 1 } , 0 \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            291,
+            746,
+            313
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "instead its moving average is updated as ",
+        "bbox": [
+            233,
+            318,
+            496,
+            333
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9410b152139107ff70cc13dbbd4987f8ce7115de3c492267b4a84f3794caef60.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mu _ { n e w } ^ { l + 1 } : = \\mu ^ { l + 1 } - I ( \\gamma = 0 ) \\cdot \\mathrm { R e L U } ( \\beta ) ^ { T } \\mathrm { s u m . r e d u c e d } ( W _ { : , : , \\cdot , \\cdot } ^ { l + 1 } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            339,
+            732,
+            359
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "such that ",
+        "bbox": [
+            232,
+            367,
+            294,
+            381
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8cc15bc9f894cff7fe3bf7f96c131969395948811a23c1bf90dbe7b3217343a8.jpg",
+        "text": "$$\nx ^ { l + 2 } \\approx \\operatorname * { m a x } \\left\\{ \\gamma ^ { l + 1 } \\cdot { \\bf B N } _ { \\mu _ { n e w } ^ { l + 1 } , \\sigma ^ { l + 1 } , \\epsilon ^ { l + 1 } } \\left( W ^ { l + 1 } * _ { \\gamma } x ^ { l + 1 } \\right) + \\beta ^ { l + 1 } , 0 \\right\\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            385,
+            756,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Remark that the approximation $( \\approx )$ is strictly equivalence $( = )$ if no padding is used in the convolution operator $^ *$ , a feature that the parallel work Liu et al. (2017) does not possess. When the original model uses padding in computing convolution layers, the network function is not strictly preserved after pruning. In our practice, we fine-tune the pruned network to fix such performance degradation at last. In short, we formulate the network pruning problem as simple as to set more elements in $\\gamma$ to zero. It is also much easier to deploy the pruned model, because no extra parameters or layers are introduced into the original model. ",
+        "bbox": [
+            173,
+            421,
+            825,
+            520
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To better understand how it works in an entire CNN, imagine a channel-to-channel computation graph formed by the connections between layers. In this graph, each channel is a node, their inference dependencies are represented by directed edges. The $\\gamma$ parameter serves as a “dam” at each node, deciding whether let the received information “flood” through to other nodes following the graph. An end-to-end training of channel pruning is essentially like a flood control system. There suppose to be rich information of the input distribution, and in two ways, much of the original input information is lost along the way of CNN inference, and the useful part — that is supposed to be preserved by the network inference — should be label sensitive. Conventional CNN has one way to reduce information: transforming feature maps (non-invertible) via forward propagation. Our approach introduces the other way: block information at each channel by forcing its output being constant using ISTA. ",
+        "bbox": [
+            173,
+            526,
+            825,
+            680
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ISTA. Despite the gap between Lasso and sparsity in the non-convex settings, we found that ISTA (Beck & Teboulle, 2009) is still a useful sparse promoting method. But we just need to use it more carefully. Specifically, we adopt ISTA in the updates of $\\gamma \\mathbf { s }$ . The basic idea is to project the parameter at every step of gradient descent to a potentially more sparse one subject to a proxy problem: let $l$ denote the training loss of interest, at the $( t + 1 )$ -th step, we set ",
+        "bbox": [
+            173,
+            686,
+            825,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0e4d279519aff3d42f03d66cc9b2a4e960d39757bb0bb28d16f04fba7ff05898.jpg",
+        "text": "$$\n\\gamma _ { t + 1 } = \\operatorname* { m i n } _ { \\gamma } \\frac { 1 } { \\mu _ { t } } \\| \\gamma - \\gamma _ { t } + \\mu _ { t } \\nabla _ { \\gamma } l _ { t } \\| ^ { 2 } + \\lambda \\| \\gamma \\| _ { 1 } \\mathrm { ~ , ~ }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            763,
+            655,
+            797
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\nabla _ { \\gamma } l _ { t }$ is the derivative with respect to $\\gamma$ computed at step $t$ , $\\mu _ { t }$ is the learning rate, $\\lambda$ is the penalty. In the stochastic learning, $\\nabla _ { \\gamma } l _ { t }$ is estimated from a mini-batch at each step. Eq. (1) has closed form solution as ",
+        "bbox": [
+            178,
+            803,
+            823,
+            844
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b138ecb397d910602cf20d6d1147498ed67ff598299506a8641b1a8cb4e47249.jpg",
+        "text": "$$\n\\gamma _ { t + 1 } = \\mathrm { p r o x } _ { \\mu _ { t } \\lambda } \\bigl ( \\gamma _ { t } - \\mu _ { t } \\nabla _ { \\gamma } l _ { t } \\bigr ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            844,
+            602,
+            863
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { p r o x } _ { \\eta } ( x ) = \\operatorname* { m a x } \\{ | x | - \\eta , 0 \\} \\cdot \\mathrm { s g n } ( x )$ . The ISTA method essentially serves as a “flood control system” in our end-to-end learning, where the functionality of each $\\gamma$ is like that of a dam. When $\\gamma$ is zero, the information flood is totally blocked, while $\\gamma \\neq 0$ , the same amount of information is passed through in form of geometric quantities whose magnitudes are proportional to $\\gamma$ . ",
+        "bbox": [
+            173,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Scaling effect. One can also see that if $\\gamma$ is scaled by $\\alpha$ meanwhile $W ^ { l + 1 }$ is scaled by $1 / \\alpha$ , that is, ",
+        "bbox": [
+            171,
+            102,
+            820,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fb54dec906e9f3a1cc3b751ec4e5015c187b229de7c4c9f0a381c60b010f7b7c.jpg",
+        "text": "$$\n\\gamma : = \\alpha \\gamma , \\qquad W ^ { l + 1 } : = \\frac { 1 } { \\alpha } W ^ { l + 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            125,
+            607,
+            156
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "the output $x ^ { l + 2 }$ is unchanged for the same input $x ^ { l }$ . Despite not changing the output, scaling of $\\gamma$ and $W ^ { l + 1 }$ also scales the gradients $\\nabla _ { \\gamma } l$ and $\\nabla _ { W ^ { l + 1 } } l$ by $1 / \\alpha$ and $\\alpha$ , respectively. As we observed, the parameter dynamics of gradient learning with ISTA depends on the scaling factor $\\alpha$ if one decides to choose it other than 1.0. Intuitively, if $\\alpha$ is large, the optimization of $\\bar { W } ^ { l + 1 }$ is progressed much slower than that of $\\gamma$ . ",
+        "bbox": [
+            173,
+            161,
+            825,
+            233
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 THE ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            250,
+            338,
+            265
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We describe our algorithm below. The following method applies to both training from scratch or re-training from a pre-trained model. Given a training loss $l$ , a convolutional neural net $\\mathcal { N }$ , and hyper-parameters $\\rho , \\alpha , \\mu _ { 0 }$ , our method proceeds as follows: ",
+        "bbox": [
+            174,
+            275,
+            826,
+            318
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. Computation of sparse penalty for each layer. Compute the memory cost per channel for each layer denoted by $\\setminus { l }$ and set the ISTA penalty for layer $l$ to $\\rho \\lambda ^ { l }$ . Here ",
+        "bbox": [
+            210,
+            329,
+            825,
+            359
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/85518fbda20b1ccf80894f0b498ae48a3fbd71b02e5a97c01e4f01c3ad5b0e3c.jpg",
+        "text": "$$\n\\lambda ^ { l } = \\frac { 1 } { I _ { w } ^ { i } \\cdot I _ { h } ^ { i } } \\left[ k _ { w } ^ { l } \\cdot k _ { h } ^ { l } \\cdot c ^ { l - 1 } + \\sum _ { l ^ { \\prime } \\in \\mathcal { T } ( l ) } k _ { w } ^ { l ^ { \\prime } } \\cdot k _ { h } ^ { l ^ { \\prime } } \\cdot c ^ { l ^ { \\prime } } + I _ { w } ^ { l } \\cdot I _ { h } ^ { l } \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            364,
+            736,
+            415
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where ",
+        "bbox": [
+            232,
+            421,
+            274,
+            434
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• $I _ { w } ^ { i } \\cdot I _ { h } ^ { i }$ is the size of input image of the neural network.   \n• $k _ { w } ^ { l } \\cdot k _ { h } ^ { l }$ is the kernel size of the convolution at layer $l$ . Likewise, $k _ { w } ^ { l ^ { \\prime } } \\cdot k _ { h } ^ { l ^ { \\prime } }$ is the kernel size of subsequent convolution at layer $l ^ { \\prime }$ .   \n• $\\tau ( l )$ represents the set of the subsequent convolutional layers of layer $l$   \n• $c ^ { l - 1 }$ denotes the channel size of the previous layer, which the $l$ -th convolution operates over; and $c ^ { l ^ { \\prime } }$ denotes the channel size of one subsequent layer $l ^ { \\prime }$ .   \n• $I _ { w } ^ { l } \\cdot I _ { h } ^ { l }$ is the image size of the feature map at layer $l$ . ",
+        "bbox": [
+            246,
+            439,
+            825,
+            554
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2. $\\gamma { = } W$ rescaling trick. For layers whose channels are going to get reduced, scale all $\\gamma ^ { l } \\mathbf { s }$ i n batch normalizations by $\\alpha$ meanwhile scale weights in their subsequent convolutions by $1 / \\alpha$ . ",
+        "bbox": [
+            214,
+            558,
+            825,
+            599
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3. End-to-End training with ISTA on $\\gamma$ . Train $\\mathcal { N }$ by the regular SGD, with the exception that $\\gamma ^ { l } \\mathbf { s }$ are updated by ISTA, where the initial learning rate is $\\mu _ { 0 }$ . Train $\\mathcal { N }$ until the loss $l$ plateaus, the total sparsity of $\\gamma ^ { l } \\mathbf { s }$ converges, and Lasso $\\textstyle { \\dot { \\rho } } \\sum _ { l } \\lambda ^ { l } \\| \\gamma ^ { l } \\| _ { 1 }$ converges.   \n4. Post-process to remove constant channels. Prune channels in layer $l$ whose elements in $\\gamma ^ { l }$ are zero and output the pruned model $\\widetilde { \\mathcal { N } }$ by absorbing all constant channels into subsequent layers (as described in the earlier section.).   \n5. $\\gamma { = } W$ rescaling trick. For $\\gamma ^ { l } \\mathbf { s }$ and weights in $\\widetilde { \\mathcal { N } }$ which were scaled in Step 2 before training, scale them by $1 / \\alpha$ and $\\alpha$ respectively (scaling back).   \n6. Fine-tune $\\widetilde { \\mathcal { N } }$ using regular stochastic gradient learning. ",
+        "bbox": [
+            207,
+            604,
+            825,
+            753
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Remark that choosing a proper $\\alpha$ as used in Steps 2 and 5 is necessary for using a large $\\mu _ { t } \\cdot \\rho$ in ISTA, which makes the sparsification progress of $\\gamma ^ { l } \\mathbf { s }$ faster. ",
+        "bbox": [
+            173,
+            765,
+            823,
+            794
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 GUIDELINES FOR TUNING HYPER-PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            809,
+            549,
+            825
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We summarize the sensitivity of hyper-parameters and their impacts for optimization below: ",
+        "bbox": [
+            171,
+            835,
+            777,
+            852
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• $\\mu$ (learning rate): larger $\\mu$ leads to fewer iterations for convergence and faster progress of sparsity. But if if $\\mu$ too large, the SGD approach wouldn’t converge. • $\\rho$ (sparse penalty): larger $\\rho$ leads to more sparse model at convergence. If trained with a very large $\\rho$ , all channels will be eventually pruned. ",
+        "bbox": [
+            215,
+            862,
+            826,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• $\\alpha$ (rescaling): we use $\\alpha$ other than 1. only for pretrained models, we typically choose $\\alpha$ from $\\{ 0 . 0 0 1 , 0 . 0 1 , 0 . 1 , 1 \\}$ and smaller $\\alpha$ warms up the progress of sparsity. ",
+        "bbox": [
+            210,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We recommend the following parameter tuning strategy. First, check the cross-entropy loss and the regularization loss, select $\\rho$ such that these two quantities are comparable at the beginning. Second, choose a reasonable learning rate. Third, if the model is pretrained, check the average magnitude of $\\gamma \\mathbf { s }$ in the network, choose $\\alpha$ such that the magnitude of rescaled $\\gamma ^ { l }$ is around $1 0 0 \\bar { \\mu } \\lambda ^ { l } \\rho$ . We found as long as one choose those parameters in the right range of magnitudes, the optimization progress is enough robust. Again one can monitor the mentioned three quantities during the training and terminate the iterations when all three quantities plateaus. ",
+        "bbox": [
+            174,
+            148,
+            825,
+            246
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "There are several patterns we found during experiments that may suggest the parameter tuning has not been successful. If during the first few epochs the Lasso-based regularization loss keeps decreasing linearly while the sparsity of $\\gamma \\mathbf { s }$ stays near zero, one may decrease $\\alpha$ and restart. If during the first few epochs the sparsity of $\\gamma \\mathbf { s }$ quickly raise up to $100 \\%$ , one may decrease $\\rho$ and restart. If during the first few epochs the cross-entropy loss keeps at or increases dramatically to a non-informative level, one may decrease $\\mu$ or $\\rho$ and restart. ",
+        "bbox": [
+            174,
+            253,
+            825,
+            337
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            367,
+            326,
+            383
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 CIFAR-10 EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            405,
+            385,
+            420
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We experiment with the standard image classification benchmark CIFAR-10 with two different network architectures: ConvNet and ResNet-20 (He et al., 2016). We resize images to $3 2 \\times 3 2$ and zero-pad them to $4 0 \\times 4 0$ . We pre-process the padded images by randomly cropping with size $3 2 \\times 3 2$ , randomly flipping, randomly adjusting brightness and contrast, and standardizing them such that their pixel values have zero mean and one variance. ",
+        "bbox": [
+            174,
+            435,
+            823,
+            506
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ConvNet For reducing the channels in ConvNet, we are interested in studying whether one can easily convert a over-parameterized network into a compact one. We start with a standard 4-layer convolutional neural network whose network attributes are specified in Table 1. We use a fixed learning rate $\\mu _ { t } = 0 . 0 1$ , scaling parameter $\\alpha = 1 . 0$ , and set batch size to 125. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            569
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Model A is trained from scratch using the base model with an initial warm-up $\\rho ~ = ~ 0 . 0 0 0 2$ for $3 0 \\mathrm { k }$ steps, and then is trained by raising up $\\rho$ to 0.001. After the termination criterion are met, we prune the channels of the base model to generate a smaller network called model A. We evaluate the classification performance of model A with the running exponential average of its parameters. It is found that the test accuracy of model A is even better than the base model. Next, we start from the pre-trained model A to create model B by raising $\\rho$ up to 0.002. We end up with a smaller network called model B, which is about $1 \\%$ worse than model A, but saves about one third parameters. Likewise, we start from the pre-trained model B to create model C. The detailed statistics and its pruned channel size are reported in Table 1. We also train a reference ConvNet from scratch whose channel sizes are 32-64-64-128 with totally 224,008 parameters and test accuracy being $8 6 . 3 \\%$ . The referenced model is not as good as Model B, which has smaller number of parameters and higher accuracy. ",
+        "bbox": [
+            173,
+            575,
+            825,
+            742
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We have two major observations from the experiment: (1) When the base network is overparameterized, our approach not only significantly reduces the number of channels of the base model but also improves its generalization performance on the test set. (2) Performance degradation seems unavoidable when the channels in a network are saturated, and our approach gives satisfactory tradeoff between test accuracy and model efficiency. ",
+        "bbox": [
+            174,
+            750,
+            823,
+            819
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ResNet-20 We also want to verify our second observation with the state-of-art models. We choose the popular ResNet-20 as our base model for the CIFAR-10 benchmark, whose test accuracy is $92 \\%$ . We focus on pruning the channels in the residual modules in ResNet-20, which has 9 convolutions in total. As detailed in Table 2, model A is trained from scratch using ResNet-20’s network structure as its base model. We use a warm-up $\\rho = 0 . 0 0 1$ for 30k steps and then train with $\\rho = 0 . 0 0 5$ . We are able to remove $37 \\%$ parameters from ResNet-20 with only about 1 percent accuracy loss. Likewise, Model B is created from model A with a higher penalty $\\rho = 0 . 0 1$ . ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/f1e0367b2f0a0772bf7f247d330f7d1c5652a736c65e6ae69069248b0d96851a.jpg",
+        "table_caption": [
+            "Table 1: Comparisons between different pruned networks and the base network. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"4\">base</td><td>model A</td><td>model B</td><td></td><td>model C</td></tr><tr><td>layer</td><td>output</td><td>kernel</td><td>channel</td><td>channel</td><td>channel</td><td></td><td>channel</td></tr><tr><td>conv1</td><td>32 × 32</td><td>5×5</td><td>96</td><td>53</td><td>41</td><td></td><td>31</td></tr><tr><td>pool1</td><td>16 ×16</td><td>3×3</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>conv2</td><td>16 ×16</td><td>5×5</td><td>192</td><td>86</td><td></td><td>64</td><td>52</td></tr><tr><td>pool2</td><td>8×8</td><td>3×3</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>conv3</td><td>8×8</td><td>3×3</td><td>192</td><td>67</td><td></td><td>52</td><td>40</td></tr><tr><td>pool4</td><td>4×4</td><td>3×3</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>fc</td><td>1×1</td><td>4×4</td><td>384</td><td>128</td><td>128</td><td></td><td>127</td></tr><tr><td>p</td><td></td><td></td><td></td><td></td><td>0.001</td><td>0.002</td><td>0.008</td></tr><tr><td>param. size</td><td></td><td></td><td>1,986,760</td><td>309,655</td><td></td><td>207,583</td><td>144,935</td></tr><tr><td>test accuracy (%)</td><td></td><td></td><td>89.0</td><td>89.5</td><td></td><td>87.6</td><td>86.0</td></tr></table>",
+        "bbox": [
+            209,
+            99,
+            789,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/07bbb71955dc12103c785f6a9e6b44fd36a51f504c3fcad97e7b762b3acc32ec.jpg",
+        "table_caption": [
+            "Table 2: Comparisons between ResNet-20 and its two pruned versions. The last columns are the number of channels of each residual modules after pruning. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>group - block</td><td>1-1</td><td>1-2</td><td>1-3</td><td>2-1</td><td>2-2</td><td>2-3</td><td>3-1</td><td>3-2</td><td>3-3</td></tr><tr><td>ResNet-20</td><td>channels param size.= 281,304 test accuracy (%) = 92.0</td><td>16</td><td>16</td><td>16</td><td>32</td><td>32</td><td>32</td><td>64</td><td>64</td><td>64</td></tr><tr><td>model A</td><td>channels param size. = 176,596 test accuracy (%) = 90.9</td><td>12</td><td>6</td><td>11</td><td>32</td><td>28</td><td>28</td><td>47</td><td></td><td>3425</td></tr><tr><td>model B</td><td>channels param size.= 90,504 test accuracy (%) = 88.8</td><td>8</td><td>2</td><td>今</td><td></td><td>271816</td><td></td><td>25</td><td>9</td><td>8</td></tr></table>",
+        "bbox": [
+            178,
+            313,
+            821,
+            472
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 ILSVRC2012 EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            539,
+            410,
+            553
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We experiment our approach with the pre-trained ResNet-101 on ILSVRC2012 image classification dataset (He et al., 2016). ResNet-101 is one of the state-of-the-art network architecture in ImageNet Challenge. We follow the standard pipeline to pre-process images to $2 2 4 \\times 2 2 4$ for training ResNets. We adopt the pre-trained TensorFlow ResNet-101 model whose single crop error rate is $2 3 . 6 \\%$ with about $4 . 4 7 \\times 1 0 ^ { 7 }$ parameters.2 We set the scaling parameter $\\alpha = 0 . 0 1$ , the initial learning rate $\\mu _ { t } = 0 . 0 0 1$ , the sparsity penalty $\\rho = 0 . 1$ , and the batch $\\mathrm { s i z e } = 1 2 8$ (across 4 GPUs). The learning rate is decayed every four epochs with rate 0.86. We create two pruned models from the different iterations of training ResNet-101: one has $2 . 3 6 \\times 1 0 ^ { 7 }$ parameters and the other has $1 . 7 3 \\times 1 0 ^ { 7 }$ parameters. We then fine-tune these two models using the standard way for training ResNet-101, and report their error rates. The Top-5 error rate increases of both models are less than $0 . 5 \\%$ . The Top-1 error rates are summarized in Table 3. To our knowledge, only a few works have reported their performance on this very large-scale benchmark w.r.t. the Top-1 errors. We compare our approach with some recent works in terms of model parameter size, flops, and error rates. As shown in Table 3, our model v2 has achieved a compression ratio more than 2.5 while maintaining more than $1 \\%$ lower error rates than that of other state-of-the-art models at comparable size of parameters. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            775
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the first experiment (CIFAR-10), we train the network from scratch and allocate enough steps for both $\\gamma$ and $W$ adjusting their own scales. Thus, initialization of an improper scale of $\\gamma { - } W$ is not really an issue given we optimize with enough steps. But for the pre-trained models which were originally optimized without any constraints of $\\gamma$ , the $\\gamma \\mathbf { s }$ scales are often unanticipated. It actually takes as many steps as that of training from scratch for $\\gamma$ to warm up. By adopting the rescaling trick setting $\\alpha$ to a smaller value, we are able to skip the warm-up stage and quick start to sparsify $\\gamma \\mathbf { s }$ . For example, it might take more than a hundred epoch to train ResNet-101, but it only takes about 5-10 epochs to complete the pruning and a few more epochs to fine-tune. ",
+        "bbox": [
+            174,
+            781,
+            825,
+            893
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/5756b34fa6a8bbcb9ed80ffbd4b2c109b174d18d814e8b564f8f4576b4cd7af3.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>network</td><td>param size.</td><td>fops</td><td>error (%)</td><td>ratio</td></tr><tr><td>resnet-50 pruned (Huang &amp; Wang,2017)</td><td>~1.65×107</td><td>3.03×109</td><td>~26.8</td><td>66%</td></tr><tr><td>resnet-101 pruned (v2,ours)</td><td>1.73 ×107</td><td>3.69×109</td><td>25.44</td><td>39%</td></tr><tr><td>resnet-34 pruned (Li et al., 2017)</td><td>1.93 ×107</td><td>2.76 ×109</td><td>27.8</td><td>89%</td></tr><tr><td>resnet-34</td><td>2.16 ×107</td><td>3.64×109</td><td>26.8</td><td>1</td></tr><tr><td>resnet-101 pruned (v1, ours)</td><td>2.36×107</td><td>4.47 ×109</td><td>24.73</td><td>53%</td></tr><tr><td>resnet-50</td><td>2.5×107</td><td>4.08 ×109</td><td>24.8</td><td>1</td></tr><tr><td>resnet-101</td><td>4.47 × 107</td><td>7.8×109</td><td>23.6</td><td>1</td></tr></table>",
+        "bbox": [
+            187,
+            99,
+            812,
+            218
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Attributes of different versions of ResNet and their single crop errors on ILSVRC2012 benchmark. The last column means the parameter size of pruned model vs. the base model. ",
+        "bbox": [
+            173,
+            229,
+            823,
+            258
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 IMAGE FOREGROUND-BACKGROUND SEGMENTATION EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            285,
+            681,
+            300
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As we have discussed about the two major observations in Section 5.1, a more appealing scenario is to apply our approach in pruning channels of over-parameterized model. It often happens when one adopts a pre-trained network on a large task (such as ImageNet classification) and fine-tunes the model to a different and smaller task (Molchanov et al., 2017). In this case, one might expect that some channels that have been useful in the first pre-training task are not quite contributing to the outputs of the second task. ",
+        "bbox": [
+            174,
+            313,
+            825,
+            396
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We describe an image segmentation experiment whose neural network model is composed from an inception-like network branch and a densenet network branch. The entire network takes a $2 2 4 \\times 2 2 4$ image and outputs binary mask at the same size. The inception branch is mainly used for locating the foreground objects while the densenet network branch is used to refine the boundaries around the segmented objects. This model was originally trained on multiple datasets. ",
+        "bbox": [
+            174,
+            404,
+            825,
+            473
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In our experiment, we attempt to prune channels in both the inception branch and densenet branch. We set $\\alpha = 0 . 0 1$ , $\\rho = 0 . 5$ , $\\bar { \\mu _ { t } } = \\bar { 2 } \\times 1 0 ^ { - 5 }$ , and batch size $= 2 4$ . We train the pre-trained base model until all termination criterion are met, and build the pruned model for fine-tuning. The pruned model saves $86 \\%$ parameters and $81 \\%$ flops of the base model. We also compare the fine-tuned pruned model with the pre-trained base model across different test benchmark. Mean IOU is used as the evaluation metric.3 It shows that pruned model actually improves over the base model on four of the five test datasets with about $2 \\% \\sim 5 \\%$ , while it performs worse than the base model on the most challenged dataset DUT-Omron, whose foregrounds might contain multiple objects. ",
+        "bbox": [
+            173,
+            479,
+            825,
+            592
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/522950d06e5cd191f0a42b634c068d78dfd6613b48b57a9232a2fedb649036b5.jpg",
+        "table_caption": [
+            "Table 4: mIOU reported on different test datasets for the base model and the pruned model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>base model</td><td>pruned model</td></tr><tr><td>test dataset (#images)</td><td>mIOU</td><td>mIOU</td></tr><tr><td>MSRA10K (Liu et al., 2011) (2,500)</td><td>83.4%</td><td>85.5%</td></tr><tr><td>DUT-Omron (Yang et al., 2013) (1,292)</td><td>83.2%</td><td>79.1%</td></tr><tr><td>Adobe Flickr-portrait (Shen et al., 20i6) (150)</td><td>88.6%</td><td>93.3%</td></tr><tr><td>Adobe Flickr-hp (Shen et al., 2016) (300)</td><td>84.5%</td><td>89.5%</td></tr><tr><td>COCO-person (Lin et al.,2014) (50)</td><td>84.1%</td><td>87.5%</td></tr><tr><td>param.size</td><td>1.02 ×107</td><td>1.41 × 106</td></tr><tr><td>flops</td><td>5.68 ×109</td><td>1.08 × 109</td></tr></table>",
+        "bbox": [
+            233,
+            606,
+            764,
+            736
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            792,
+            328,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We proposed a model pruning technique that focuses on simplifying the computation graph of a deep convolutional neural network. Our approach adopts ISTA to update the $\\gamma$ parameter in batch normalization operator embedded in each convolution. To accelerate the progress of model pruning, we use a $\\gamma { - } W$ rescaling trick before and after stochastic training. Our method cleverly avoids some possible numerical difficulties such as mentioned in other regularization-based related work, hence is easier to apply for practitioners. We empirically validated our method through several benchmarks and showed its usefulness and competitiveness in building compact CNN models. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            895
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            151,
+            287,
+            166
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jose M Alvarez and Mathieu Salzmann. Learning the number of neurons in deep networks. In Advances in Neural Information Processing Systems, pp. 2270–2278, 2016. ",
+        "bbox": [
+            173,
+            174,
+            823,
+            200
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sajid Anwar, Kyuyeon Hwang, and Wonyong Sung. Structured pruning of deep convolutional neural networks. ACM Journal on Emerging Technologies in Computing Systems (JETC), 13(3):32, 2017. ",
+        "bbox": [
+            173,
+            208,
+            821,
+            234
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Amir Beck and Marc Teboulle. A fast iterative shrinkage-thresholding algorithm for linear inverse problems. SIAM Journal on Imaging Sciences, 2(1):183–202, 2009. ",
+        "bbox": [
+            174,
+            242,
+            820,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp minima can generalize for deep nets. In Proceedings of International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            174,
+            277,
+            820,
+            304
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In Advances in Neural Information Processing Systems, pp. 1135–1143, 2015. ",
+        "bbox": [
+            174,
+            313,
+            823,
+            339
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Babak Hassibi and David G Stork. Second order derivatives for network pruning: Optimal brain surgeon. In Advances in Neural Information Processing Systems, pp. 164–171, 1993. ",
+        "bbox": [
+            174,
+            347,
+            821,
+            375
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            174,
+            381,
+            823,
+            409
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of International Conference on Computer Vision, 2017. ",
+        "bbox": [
+            173,
+            416,
+            823,
+            444
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zehao Huang and Naiyan Wang. Data-driven sparse structure selection for deep neural networks. arXiv preprint arXiv:1707.01213, 2017. ",
+        "bbox": [
+            174,
+            452,
+            823,
+            478
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015. ",
+        "bbox": [
+            174,
+            486,
+            823,
+            513
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vadim Lebedev and Victor Lempitsky. Fast convnets using group-wise brain damage. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2554–2564, 2016. ",
+        "bbox": [
+            174,
+            521,
+            820,
+            547
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. In Advances in Neural Information Processing Systems, pp. 598–605, 1990. ",
+        "bbox": [
+            173,
+            555,
+            823,
+            583
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            171,
+            590,
+            821,
+            617
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and ´ C Lawrence Zitnick. Microsoft coco: Common objects in context. In European conference on computer vision, pp. 740–755. Springer, 2014. ",
+        "bbox": [
+            174,
+            626,
+            825,
+            665
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tie Liu, Zejian Yuan, Jian Sun, Jingdong Wang, Nanning Zheng, Xiaoou Tang, and Heung-Yeung Shum. Learning to detect a salient object. IEEE Transactions on Pattern analysis and machine intelligence, 33(2): 353–367, 2011. ",
+        "bbox": [
+            173,
+            672,
+            823,
+            712
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. arXiv preprint arXiv:1708.06519, 2017. ",
+        "bbox": [
+            169,
+            719,
+            823,
+            747
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient transfer learning. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            173,
+            755,
+            823,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaoyong Shen, Aaron Hertzmann, Jiaya Jia, Sylvain Paris, Brian Price, Eli Shechtman, and Ian Sachs. Automatic portrait segmentation for image stylization. In Computer Graphics Forum, volume 35, pp. 93–102. Wiley Online Library, 2016. ",
+        "bbox": [
+            171,
+            801,
+            823,
+            842
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances in Neural Information Processing Systems, pp. 2074–2082, 2016. ",
+        "bbox": [
+            173,
+            849,
+            823,
+            877
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chuan Yang, Lihe Zhang, Huchuan Lu, Xiang Ruan, and Ming-Hsuan Yang. Saliency detection via graphbased manifold ranking. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3166–3173, 2013. ",
+        "bbox": [
+            173,
+            885,
+            821,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiangyu Zhang, Jianhua Zou, Kaiming He, and Jian Sun. Accelerating very deep convolutional networks for classification and detection. IEEE Transactions on Pattern Analysis and Machine Intelligence, 38(10): 1943–1955, 2016. ",
+        "bbox": [
+            173,
+            104,
+            823,
+            142
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hao Zhou, Jose M Alvarez, and Fatih Porikli. Less is more: Towards compact cnns. In European Conference on Computer Vision, pp. 662–677. Springer, 2016. ",
+        "bbox": [
+            169,
+            151,
+            825,
+            178
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/9f3a9db4aa3de8ff16f04d70491a4b364af864f221ad2e7ad9dee6582b55f869.jpg",
+        "image_caption": [
+            "Figure 1: Visualization of the number of pruned channels at each convolution in the inception branch. Colored regions represents the number of channels kept. The height of each bar represents the size of feature map, and the width of each bar represents the size of channels. It is observed that most of channels in the bottom layers are kept while most of channels in the top layers are pruned. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            193,
+            787,
+            844
+        ],
+        "page_idx": 10
+    }
+]

parse/train/xboZWqM_ELA/xboZWqM_ELA.md

@@ -0,0 +1,357 @@
+# DEBIASED GRAPH NEURAL NETWORKS WITH AGNOSTIC LABEL SELECTION BIAS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Most existing Graph Neural Networks (GNNs) are proposed without considering the selection bias in data, i.e., the inconsistent distribution between the training set with test set. In reality, the test data is not even available during the training process, making selection bias agnostic. Training GNNs with biased selected nodes leads to significant parameter estimation bias and greatly impacts the generalization ability on test nodes. In this paper, we first present an experimental investigation, which clearly shows that the selection bias drastically hinders the generalization ability of GNNs, and theoretically prove that the selection bias will cause the biased estimation on GNN parameters. Then to remove the bias in GNN estimation, we propose a novel Debiased Graph Neural Networks (DGNN) with a differentiated decorrelation regularizer. The differentiated decorrelation regularizer estimates a sample weight for each labeled node such that the spurious correlation of learned embeddings could be eliminated. We analyze the regularizer in causal view and it motivates us to differentiate the weights of the variables based on their contribution on the confounding bias. Then, these sample weights are used for reweighting GNNs to eliminate the estimation bias, thus help to improve the stability of prediction on unknown test nodes. Comprehensive experiments are conducted on several challenging graph datasets with two kinds of label selection bias. The results well verify that our proposed model outperforms the state-of-the-art methods and DGNN is a flexible framework to enhance existing GNNs.
+
+# 1 INTRODUCTION
+
+Graph Neural Networks (GNNs) are powerful deep learning algorithms on graphs with various applications (Scarselli et al., 2008; Kipf & Welling, 2016; Velickovi ˇ c et al., 2017; Hamilton et al., ´ 2017). Existing GNNs mainly learn a node embedding through aggregating the features from its neighbors, and such message-passing framework is supervised by node label in an end-to-end manner. During this training procedure, GNNs will effectively learn the correlation between the structure pattern and node feature with node label, so that GNNs are capable of learning the embeddings of new nodes and inferring their labels.
+
+One basic requirement of GNNs making precise prediction on unseen test nodes is that the distribution of labeled training and test nodes is same, i.e., the structure and feature of labeled training and test nodes follow the similar pattern, so that the learned correlation between the current graph and label can be well generalized to the new nodes. However, in reality, there are two inevitable issues. (1) Because it is difficult to control the graph collection in an unbiased environment, the relationship between the collected real-world graph and the labeled nodes is inevitably biased. Training on such graph will cause biased correlation with node label. Taking a scientist collaboration network as an example, if most scientists with “machine learning” (ML) label collaborate with those with “computer vision” (CV) label, existing GNNs may learn spurious correlation, i.e., scientists who cooperate with CV scientist are ML scientists. If a new ML scientist only connects with ML scientists or the scientists in other areas, it will be probably misclassified. (2) The test node in the real scenario is usually not available, implying that the distribution of new nodes is agnostic. Once the distribution is inconsistent with that in the training nodes, the performance of all the current GNNs will be hindered. Even transfer learning is able to solve the distribution shift problem, however, it still needs the prior of test distribution, which actually cannot be obtained beforehand. Therefore, the agnostic label selection bias greatly affects the generalization ability of GNNs on unknown test data.
+
+![](images/f9fd6b7c6cf27a9c636af0d53db928b62744a418594709b81461b91a66ea750b.jpg)  
+Figure 1: Effect of selection bias on GCN and GAT.
+
+In order to observe selection bias in real graph data, we conduct an experimental investigation to validate the effect of selection bias on GNNs (details can be seen in Section 2.1). We select training nodes with different biased degrees for each dataset, making the distribution of training nodes and test nodes inconsistent. The results clearly show that selection bias drastically hinders the performance of GNNs on unseen test nodes. Moreover, with heavier bias, the performance drops more. Further, we theoretically analyze how the data selection bias results in the estimation bias in GNN parameters (details can be seen in Section 2.2). Based on the stable learning technique (Kuang et al., 2020), we can assume that the learned embeddings consist of two parts: stable variables and unstable variables. The data selection bias will cause the spurious correlation between these two kinds of variables. Thereby we prove that with the inevitable model misspecification, the spurious correlation will further cause the parameter estimation bias. Once the weakness of the current GNNs with selection bias is identified, one natural question is “how to remove the estimation bias in GNNs?”
+
+In this paper, we propose a novel Debiased Graph Neural Network (DGNN) framework for stable graph learning by jointly optimizing a differentiated decorrelation regularizer and a weighted GNN model. Specifically, the differentiated decorrelation regularizer is able to learn a set of sample weights under differentiated variable weights, so that the spurious correlation between stable and unstable variables would be greatly eliminated. Based on the causal view analysis of decorrelation regularizer, we theoretically prove that the weights of variables can be differentiated by the regression weights. Moreover, to better combine the decorrelation regularizer with GNNs, we prove that adding the regularizer to the embedding learned by the second to last layer could be both theoretically sound and flexible. Then the sample weights learned by decorrelation regularizer are used to reweight GNN loss so that the parameter estimation could be unbiased.
+
+In summary, the contributions of this paper are three-fold: i) We investigate a new problem of learning GNNs with agnostic label selection bias. The problem setting is general and practical for real applications. ii) We bring the idea of variable decorrelation into GNNs to relieve bias influence on model learning and propose a general framework DGNN which could be adopted to various GNNs. iii) We conduct the experiments on real-world graph benchmarks with two kinds of agnostic label selection bias, and the experimental results demonstrate the effectiveness and flexibility of our model.
+
+# 2 EFFECT OF LABEL SELECTION BIAS ON GNNS
+
+In this section, we first formulate our target problem as follows:
+
+Problem 1 (Semi-supervised Learning on Graph with Agnostic Label Selection Bias). Given a training graph $\mathcal { G } _ { t r a i n } = \{ \mathbf { A } _ { t r a i n } , \mathbf { X } _ { t r a i n } , \mathbf { Y } _ { t r a i n } \} ,$ , where $\mathbf { \bar { A } } _ { t r a i n } \in \mathbb { R } ^ { N \times N }$ ( $N$ nodes) represents the adjacency matrix, $\mathbf { X } _ { t r a i n } \in \mathbb { R } ^ { N \times D }$ (D features) refers to the node features and $\mathbf { Y } _ { t r a i n } \mathbf { \bar { \Pi } } \in \mathbb { R } ^ { n \times C }$ (n labeled nodes, $C$ classes) refers to the available labels for training $( n \ll N )$ , the task is to learn a GNN $g _ { \theta } ( \cdot )$ with parameter $\theta$ to precisely predict the label of nodes on test graph $\mathcal { G } _ { t e s t } =$ $\{ \mathbf { A } _ { t e s t } , \mathbf { X } _ { t e s t } , \mathbf { Y } _ { t e s t } \} ,$ , where distribution $\Psi ( \mathcal { G } _ { t r a i n } ) \neq \Psi ( \mathcal { G } _ { t e s t } )$ .
+
+# 2.1 EXPERIMENTAL INVESTIGATION
+
+We conduct an experimental investigation to examine whether the state-of-the-art GNNs are sensitive to the selection bias. The main idea is that we will perform two representative GNNs: GCN (Kipf & Welling, 2016) and GAT (Velickovi ˇ c et al., 2017) on three widely used graph datasets: ´ Cora, Citeseer, Pubmed (Sen et al., 2008) with different degrees of bias. If the performance drops sharply in comparison with the scenarios without selection bias, this will demonstrate that GNNs cannot generalize well in selection bias setting.
+
+To simulate the agnostic selection bias scenario, we first follow the inductive setting in $\mathrm { { W u } }$ et al. (2019) that masks the validation and test nodes as the training graph $\mathcal { G } _ { t r a i n }$ in the training phase, and then infer the labels of validation and test nodes with whole graph $\mathcal { G } _ { t e s t }$ . In this way, the distribution of test node can be considered agnostic. Following Zadrozny (2004), we design a biased label selection method on training graph $\mathcal { G } _ { t r a i n }$ . The selection variable $e$ is introduced to control whether the node will be selected as labeled nodes, where $e = 1$ means selected and 0 otherwise. For node $i$ , we compute its neighbor distribution ratio: $r _ { i } = | \{ j | j \in \mathcal { N } _ { i } , y _ { j } \neq y _ { i } \} | / | \mathcal { N } _ { i } |$ , where ${ \mathcal { N } } _ { i }$ is neighborhood of node $i$ in $\mathcal { G } _ { t r a i n }$ and $y _ { j } \ne y _ { i }$ means the label of central node $i$ is not the label of its neighborhood node $j$ . And $r _ { i }$ measures the difference between the label of central node $i$ with the labels of its neighborhood. Then we average all the nodes’ $r$ to get a threshold $t$ . For each node, the probability to be selected is: $P ( e _ { i } = 1 | r _ { i } ) = \left\{ \begin{array} { r } { \epsilon \quad r _ { i } \ge t } \\ { 1 - \epsilon \quad r _ { i } < t } \end{array} \right.$ , where  ∈ (0.5, 1) is used to control the degree of selection bias and the larger $\epsilon$ means heavier bias. We set $\epsilon$ as $\{ 0 . 7 , 0 . 8 , 0 . 9 \}$ to get three bias degrees for each dataset, termed as Light, Medium, Heavy, respectively. We select 20 nodes for each class for training and the validation and test nodes are same as Yang et al. (2016). Furthermore, we take the unbiased datasets as baselines, where the labeled nodes are selected randomly.
+
+Figure 1 is the results of GCN and GAT on biased datasets. The dashed lines mean the performances of GCN/GAT on unbiased datasets and the solid lines refer to the results on biased datasets. We can find that: i) The dashed lines are all above the corresponding coloured solid lines, indicating that selection bias greatly affects the GNNs’ performance. ii) All solid lines decrease monotonically with the increase of bias degree, demonstrating that heavier bias will cause larger performance decrease.
+
+# 2.2 THEORETICAL ANALYSIS
+
+The above experiment empirically verifies the effect of selection bias on GNNs. Here we theoretically analyze the effect of selection bias on estimating the parameters in GNNs. First, because biased labeled nodes have biased neighborhood structure, GNNs will encode this biased information into the node embeddings. Based on stable learning technique (Kuang et al., 2020), we make following assumption:
+
+Assumption 1. All the variables of embeddings learned by GNNs for each node can be decomposed as $\mathbf { H } = \{ \mathbf { S } , \mathbf { V } \}$ , where S represents the stable variables and $\mathbf { V }$ represents the unstable variables. Specifically, for both training and test environment, $\mathbb { E } ( \mathbf { Y } | \mathbf { S } = s , \mathbf { V } = v ) = \mathbb { E } ( \mathbf { Y } | \mathbf { S } = s )$ .
+
+Under Assumption 1, the distribution shift between training set and test set is mainly induced by the variation in the joint distribution over $( \mathbf { S } , \mathbf { V } )$ , i.e., $\mathbb { P } ( \mathbf { S } _ { t r a i n } , \mathbf { V } _ { t r a i n } ) \neq \mathbb { P } ( \mathbf { S } _ { t e s t } , \dot { \mathbf { V } } _ { t e s t } )$ . However, there is an invariant relationship between stable variable S and outcome $\mathbf { Y }$ in both training and test environments, which can be expressed as $\mathbb { P } ( \mathbf { Y } _ { t r a i n } | \mathbf { S } _ { t r a i n } ) = \mathbb { P } ( \mathbf { Y } _ { t e s t } | \mathbf { S } _ { t e s t } )$ . Assumption 1 can be guaranteed by $\mathbf { Y \bot V } |$ S. Thus, one can solve the stable prediction problem by developing a function ${ \bar { f } } ( \cdot )$ based on S. However, one can hardly identify such variables in GNNs.
+
+Without loss of generality, we take $\mathbf { Y }$ as continuous variable for analysis and have the following assumption:
+
+Assumption 2. The true generation process of target variable $\mathbf { Y }$ contains not only the linear combination of stable variables S, but also the nonlinear transformation of stable variables.
+
+Based on the above assumptions, we formalize the label generation process as follows:
+
+$$
+\mathbf { Y } = f ( \mathbf { X } , \mathbf { A } ) + \varepsilon = \mathcal { G } ( \mathbf { X } , \mathbf { A } ; \theta _ { g } ) _ { S } { \beta _ { S } } + \mathcal { G } ( \mathbf { X } , \mathbf { A } ; \theta _ { g } ) _ { V } { \beta _ { V } } + g ( \mathcal { G } ( \mathbf { X } , \mathbf { A } ; \theta _ { g } ) _ { S } ) + \varepsilon ,
+$$
+
+where $\mathcal { G } ( \mathbf { X } , \mathbf { A } ; \theta _ { g } ) \in \mathbb { R } ^ { N \times p }$ denotes an unknown function of $\mathbf { X }$ and $\mathbf { A }$ that learns node embedding and it can be learned by a GNN, such as GCN and GAT, the output variables of $\mathcal { G } ( \mathbf { X } , \mathbf { A } ; \boldsymbol { \theta } _ { g } )$ can be decomposed as stable variables G (X, A; θg)S ∈ RN×m and unstable variables $\mathcal { G } ( \mathbf { X } , \mathbf { A } ; \theta _ { g } ) _ { V } \in$ $\mathbf { R } ^ { N \times q } ( m + q = p ) , \beta _ { S } \in { \mathbb R } ^ { m \times 1 }$ and $\beta _ { V } \in \mathbb { R } ^ { q \times 1 }$ are the linear coefficients can be learned by the last layer of GNNs, $\varepsilon$ is the independent random noise, and $g ( \cdot )$ is the nonlinear transformation function of stable variables. According to Assumption 1, we know that coefficients of unstable variables $\mathcal { G } ( \mathbf { X } , \mathbf { A } ; \boldsymbol { \theta } _ { g } ) _ { V }$ are actually 0 (i.e., $\beta _ { V } { = } 0 )$ .
+
+For a classical GNN model with linear regressor, its prediction function can be formulated as:
+
+$$
+\hat { \mathbf { Y } } = \hat { \mathcal { G } } ( \mathbf { X } , \mathbf { A } ; \theta _ { g } ) _ { S } \hat { \boldsymbol { \beta } } _ { S } + \hat { \mathcal { G } } ( \mathbf { X } , \mathbf { A } ; \theta _ { g } ) _ { V } \hat { \boldsymbol { \beta } } _ { V } + \varepsilon .
+$$
+
+Compared with Eq. (1), we can find that the parameters of GNN could be unbiasedly estimated if the nonlinear term $g ( \mathcal { G } ( \mathbf { X } , \mathbf { A } ; \theta _ { g } ) _ { S } ) = 0$ , because the GNN model will have the same label generation mechanism as Eq. (1). However, limited by the nonlinear power of GNNs $\mathrm { \Delta X u }$ et al., 2019), it is reasonable to assume that there is a nonlinear term $g ( \mathcal { G } ( \mathbf { X } , \mathbf { A } ; \theta _ { g } ) _ { S } ) \neq 0$ that cannot be fitted by the GNNs. Under this assumption, next, we taking a vanilla GCN (Kipf & Welling, 2016) as an example to illustrate how the distribution shift will induce parameter estimation bias. A two-layer GCN can be formulated as $\hat { \mathbf { A } } \sigma ( \hat { \mathbf { A } } \mathbf { X } \mathbf { W } ^ { ( 0 ) } ) \mathbf { W } ^ { ( 1 ) }$ , where $\hat { \bf A }$ is the normalized adjacency matrix, W is the transformation matrix at each layer and $\sigma ( \cdot )$ is the Relu activation function. We decompose GCN as two parts: one is embedding learning part $\hat { \mathbf { A } } \sigma ( \hat { \mathbf { A } } \mathbf { X } \mathbf { W } ^ { ( 0 ) } )$ , which can be decomposed as $[ \mathbf { S } ^ { \mathrm { T } } , \mathbf { V } ^ { \mathrm { T } } ]$ , corresponding to $\hat { \mathcal { G } } ( \mathbf { X } , \mathbf { A } ; \theta _ { g } ) _ { S }$ and $\hat { \mathcal { G } } ( \mathbf { X } , \mathbf { A } ; \theta _ { g } ) _ { V }$ in Eq. (2), and the other part is $\mathbf { W } ^ { ( 1 ) }$ , where the learned parameters can be decomposed as $[ \tilde { \beta } _ { S } , \tilde { \beta } _ { V } ]$ , corresponding to $[ \hat { \beta } _ { S } , \hat { \beta } _ { V } ]$ in Eq. (2). We aim at minimizing the square loss: $\begin{array} { r } { \mathcal { L } _ { G C N } = \sum _ { i = 1 } ^ { n } ( \mathbf { S } _ { i } ^ { \mathrm { T } } \tilde { \boldsymbol { \beta } } _ { S } + \mathbf { V } _ { i } ^ { \mathrm { T } } \tilde { \boldsymbol { \beta } } _ { V } - \mathbf { Y } _ { i } ) ^ { 2 } } \end{array}$ .
+
+According to the derivation rule of partitioned regression model, we have:
+
+$$
+\tilde { \beta } _ { V } - \beta _ { V } = \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { V } _ { i } ^ { \mathsf { T } } \mathbf { V } _ { i } \big ) ^ { - 1 } \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { V } _ { i } ^ { \mathsf { T } } g \big ( \mathbf { S } _ { i } \big ) \big ) + \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { V } _ { i } ^ { \mathsf { T } } \mathbf { V } _ { i } \big ) ^ { - 1 } \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { V } _ { i } ^ { \mathsf { T } } \mathbf { S } _ { i } \big ) \big ( \beta _ { S } - \tilde { \beta } _ { S } \big ) ,
+$$
+
+$$
+\tilde { \beta } _ { S } - \beta _ { S } = ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { S } _ { i } ^ { \Gamma } \mathbf { S } _ { i } ) ^ { - 1 } ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { S } _ { i } ^ { \Gamma } g ( \mathbf { S } _ { i } ) ) + ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { S } _ { i } ^ { \Gamma } \mathbf { S } _ { i } ) ^ { - 1 } ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { S } _ { i } ^ { \Gamma } \mathbf { V } _ { i } ) ( \beta _ { V } - \tilde { \beta } _ { V } ) ,
+$$
+
+where $n$ is labeled node size, $\mathbf { S } _ { i }$ is $i$ -th sample of $\mathbf { S }$ , $\begin{array} { r } { \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { V } _ { i } ^ { \mathrm { T } } g ( \mathbf { S } _ { i } ) \ : = \ : \mathbb { E } ( \mathbf { V } ^ { \mathrm { T } } g ( \mathbf { S } ) ) + o _ { p } ( 1 ) } \end{array}$ , $\begin{array} { r } { \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { V } _ { i } ^ { \mathrm { T } } \mathbf { S } _ { i } = \mathbb { E } ( \mathbf { V } ^ { \mathrm { T } } \mathbf { S } ) + o _ { p } ( 1 ) } \end{array}$ and $o _ { p } ( 1 )$ is the error which is negligible. Ideally, $\tilde { \beta } _ { V } - \beta _ { V } = 0$ indicates that there is no bias between the estimated and the real parameter. However, if $\mathbb { E } ( \mathbf { V } ^ { \mathrm { T } } \mathbf { S } ) \neq 0$ or $\mathbb { E } ( \mathbf { V } ^ { \mathrm { T } } g ( \mathbf { S } ) ) \neq 0$ in Eq. (3), ${ \tilde { \beta } } _ { V }$ will be biased, leading to the biased estimation on $\tilde { \beta } _ { S }$ in Eq. (4) as well. Since the correlation between $\mathbf { V }$ and S (or $g ( \mathbf { S } ) )$ might shift in test phase, the biased parameters learned in training set is not the optimal parameters for predicting testing nodes. Therefore, to increase the stability of prediction, we need to unbiasedly estimate the parameters of ${ \tilde { \beta } } _ { V }$ by removing the correlation between $\mathbf { V }$ and S (or $g ( \mathbf { S } ) _ { \cdot }$ ) on training graph, making $\mathbb { E } ( \mathbf { V } ^ { \mathrm { T } } \mathbf { S } ) = 0$ or $\mathbb { E } ( \mathbf { V } ^ { \mathrm { T } } g ( \mathbf { S } ) ) = 0$ . Note that $\begin{array} { r } { \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { S } _ { i } ^ { \mathrm { T } } g ( \mathbf { S } _ { i } ) } \end{array}$ in Eq. (4) can also cause estimation bias, but the relation between S and $g ( \mathbf { S } )$ is stable across environments, which do not influence the stability to some extent.
+
+# 3 PROPOSED MODEL
+
+# 3.1 REVISITING ON VARIABLE DECORRELATION IN CAUSAL VIEW
+
+To decorrelate $\mathbf { V }$ and $\mathbf { S }$ (or $g ( \mathbf { S } ) _ { \mathfrak { c } }$ ), we should decorrelate the output variables of $\hat { \mathcal { G } } ( \mathbf { X } , \mathbf { A } ; \boldsymbol { \theta } _ { g } )$ (Kuang et al., 2020). They propose a Variable Decorrelation (VD) term with sample reweighting technique to eliminate the correlation between each variable pair, in which the sample weights are learned by jointly minimizing the moment discrepancy between each variable pair:
+
+$$
+\mathcal { L } _ { V D } ( \mathbf { H } ) = \sum _ { j = 1 } ^ { p } | | \mathbf { H } _ { \cdot j } ^ { \mathrm { T } } \boldsymbol { \Lambda } _ { \mathbf { w } } \mathbf { H } _ { \ldots j } / n - \mathbf { H } _ { \cdot j } ^ { \mathrm { T } } \mathbf { w } / n \cdot \mathbf { H } _ { \ldots j } ^ { \mathrm { T } } \mathbf { w } / n | | _ { 2 } ^ { 2 } ,
+$$
+
+where H ∈ Rn×p means the variables needed to be decorrelated, $\mathbf { H } _ { . j }$ is $j$ -th variable of ${ \bf H } , { \bf H } _ { - j } =$ $\mathbf { H } \backslash \mathbf { H } _ { . j }$ means all the remaining variables by setting the value of $j$ -th variable in $\mathbf { H }$ as zero, w $\mathbf { \tau } _ { r } \in \mathbb { R } ^ { n \times 1 }$ are sample weights, $\textstyle \sum _ { i = 1 } ^ { n } \mathbf { w } _ { i } = n$ and $\boldsymbol { \Lambda } _ { \mathbf { w } } = \mathrm { d i a g } ( \mathbf { w } _ { 1 } , \cdots , \mathbf { w } _ { n } )$ is the corresponding diagonal matrix. As we can see, $\mathcal { L } _ { V D } ( \mathbf { H } )$ can be reformulated as $\begin{array} { r l } { \phantom { } } & { { } \sum _ { j \neq k } | | \mathbf { H } _ { . j } ^ { \mathrm { T } } \boldsymbol { \Lambda } _ { \mathbf { w } } \mathbf { H } _ { . k } / n - \mathbf { H } _ { . j } ^ { \mathrm { T } } \mathbf { w } / n \cdot \mathbf { H } _ { . k } ^ { \mathrm { T } } \mathbf { w } / n | | _ { 2 } ^ { 2 } } \end{array}$ , and it aims to let $\mathbb { E } ( \mathbf { H } _ { . i } ^ { \mathrm { T } } \mathbf { H } _ { . j } ) = \mathbb { E } ( \mathbf { H } _ { . i } ^ { \mathrm { T } } ) \mathbb { E } ( \mathbf { H } _ { . j } )$ for each variable pair $j$ and $k$ ${ \bf \nabla } . { \mathcal { L } } _ { V D } ( { \bf H } )$ decorrelates all the variable pairs equally. However, decorrelating all the variables requires sufficient samples Kuang et al. (2020), i.e., $n \to \infty$ , which is hard to be satisfied, especially in the semi-supervised setting. In this scenario, we cannot guarantee $\mathcal { L } _ { V D } ( \mathbf { H } ) = 0$ . Therefore the key challenge is how to remove the correlation influencing the unbiased estimation most when $\mathcal { L } _ { V D } ( \dot { \mathbf { H } } ) \neq 0$ .
+
+Inspired by confounding balancing technique in observational studies (Hainmueller, 2012), we revisit the variable decorrelation regularizer in causal view and show how to differentiate each variable pair. Confounding balancing techniques are often used for causal effect estimation of treatment $T$ , where the distributions of confounders $\mathbf { X }$ are different between treated $( T = 1 )$ ) and control $( T = 0$ ) groups because of non-random treatment assignment. One could balance the distribution of confounders between treatment and control groups to unbiased estimate causal treatment effects (Yao et al., 2020). Most balancing approaches exploit moments to characterize distributions, and balance them by adjusting sample weights w as follows: $\begin{array} { r } { \mathbf { w } = \arg \operatorname* { m i n } _ { \mathbf { w } } | | \sum _ { i : T _ { i } = 1 } \mathbf { X } _ { i } - \sum _ { i : T _ { i } = 0 } \mathbf { w } _ { i } \cdot \mathbf { X } _ { i } | | _ { 2 } ^ { 2 } } \end{array}$ . After balancing, the treatment $T$ and confounders $\mathbf { X }$ tend to be independent.
+
+Given one targeted variable $j$ , under the variables only have linear relation assumption1, its decorrelataion term, $\mathcal { L } _ { V D _ { j } } = | | \mathbf { H } _ { . j } ^ { \mathrm { T } } \boldsymbol { \Lambda } _ { \mathbf { w } } \mathbf { H } _ { . - j } / n - \mathbf { H } _ { . j } ^ { \mathrm { T } } \mathbf { w } / n \cdot \mathbf { H } _ { . - j } ^ { \mathrm { T } } \mathbf { w } / n | | _ { 2 } ^ { 2 }$ , is to make $\mathbf { H } _ { . j }$ independent of $\mathbf { H } _ { . - j }$ , which is same as the confounding balancing term making treatment and confounders independent. Thereby, $\mathcal { L } _ { V _ { \frac { . } { . } } D _ { j } }$ can also be viewed as a confounding balancing term, where $\mathbf { H } _ { . j }$ is treatment and $\mathbf { H } _ { . - j }$ is confounders, illustrated in Fig. 2(a). Hence, our target can be explained as unbiasedly estimate causal effect of each variable which is invariant across training and test set. As different variable may contribute unequally to the confounding bias, it is necessary to differentiate the confounders. The target of differentiating confounders exactly matches our target that removes the correlation of variables influencing the unbiased estimation most.
+
+# 3.2 DIFFERETIATED VARIABLE DECORRELATION
+
+Considering the continuous treatment, the causal effect of treatment can be measured by Marginal Treatment Effect Function (MTEF) (Kreif et al., 2015), and defined as: $M T E F \ =$ E[Yi(t)]−E[Yi(t−∆t)] , where Yi(t) represents the potential outcome of sample i with treatment status $T = t , \mathbb { E } ( \cdot )$ refers to the expectation function, and $\Delta t$ denotes the increasing level of treatment. With the sample weights w decorrelating treatment and confounders, we can estimate the MTEF by:
+
+$$
+\widehat { M T E F } = \frac { \sum _ { i : T _ { i } = t } \mathbf { w } _ { i } \cdot Y _ { i } ( t ) - \sum _ { j : T _ { j } = t - \Delta t } \mathbf { w } _ { j } \cdot Y _ { j } ( t - \Delta t ) } { \Delta t } .
+$$
+
+Next we theoretically analyze how to differentiate confounders’ weights with following theorem.
+
+Theorem 1. In observational studies, different confounders make unequal confounding bias on Marginal Treatment Effect Function (MTEF) with their own weights, and the weights can be learned via regressing outcome $Y$ on confounders $\mathbf { X }$ and treatment variable $T$ .
+
+We prove Theorem 1 with the following assumption:
+
+Assumption 3 (Linearity). The regression of outcome $Y$ on confounders $\mathbf { X }$ and treatment variable $T$ is linear, that is $\begin{array} { r } { Y = \dot { \sum } _ { k \neq t } \alpha _ { k } \mathbf { X } _ { . k } + \alpha _ { t } T + c + \varepsilon , } \end{array}$ , where $\alpha _ { k } \in \alpha$ is the linear coefficient.
+
+Under Assumption 3, we can write estimator of $\overline { { M T E } } F$ as:
+
+$$
+\begin{array} { r l } & { \widehat { M T E F } = \frac { \sum _ { i : T _ { i } = t } \mathbf { w } _ { i } \cdot Y _ { i } ( t ) - \sum _ { j : T _ { j } = t - \Delta t } \mathbf { w } _ { j } \cdot Y _ { j } ( t - \Delta t ) } { \Delta t } } \\ & { \qquad = M T E F + \sum _ { k \neq t } \alpha _ { k } ( \frac { \sum _ { i : T _ { i } = t } \mathbf { w } _ { i } \cdot \mathbf { X } _ { i k } - \sum _ { j : T _ { j } = t - \Delta t } \mathbf { w } _ { j } \cdot \mathbf { X } _ { j k } } { \Delta t } ) + \phi ( \varepsilon ) , } \end{array}
+$$
+
+where $M T E F$ is the ground truth, $\phi ( \varepsilon )$ means the noise term, and $\phi ( \varepsilon ) \simeq 0$ with Gaussian noise. The detailed derivation can be found in Appendix A. To reduce the bias of $\overline { { M T E } } F$ , we need regulate the term ( ∑i∶Ti=t wi⋅Xik−∑j∶Tj =t−∆t wj ⋅Xjk ), where $\frac { \sum _ { i : T _ { i } = t } \mathbf { w } _ { i } \cdot \mathbf { X } _ { i k } - \sum _ { j : T _ { j } = t - \Delta t } \mathbf { w } _ { j } \cdot \mathbf { X } _ { j k } } { \Delta t }$ means the difference of the $k$ -th confounder between treated and control samples. The parameter $\alpha _ { k }$ represents the confounding bias weight of the $k$ -th confounder, and it is the coefficient of $\mathbf { X } _ { , k }$ . Moreover, because our target is to learn the weight of each variable pair, i.e., between treatment and each confounder, we need to learn the weight $\alpha _ { t }$ of treatment that is the coefficient of $T$ . Hence, the confounder weights and treatment weight can be learned from the regression of observed outcome $Y$ on confounders $\mathbf { X }$ and treatment $T$ under Linearity assumption.
+
+![](images/8c609d44418758afb0b62cb2750a20f3cc9f350cc703561c7aea5b74eca6d3db.jpg)  
+Figure 2: (a) Diagram of decorrelating node embedding with confounding balance. H(K−1) i s the node embedding to be decorrelated. $T$ is the treatment, corresponding to one target variable in H(K−1). $\mathbf { X }$ is the confounders, corresponding to the remaining variables of the target variable in $\mathbf { H } ^ { ( K - 1 ) }$ . $Y$ is the outcome, corresponding to labels. (b) The framework of GNN-DVD. The same color in the two figures represents the same kind of variable.
+
+Due to the connection between treatment effect estimation with variable decorrelation as analyzed in Section 3.1, we utilize Theorem 1 to reweight the variable weight in variable decorrelation term. When apply the Theorem 1 to GNNs, the confounders $\mathbf { X }$ should be $\mathbf { H } _ { . - j }$ and treatment is $\mathbf { H } _ { . j }$ , where the embedding $\mathbf { H }$ is learned by $\hat { \mathcal { G } } ( \mathbf { X } , \mathbf { A } ; \boldsymbol { \theta } _ { g } )$ in Eq. (2). And the variable weights $\alpha$ could be computed from the regression coefficients for $\mathbf { H }$ , hence $\alpha$ is equal to $\hat { \beta }$ in Eq. (2). Then the Differentiated Variable Decorrelation (DVD) term can be formulated as follows:
+
+$$
+\begin{array} { l } { \displaystyle \operatorname* { m i n } _ { \mathbf { w } } \mathcal { L } _ { D V D } \big ( \mathbf { H } \big ) = \sum _ { j = 1 } ^ { p } \big ( \boldsymbol { \alpha } ^ { \mathrm { T } } \cdot \mathrm { a b s } \big ( \mathbf { H } _ { \mathcal { I } } ^ { \mathrm { T } } \boldsymbol { \Lambda } _ { \mathbf { w } } \mathbf { H } _ { . - j } / n - \mathbf { H } _ { \mathcal { I } } ^ { \mathrm { T } } \mathbf { w } / n \cdot \mathbf { H } _ { . - j } ^ { \mathrm { T } } \mathbf { w } / n \big ) \big ) ^ { 2 } } \\ { \displaystyle \qquad + \frac { \lambda _ { 1 } } { n } \sum _ { i = 1 } ^ { n } \mathbf { w } _ { i } ^ { 2 } + \lambda _ { 2 } \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { w } _ { i } - 1 \big ) ^ { 2 } , s . t . \mathbf { w } \succeq 0 } \end{array}
+$$
+
+where $\operatorname { a b s } ( { \mathord { \cdot } } )$ means the element-wise absolute value operation, preventing positive and negative values from eliminating. Term $\frac { \lambda _ { 1 } } { n } \sum _ { i = 1 } ^ { n } \mathbf { w } _ { i } ^ { 2 }$ is added to reduce the variance of sample weights to achieve stability, and the formula $\begin{array} { r } { \lambda _ { 2 } \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } { \mathbf { w } _ { i } } - 1 \big ) ^ { 2 } } \end{array}$ avoids all the sample weights to be 0. The term $\mathbf { w } \succeq 0$ constrains each sample weight to be non-negative. After variable reweighting, the weighted decorrelation term in Eq. (8) can band the weight for variable pair rewrand en as wou $\begin{array} { r l } { \phantom { x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x } } & { { } \phantom { x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x } } \end{array}$ $j$ $k$ $\alpha _ { j } ^ { 2 } \alpha _ { k } ^ { 2 }$ treatment and confounder. We prove the uniqueness property of w in Appendix B, as follows:
+
+Theorem 2 (Uniqueness). If $\lambda _ { 1 } n \gg p ^ { 2 } + \lambda _ { 2 }$ , $p ^ { 2 } \gg \operatorname* { m a x } ( \lambda _ { 1 } , \lambda _ { 2 } )$ , $| \mathbf { H } _ { i , j } | \leq c$ and $\left| \alpha _ { i } \right| \leq c$ for some constant c, the solution $\mathbf { \dot { v } } \in \left\{ \mathbf { w } : \left| \mathbf { w } _ { i } \right| \leq c \right\}$ to minimize Eq. (8) is unique.
+
+# 3.3 DEBIASED GNN FRAMEWORK
+
+In this section, we describe the framework of Debiased GNN that incorporates DVD/VD term with GNNs in a seamless way. As analyzed in Section 2.2, decorrelating $\hat { \mathbf { A } } \sigma ( \hat { \mathbf { A } } \mathbf { X } \mathbf { W } ^ { ( 0 ) } )$ could make GCN stable. However, most GNNs follow a layer-by-layer stacking structure, and the output embedding of each layer is more easy to obtain in implementing. Since $\hat { \mathbf { A } } \sigma ( \hat { \mathbf { A } } \mathbf { X } \mathbf { W } ^ { ( 0 ) } )$ is the aggregation of the first layer embedding $\sigma ( \hat { \mathbf { A } } \mathbf { X } \mathbf { W } ^ { ( 0 ) } )$ , decorrelating these variables may lack the flexibility that incorporates DVD/VD term with other GNN structure. Fortunately, we have the following theorem to identify a more flexible way to combine variable decorrelation with GNNs.
+
+Theorem 3. Given p pairwise uncorrelated variables $\mathbf { Z } = ( \mathbf { Z } _ { 1 } , \mathbf { Z } _ { 2 } , \cdots , \mathbf { Z } _ { p } )$ , with a linear aggregation operator $\hat { \bf A }$ , the variables of $\mathbf { Y } = \hat { \mathbf { A } } \mathbf { Z }$ are still pairwise uncorrelated.
+
+Proof can be found in Appendix C. The theorem indicates that if the variables of embeddings $\mathbf { Z }$ are uncorrelated, after any form of linear neighborhood aggregation $\hat { \bf A }$ , e.g., average, attention or sum, the variables of transformed embeddings $\mathbf { Y }$ would be also uncorrelated. Therefore, decorrelating $\sigma ( \hat { \mathbf { A } } \mathbf { X } \mathbf { W } ^ { ( 0 ) } )$ can also reduce the estimation bias. For a $K$ layers of GNN, we can directly decorrelate the output of $( K - 1 )$ -th layer, i.e., $\sigma ( \hat { \mathbf { A } } { \cdots } { \sigma } ( \hat { \mathbf { A } } \mathbf { X } \mathbf { W } ^ { ( 0 ) } ) { \cdots } { \mathbf { W } } ^ { ( K - 2 ) } )$ for a $K$ layers of GCN.
+
+The previous analysis finds a flexible way to incorporate DVD/VD term with GNNs, however, recall that we analyze GNNs based on the least squares loss, and most existing GNNs are designed for classification. Therefore, in the following, we analyze that the previous conclusions are still applicable in classification. We consider the cases that softmax layer is used as the output layer of GNNs and loss is the cross-entropy error function. We use the Newton-Raphson update rule (Bishop, 2006) to bridge the gap between linear regression and multi-classification. According to the Newton-Raphson update rule, the update formula for transformation matrix $\mathbf { W } ^ { ( K - 1 ) }$ of the last layer of GCN can be derived:
+
+$$
+\begin{array} { r l } & { \mathbf { W } _ { , j } ^ { ( \mathrm { n e w } ) } = \mathbf { W } _ { , j } ^ { ( \mathrm { o l d } ) } - \left( { \boldsymbol { \mathbf { H } } ^ { \mathrm { T } } } \mathbf { R } { \boldsymbol { \mathbf { H } } } \right) ^ { - 1 } \mathbf { H } ^ { \mathrm { T } } ( \mathbf { H } \mathbf { W } _ { , j } ^ { ( \mathrm { o l d } ) } - \mathbf { Y } _ { , j } ) } \\ & { \qquad = \left( \mathbf { H } ^ { \mathrm { T } } \mathbf { R } \mathbf { H } \right) ^ { - 1 } \{ \mathbf { H } ^ { \mathrm { T } } \mathbf { R } \mathbf { H } \mathbf { W } _ { , j } ^ { ( \mathrm { o l d } ) } - \mathbf { H } ^ { \mathrm { T } } ( \mathbf { H } \mathbf { W } _ { , j } ^ { ( \mathrm { o l d } ) } - \mathbf { Y } _ { , j } ) \} = \left( \mathbf { H } ^ { \mathrm { T } } \mathbf { R } \mathbf { H } \right) ^ { - 1 } \mathbf { H } ^ { \mathrm { T } } \mathbf { R } \mathbf { z } , } \end{array}
+$$
+
+where $\begin{array} { r } { \mathbf { R } _ { k j } = - \sum _ { n = 1 } ^ { N } \mathbf { H } _ { n } \mathbf { W } _ { . k } ^ { \mathrm { ( o l d ) } } ( \mathbf { I } _ { k j } - \mathbf { H } _ { n } \mathbf { W } _ { . j } ^ { \mathrm { ( o l d ) } } ) } \end{array}$ is a weighing matrix and $\mathbf { I } _ { k j }$ is the element of the identity matrix, and z = HW(old).j − $\mathbf { z } = \mathbf { H } \mathbf { W } _ { . j } ^ { ( \mathrm { o l d } ) } - \mathbf { R } ^ { - 1 } ( \mathbf { Y } _ { . j } - \mathbf { W } _ { . j } \mathbf { H } )$ is an effective target value. Eq. (9) takes the form of a set of normal equations for a weighted least-squares problem. As the weighing matrix R is not constant but depends on the parameter vector W(old).j , we must apply the normal equations iteratively. Each iteration uses the last iteration weight vector W(old).j t matrix $\mathbf { R }$ and regresses the target value $\mathbf { z }$ with $\mathbf { H } \mathbf { W } _ { . j } ^ { ( \mathrm { n e w } ) }$ . Th o compute a revised weighing, the variable decorrelation can also be applied to the GNNs with softmax classifier to reduce the estimation bias in each iteration.
+
+Figure 2(b) is the framework of GNN-DVD, and we input the labeled nodes’ embeddings H˜ (K−1) into the regularizer $\mathcal { L } _ { D V D } ( \tilde { \mathbf { H } } ^ { ( K - 1 ) } )$ . As GCN has the formula sof tmax $\mathbf { \mathbf { \mathbf { A } } } \mathbf { H } ^ { ( K - 1 ) } \mathbf { \mathbf { W } } ^ { ( K - 1 ) } )$ , the variable weights of H˜ (K−1) used for differentiating $\mathcal { L } _ { D V D } ( \tilde { \mathbf { H } } ^ { ( K - 1 ) } )$ can be computed from $\alpha = \mathrm { V a r } ( \mathbf { W } ^ { ( K - 1 ) } , \mathrm { a x i s = 1 } )$ , where ${ \mathrm { V a r } } ( \cdot , { \mathrm { a x i s } } = 1 _ { . }$ ) refers to calculating the variance of each row of some matrix and it reflects each variable’s weight for classification which is similar to the regression coefficients. Note that when incorporating VD term with GNNs, we do not need compute the variable weights. Then the sample weights w learned by DVD term have the ability to remove the correlation in $\tilde { \mathbf { H } } ^ { ( K - 1 ) }$ . We propose to use this sample weights to reweight softmax loss:
+
+$$
+\operatorname* { m i n } _ { \theta } \mathcal { L } _ { G } = \sum _ { l \in \mathcal { V } _ { L } } \mathbf { w } _ { l } \cdot \ln ( q ( \tilde { \mathbf { H } } _ { l } ^ { ( K ) } ) \cdot \mathbf { Y } _ { l } ) ,
+$$
+
+where $q ( \cdot )$ is the softmax function, $\mathcal { { V } } _ { L }$ is the set of labeled node indices and $\theta$ is the set of parameters of GCN. The complexity analysis as well as the optimization of whole algorithm are summarized in Appendix D.
+
+# 4 EXPERIMENTS
+
+Datasets Here, we validate the effectiveness of our method on node classification with two kinds of selection biased data, i.e., label selection bias and small sample selection bias. For label selection bias, we empoly three widely used graph datasets: Cora, Citeseer and Pubmed (Sen et al., 2008). As in Section 2.1, we make the inductive setting for each graph and get three biased degrees for each graph. For small sample selection bias, we conduct the experiments on NELL dataset (Carlson et al., 2010) that each class only has one labeled node for training. Due to the large scale of this dataset, the test nodes are easily to have distribution shift from training nodes. The details of the datasets and experimental setup are given in Appendix E. One can download codes and datasets for all experiments from the supplementary material.
+
+Table 1: Performance of three citation networks. The ‘\*’ indicates the best results of the baselines. Best results of all methods are indicated in bold. $\cdot \%$ gain over GCN/GAT’ means the improvement percent of GCN/GAT-DVD against GCN/GAT, respectively.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="3">Cora</td><td colspan="3">Citeseer</td><td colspan="3">Pubmed</td></tr><tr><td>Light</td><td>Medium</td><td>Heavy</td><td>Light</td><td>Medium</td><td>Heavy</td><td>Light</td><td>Medium</td><td>Heavy</td></tr><tr><td>MLP</td><td>0.5624</td><td>0.5197</td><td>0.5087</td><td>0.4532</td><td>0.3757</td><td>0.3893</td><td>0.6852</td><td>0.6620</td><td>0.6378</td></tr><tr><td>Planetoid (Yang et al., 2016)</td><td>0.5890</td><td>0.5240</td><td>0.5180</td><td>0.5160</td><td>0.5140</td><td>0.4880</td><td>0.7160</td><td>0.6770</td><td>0.6680</td></tr><tr><td>Chebyshev (Defferrard et al.,2016)</td><td>0.7116</td><td>0.7006</td><td>0.6809</td><td>0.6542</td><td>0.6276</td><td>0.5920</td><td>0.7358</td><td>0.6862</td><td>0.6732</td></tr><tr><td>SGC (Wu et al., 2019)</td><td>0.7800</td><td>0.7800</td><td>0.7530</td><td>0.6780</td><td>0.6730*</td><td>0.6200</td><td>0.7880*</td><td>0.7560</td><td>0.6800</td></tr><tr><td>APPNP (Klicpera et al.,2019)</td><td>0.7913</td><td>0.7689</td><td>0.7629</td><td>0.6478</td><td>0.6052</td><td>0.5903</td><td>0.7639</td><td>0.7369</td><td>0.6862</td></tr><tr><td>GNM-GCN (Zhou et al.,2019)</td><td>0.7423</td><td>0.7531</td><td>0.7196</td><td>0.5793</td><td>0.5717</td><td>0.5125</td><td>0.7552</td><td>0.7381</td><td>0.7072</td></tr><tr><td>GNM-GAT (Zhou etal., 2019)</td><td>0.7875</td><td>0.7638</td><td>0.7404</td><td>0.6524</td><td>0.6487</td><td>0.5865</td><td>0.7438</td><td>0.7568</td><td>0.6891</td></tr><tr><td>GCN(Kipf &amp;Welling,2016)</td><td>0.7851</td><td>0.7775</td><td>0.7422</td><td>0.6786</td><td>0.5952</td><td>0.5551</td><td>0.7673</td><td>0.7545</td><td>0.7247</td></tr><tr><td>GCN-VD</td><td>0.7951</td><td>0.7855</td><td>0.7522</td><td>0.6844</td><td>0.6676</td><td>0.6408</td><td>0.7727</td><td>0.7729</td><td>0.7399</td></tr><tr><td>GCN-DVD</td><td>0.7959</td><td>0.7885</td><td>0.7555</td><td>0.6908</td><td>0.6769</td><td>0.6496</td><td>0.7741</td><td>0.7746</td><td>0.7542</td></tr><tr><td>% gain over GCN</td><td>1.38%</td><td>1.41%</td><td>1.79%</td><td>1.8%</td><td>14.2%</td><td>17.0%</td><td>0.89%</td><td>2.67%</td><td>4.07%</td></tr><tr><td>GAT(Velickovic et al.,2017)</td><td>0.8067*</td><td>0.8019*</td><td>0.7578</td><td>0.7033*</td><td>0.6683</td><td>0.6475*</td><td>0.7665</td><td>0.7579*</td><td>0.7068</td></tr><tr><td>GAT-VD</td><td>0.8146</td><td>0.8079</td><td>0.7708</td><td>0.7149</td><td>0.6833</td><td>0.6611</td><td>0.7783</td><td>0.7689</td><td>0.7149</td></tr><tr><td>GAT-DVD</td><td>0.8179</td><td>0.8119</td><td>0.7694</td><td>0.7172</td><td>0.6825</td><td>0.6627</td><td>0.7788</td><td>0.7723</td><td>0.7210</td></tr><tr><td>% gain over GAT</td><td>1.39%</td><td>1.26%</td><td>1.53%</td><td>1.97%</td><td>2.12%</td><td>2.34%</td><td>1.6%</td><td>1.9%</td><td>2.0%</td></tr></table>
+
+Baselines Under our proposed framework, we incorporate the VD/DVD term with GCN and GAT called GCN-VD/DVD and GAT-VD/DVD (details in Appendix F), and thus GCN and GAT are two basic baselines. We compare with GNM-GCN/GAT (Zhou et al., 2019) that considers the label selection bias in transductive setting. Moreover, several state-of-the-art GNNs are included: Chebyshev filter (Kipf & Welling, 2016), SGC (Wu et al., 2019) and APPNP (Klicpera et al., 2019). Additionally, we compare with Planetoid (Yang et al., 2016) and MLP trained on the labeled nodes.
+
+Results on Label Selection Bias Dataset The results are given in Table 1, and we have the following observations. First, the proposed models (i.e., GCN/GAT with VD/DVD terms) always achieve the best performances in most cases, which well demonstrates that the effectiveness of our proposed debiased GNN framework. Second, comparing with base models, our proposed models all achieve up to $1 7 . 0 \%$ performance improvements, and gain larger improvements under heavier bias scenarios. Since the major difference between our model with base models is the VD/DVD regularizer, we can safely attribute the significant improvements to the effective decorrelation term and its seamless joint with GNN models. Moreover, GCN/GAT-DVD achieve better results that GCN/GAT-VD in most cases. It validates the importance and effectiveness of differentiating variables’ weights in semi-supervised setting. Additional experimental results about the sample weight analysis and parameter sensitivity analysis can be found in Appendix G.
+
+Results on Small Sample Selection Bias Dataset As NELL is a large-scale graph, we cannot run GAT on a single GPU with 16GB memory. We only perform GCN-VD/DVD and compare with representative methods which can perform on this dataset. The results are shown in Table 2. First, GCN-VD/DVD achieve significant improvements over GCN. It indicates that selection bias could be induced by a small number of labeled nodes and our proposed method can relieve the estimation bias. Moreover, GCN-DVD further improves GCN-VD with a large margin. It further validates that decorrelating all the variable pairs equally is suboptimal, and our differentiated strategy is effective when labeled nodes are scarce. The reason that GNM-GCN fails is the GNM relies on the accuracy of the IPW estimator that predicts the probability of a node to be selected, however, in this dataset, the ratio of positive and negative samples are extremely unbalanced influencing the performance of IPW.
+
+Table 2: Performance of NELL   
+
+<table><tr><td>Dataset</td><td>MLP</td><td>Planetoid</td><td>SGC</td><td>GNM-GCN</td><td>GCN</td><td>GCN-VD</td><td>GCN-DVD</td></tr><tr><td>NELL</td><td>0.2385</td><td>0.3901</td><td>0.4128</td><td>0.1589</td><td>0.4416</td><td>0.4652</td><td>0.4734</td></tr></table>
+
+# 5 RELATED WORKS
+
+In the past few years, Graph Neural Networks (GNNs) (Scarselli et al., 2008; Kipf & Welling, 2016; Velickovi ˇ c et al., 2017; Xu et al., 2019; Klicpera et al., 2019) have become the major technology ´ to capture patterns encoded in the graph due to its powerful representation capacity. Although the current GNNs have achieved great success, when applied to inductive setting, they all assume that training nodes and test nodes follow the same distribution. However, this assumption does not always hold in real applications. GNM (Zhou et al., 2019) first pays attention on the label selection problem on graph learning, and it learns a IPW estimator to estimate the probability of each node to be selected and uses this probability to reweight the labeled nodes. However, it heavily relies on the accuracy of IPW estimator, which depends on the label assignment distribution of whole graph, hence it is more suitable for transductive setting.
+
+To enhance the stability in unseen varied distributions, some literatures (Shen et al., 2020b; Kuang et al., 2020) have revealed the connection between correlation and prediction stability under model misspecification. However, these methods are built on the simple regressions, but GNNs have more complex structure and properties needed to be considered. We also notice that Shen et al. (2020a) propose a differentiated variable decorrelation term for linear regression. However, this decorrelation term requires multiple environment with different correlations between stable variable and unstable variable available in the training stage while our method do not require.
+
+# 6 CONCLUSION
+
+In this paper, we investigate a general and practical problem: learning GNNs with agnostic selection bias. The selection bias will inevitably cause the GNNs to learn the biased correlation between aggregation mode and class label and make the prediction unstable. We then propose a novel differentiated decorrelated GNN, which combines the debiasing technique with GNNs in a unified framework. Extensive experiments well demonstrate the effectiveness and flexibility of GNN-DVD.
+
+# REFERENCES
+
+Christopher M Bishop. Pattern recognition and machine learning. springer, 2006.
+
+Andrew Carlson, Justin Betteridge, Bryan Kisiel, Burr Settles, Estevam R Hruschka, and Tom M Mitchell. Toward an architecture for never-ending language learning. In AAAI, 2010.
+
+Michael Cogswell, Faruk Ahmed, Ross Girshick, Larry Zitnick, and Dhruv Batra. Reducing overfitting in deep networks by decorrelating representations. In ICLR, 2016.
+
+Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In NeurIPS, pp. 3844–3852, 2016.
+
+Jens Hainmueller. Entropy balancing for causal effects: A multivariate reweighting method to produce balanced samples in observational studies. Political analysis, pp. 25–46, 2012.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In NeurIPS, pp. 1024–1034, 2017.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2016.
+
+Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. In ICLR, 2019.
+
+Noémi Kreif, Richard Grieve, Iván Díaz, and David Harrison. Evaluation of the effect of a continuous treatment: a machine learning approach with an application to treatment for traumatic brain injury. Health economics, 24(9):1213–1228, 2015.
+
+Kun Kuang, Ruoxuan Xiong, Peng Cui, Susan Athey, and Bo Li. Stable prediction with model misspecification and agnostic distribution shift. In AAAI, 2020.
+
+Yuji Nakatsukasa. Absolute and relative weyl theorems for generalized eigenvalue problems. Linear Algebra and its Applications, 432(1):242–248, 2010.
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2008.
+
+Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.
+
+Zheyan Shen, Peng Cui, Jiashuo Liu, Tong Zhang, Bo Li, and Zhitang Chen. Stable learning via differentiated variable decorrelation. In KDD, pp. 2185–2193, 2020a.
+
+Zheyan Shen, Peng Cui, Tong Zhang, and Kun Kuang. Stable learning via sample reweighting. In AAAI, pp. 5692–5699, 2020b.
+
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. In ICLR, 2017.
+
+Felix Wu, Amauri Souza, Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Weinberger. Simplifying graph convolutional networks. In ICML, pp. 6861–6871. PMLR, 2019.
+
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In ICLR, 2019. URL https://openreview.net/forum?id ${ . } = { }$ ryGs6iA5Km.
+
+Zhilin Yang, William W Cohen, and Ruslan Salakhutdinov. Revisiting semi-supervised learning with graph embeddings. In ICML, 2016.
+
+Liuyi Yao, Zhixuan Chu, Sheng Li, Yaliang Li, Jing Gao, and Aidong Zhang. A survey on causal inference. arXiv preprint arXiv:2002.02770, 2020.
+
+Bianca Zadrozny. Learning and evaluating classifiers under sample selection bias. In ICML, pp. 114, 2004.
+
+Fan Zhou, Tengfei Li, Haibo Zhou, Hongtu Zhu, and Ye Jieping. Graph-based semi-supervised learning with non-ignorable non-response. In NeurIPS, pp. 7015–7025, 2019.
+
+A DERIVATION OF $\overline { { M T E } } F$
+
+$$
+\begin{array} { r l } { \widehat { d T F F } F = } & { \frac { \sum _ { i : T _ { i } = t } \mathbf { w } _ { i } \cdot Y _ { i } ( t ) - \sum _ { j : T _ { j } = t - \Delta t } \mathbf { w } _ { j } \cdot Y _ { j } ( t - \Delta t ) } { \Delta t } } \\ & { = \frac { \sum _ { i : T _ { i } = t } \mathbf { w } _ { i } \cdot ( \sum _ { k \neq t } \alpha _ { k } \mathbf { X } _ { i k } + \alpha _ { t } t + c + c ) - \sum _ { j : T _ { j } = t - \Delta t } \mathbf { w } _ { j } \cdot ( \sum _ { k \neq t } \alpha _ { k } \mathbf { X } _ { j k } + \alpha _ { t } ( t - \Delta t ) } { \Delta t } } \\ & { = \frac { \sum _ { i : T _ { i } = t } \mathbf { w } _ { i } \alpha _ { t } t - \sum _ { j : T _ { j } = t - \Delta t } \mathbf { w } _ { j } \alpha _ { t } ( t - \Delta t ) } { \Delta t } } \\ & { + \frac { ( \sum _ { i : T _ { i } = t } \mathbf { w } _ { i } \sum _ { k \neq t } \alpha _ { k } \mathbf { X } _ { i k } - \sum _ { j : T _ { j } = t - \Delta t } \mathbf { w } _ { j } \cdot \sum _ { k \neq t } \alpha _ { k } \mathbf { X } _ { i k } ) } { \Delta t } + \phi ( \epsilon ) } \\ & { = M T E F + \sum _ { k \neq t } \frac { \sum _ { i : T _ { i } = t } \mathbf { W } _ { i } \cdot \mathbf { X } _ { i k } - \sum _ { j : T _ { j } = t - \Delta t } \mathbf { w } _ { j } \cdot \mathbf { X } _ { j k } } { \Delta t } ) + \phi ( \epsilon ) , } \end{array}
+$$
+
+where $\frac { \sum _ { i : T _ { i } = t } \mathbf { w } _ { i } \alpha _ { t } t - \sum _ { j : T _ { j } = t - \Delta t } \mathbf { w } _ { j } \alpha _ { t } ( t - \Delta t ) } { \Delta t }$ is the ground truth of M T EF , $\phi ( \epsilon )$ means the noise term, and $\phi ( \epsilon ) \simeq 0$ with Gaussian noise.
+
+# B PROOF OF THEOREM 2
+
+$$
+\hat { \mathbf { v } } = \arg \operatorname* { m i n } _ { \mathbf { w } } \sum _ { j = 1 } ^ { p } ( \alpha ^ { \mathrm { T } } \cdot \mathrm { a b s } ( \mathbf { H } _ { \mathrm { \mathcal { I } } } ^ { \mathrm { T } } \Lambda _ { \mathbf { w } } \mathbf { H } _ { \mathrm { \mathcal { I - \cdot } \mathcal { I } } } / n - \mathbf { H } _ { \mathrm { \mathcal { I } } } ^ { \mathrm { T } } \mathbf { w } / n \cdot \mathbf { H } _ { \mathrm { \mathcal { - I } } } ^ { \mathrm { T } } \mathbf { w } / n ) ) ^ { 2 } + \frac { \lambda _ { 1 } } { n } \sum _ { i = 1 } ^ { n } \mathbf { w } _ { i } ^ { 2 } + \lambda _ { 2 } ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { w } _ { i } - 1 ) ^ { 2 }
+$$
+
+Proof For simplicity, we denote $\begin{array} { r } { \mathcal { L } _ { 1 } = \sum _ { j = 1 } ^ { p } \big ( \boldsymbol { \alpha } ^ { \mathrm { T } } \cdot \mathrm { a b s } \big ( \mathbf { H } _ { . j } ^ { \mathrm { T } } \boldsymbol { \Lambda } _ { \mathbf { w } } \mathbf { H } _ { . - j } / n - \mathbf { H } _ { . j } ^ { \mathrm { T } } \mathbf { w } / n \cdot \mathbf { H } _ { . - j } ^ { \mathrm { T } } \mathbf { w } / n \big ) \big ) ^ { 2 } , } \end{array}$ $\begin{array} { r } { \mathcal { L } _ { 2 } = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { w } _ { i } ^ { 2 } } \end{array}$ , $\begin{array} { r } { \mathcal { L } _ { 3 } = \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } { \bf w } _ { i } - 1 \big ) ^ { 2 } } \end{array}$ and $\mathcal { F } ( \mathbf { w } ) = \mathcal { L } _ { 1 } + \lambda _ { 1 } \mathcal { L } _ { 1 } + \lambda _ { 2 } \mathcal { L } _ { 2 }$ . We first calculate the Hessian matrix of $\mathcal { F } ( \mathbf { w } )$ , denoted as ${ \bf { H } } _ { e }$ , to prove the uniqueness of the optimal solution $\hat { \mathbf { w } }$ , as follows:
+
+$$
+\mathbf { H } _ { e } = { \frac { \partial ^ { 2 } { \mathcal { L } } _ { 1 } } { \partial \mathbf { w } ^ { 2 } } } + \lambda _ { 1 } { \frac { \partial ^ { 2 } { \mathcal { L } } _ { 2 } } { \partial \mathbf { w } ^ { 2 } } } + \lambda _ { 2 } { \frac { \partial ^ { 2 } { \mathcal { L } } _ { 3 } } { \partial \mathbf { w } ^ { 2 } } }
+$$
+
+For the term $\mathcal { L } _ { 1 }$ , we can rewrite it as:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { 1 } = \displaystyle \sum _ { j \neq k } \alpha _ { i } ^ { 2 } \alpha _ { k } ^ { 2 } \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { H } _ { i , j } \mathbf { H } _ { i , k } \mathbf { w } _ { i } - \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { H } _ { i , j } \mathbf { w } _ { i } \big ) \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { H } _ { i , k } \mathbf { w } _ { i } \big ) \big ) ^ { 2 } } \\ & { \quad = \displaystyle \sum _ { j \neq k } \alpha _ { i } ^ { 2 } \alpha _ { k } ^ { 2 } \big ( \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { H } _ { i , j } \mathbf { H } _ { i , k } \mathbf { w } _ { i } \big ) ^ { 2 } - ( \frac { 2 } { n } \sum _ { i = 1 } ^ { n } \mathbf { H } _ { i , j } \mathbf { H } _ { i , k } \mathbf { w } _ { i } ) \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { H } _ { i , j } \mathbf { w } _ { i } \big ) \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { H } _ { i , k } \mathbf { w } _ { i } \big ) } \\ & { \quad \quad + \big ( \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { H } _ { i , j } \mathbf { w } _ { i } \big ) \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { H } _ { i , k } \mathbf { w } _ { i } \big ) \big ) ^ { 2 } \big ) } \end{array}
+$$
+
+And when $\begin{array} { r l r } { | { \bf { H } } _ { i , j } | } & { { } \le } & { c , } \end{array}$ , for any variable $j$ and $k$ , and $\begin{array} { r l r } { | \mathbf { w } _ { i } | } & { { } \le } & { c . } \end{array}$ , we have $\begin{array} { r l r } { \frac { \partial ^ { 2 } } { \partial { \bf w } ^ { 2 } } ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } { \bf H } _ { i , j } { \bf H } _ { i , k } { \bf w } _ { i } ) ^ { 2 } } & { = } & { \mathcal { O } ( \frac { 1 } { n ^ { 2 } } ) } \end{array}$ , $\begin{array} { r l r } { \frac { \partial ^ { 2 } } { \partial { \bf w } ^ { 2 } } \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } { \bf H } _ { i , j } { \bf w } _ { i } \big ) \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } { \bf H } _ { i , k } { \bf w } _ { i } \big ) } & { = } & { \mathcal { O } \big ( \frac { 1 } { n ^ { 2 } } \big ) } \end{array}$ and $\begin{array} { r } { \frac { \partial ^ { 2 } } { | { \bf { w } } ^ { 2 } | } \big ( \big ( \frac { 2 } { n } \sum _ { i = 1 } ^ { n } { \bf { H } } _ { i , j } { \bf { H } } _ { i , k } { \bf { w } } _ { i } \big ) \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } { \bf { H } } _ { i , j } { \bf { w } } _ { i } \big ) \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } { \bf { H } } _ { i , k } { \bf { w } } _ { i } \big ) \big ) \ = \ { \mathcal O } \big ( \frac { 1 } { n ^ { 2 } } \big ) . } \end{array}$ Then with 2 $| \alpha _ { i } | \ \leq \ c .$ we hav $\begin{array} { r } { \alpha _ { i } ^ { 2 } \alpha _ { k } ^ { 2 } \frac { \partial ^ { 2 } } { \partial { \bf w } ^ { 2 } } \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } { \bf H } _ { i , j } { \bf H } _ { i , k } { \bf w } _ { i } - \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } { \bf H } _ { i , j } { \bf w } _ { i } \big ) \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } { \bf H } _ { i , k } { \bf w } _ { i } \big ) \big ) ^ { 2 } \ = \ \mathcal { O } \big ( \frac { 1 } { n ^ { 2 } } \big ) . } \end{array}$ $\mathcal { L } _ { 1 }$ is $p ( p - 1 )$ such terms. Then we have
+
+$$
+\frac { \partial ^ { 2 } \mathcal { L } _ { 1 } } { \partial \mathbf { w } ^ { 2 } } = \mathcal { O } ( \frac { p ^ { 2 } } { n ^ { 2 } } ) .
+$$
+
+With some algebras, we can also have
+
+$$
+\frac { \partial ^ { 2 } \mathcal { L } _ { 2 } } { \partial \mathbf { w } ^ { 2 } } = \frac { 1 } { n } \mathbf { I } ,
+$$
+
+$$
+\frac { \partial ^ { 2 } \mathcal { L } _ { 3 } } { \partial \mathbf { w } ^ { 2 } } = \frac { 1 } { n ^ { 2 } } \mathbf { 1 1 } ^ { \mathrm { T } } ,
+$$
+
+thus,
+
+$$
+{ \mathbf H } _ { e } = \mathcal { O } ( \frac { p ^ { 2 } } { n ^ { 2 } } ) + \frac { \lambda _ { 1 } } { n } { \mathbf I } + \frac { \lambda _ { 2 } } { n ^ { 2 } } { \mathbf 1 } { \mathbf I } ^ { \mathrm { T } } = \frac { \lambda _ { 1 } } { n } { \mathbf I } + \mathcal { O } ( \frac { p ^ { 2 } + \lambda _ { 2 } } { n ^ { 2 } } ) .
+$$
+
+Therefore, if $\begin{array} { r } { \frac { \lambda _ { 1 } } { n } \gg \frac { p ^ { 2 } + \lambda _ { 2 } } { n ^ { 2 } } } \end{array}$ , equivalent to $\lambda _ { 1 } n \gg p ^ { 2 } + \lambda _ { 2 }$ , ${ \bf { H } } _ { e }$ is an almost diagonal matrix. Hence, $\mathbf { H } _ { e }$ is positive definite (Nakatsukasa, 2010). Then the function $\mathcal { F } ( \mathbf { w } )$ is convex on $\mathcal { C } = \left\{ \mathbf { w } : \left| \mathbf { w } _ { i } \right| \leq c \right\}$ , and has unique optimal solution $\hat { \mathbf { w } }$ .
+
+over,and use . O $\mathcal { L } _ { 1 }$ is our ma, we have e hop, and $\mathcal { L } _ { 1 }$ $\lambda _ { 1 } \mathcal { L } _ { 2 }$ $\lambda _ { 2 } { \mathcal { L } } _ { 3 }$ $\mathcal { C }$ $\mathcal { L } _ { 1 } ~ = ~ \mathcal { O } ( 1 ) , \mathcal { L } _ { 2 } ~ = ~ \mathcal { O } ( 1 )$ $\begin{array} { r } { \alpha _ { i } ^ { 2 } \alpha _ { k } ^ { 2 } ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } { \bf H } _ { i , j } { \bf H } _ { i , k } { \bf w } _ { i } - } \end{array}$ $\begin{array} { r } { \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { H } _ { i , j } \mathbf { w } _ { i } \big ) \big ( \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbf { H } _ { i , k } \mathbf { w } _ { i } \big ) \big ) ^ { 2 } \ = \ \mathcal { O } ( 1 ) } \end{array}$ . Thus ${ \mathcal { L } } _ { 1 } = { \mathcal { O } } ( p ^ { 2 } )$ . When $p ^ { 2 } \gg \operatorname* { m a x } ( \lambda _ { 1 } , \lambda _ { 2 } )$ , $\mathcal { L } _ { 1 }$ will dominate the regularization terms $\mathcal { L } _ { 2 }$ and $\mathcal { L } _ { 3 }$ .
+
+# C PROOF OF THEOREM 3
+
+Let $\mathbf { Z } = \{ \mathbf { Z } _ { 1 } , \mathbf { Z } _ { 2 } , \cdots , \mathbf { Z } _ { p } \}$ be $p$ pairwise uncorrelated variables. $\forall \mathbf { Z } _ { i } , \mathbf { Z } _ { j } \in \mathbf { Z } , ( \mathbf { Z } _ { i } ^ { ( 1 ) } , \mathbf { Z } _ { i } ^ { ( 2 ) } , \cdots , \mathbf { Z } _ { i } ^ { ( n ) } )$ and $( \mathbf { Z } _ { j } ^ { ( 1 ) } , \mathbf { Z } _ { j } ^ { ( 2 ) } , \cdots , \mathbf { Z } _ { j } ^ { ( n ) } )$ are $n$ simple random samples drawn from $\mathbf { Z } _ { i }$ and $\mathbf { Z } _ { j }$ respectively, and have let same distribution with $\begin{array} { r } { \mathbf { Y } _ { i } ^ { ( s ) } = \sum _ { k = 1 } ^ { n } a _ { s k } \mathbf { Z } _ { i } ^ { ( k ) } } \end{array}$ $\mathbf { Z } _ { i }$ and and $\mathbf { Z } _ { j }$ $\begin{array} { r } { \dot { \mathbf { Y } } _ { j } ^ { ( v ) } = \sum _ { l = 1 } ^ { n } a _ { v l } \mathbf { Z } _ { j } ^ { ( l ) } } \end{array}$ . Given a linear aggregation matrix ij    , and we have following derivation: $\hat { \mathbf { A } } = ( a _ { i j } ) , \forall s , v \in ( 1 , 2 , \cdots , n )$ ,
+
+$$
+\begin{array} { l } { { \displaystyle { \bf C o v } ( { \bf Y } _ { i } ^ { ( s ) } , { \bf Y } _ { j } ^ { ( v ) } ) = { \bf C o v } ( \sum _ { k = 1 } ^ { n } a _ { s k } { \bf Z } _ { i } ^ { ( k ) } , \sum _ { l = 1 } ^ { n } a _ { v l } { \bf Z } _ { j } ^ { ( l ) } ) } \ ~ } \\  { \displaystyle ~ = \sum _ { k = 1 } ^ { n } \sum _ { l = 1 } ^ { n } a _ { s k } a _ { v l } { \bf C o v } ( { \bf Z } _ { i } ^ { ( k ) } , { \bf Z } _ { j } ^ { ( l ) } ) = \sum _ { k = 1 } ^ { n } \sum _ { l = 1 } ^ { n } a _ { s k } a _ { v l } \delta _ { i j } , } \end{array}
+$$
+
+where $\delta _ { i j } = 0$ when $i \neq j$ , otherwise $\delta _ { i j } = 1$ . Therefore, when $i \neq j$ , we have $\mathrm { C o v } ( \mathbf { Y } _ { i } ^ { ( s ) } , \mathbf { Y } _ { j } ^ { ( v ) } ) = 0$ and $\mathrm { C o v } ( \mathbf { Y } _ { i } , \mathbf { Y } _ { j } ) = 0$ . Extended the conclusion to multiple variable, $\mathbf { Y } = ( \mathbf { Y } _ { 1 } , \mathbf { Y } _ { 2 } , \cdots , \mathbf { Y } _ { n } )$ are pairwise uncorrelated. Proof completes.
+
+# D PSEUDOCODE OF GNN-DVD
+
+# Algorithm 1: GNN-DVD Algorithm
+
+Input :Training graph $\mathcal { G } _ { t r a i n } = \{ \mathbf { A } , \mathbf { X } , \mathbf { Y } \}$ , and indices of labeled nodes $\mathcal { { V } } _ { L }$ ; Max iteration:maxIter   
+Output :GNN parameter $\theta$ and sample weights w   
+Initialization : Let $\mathbf { w } = { \boldsymbol { \omega } } \odot { \boldsymbol { \omega } }$ and initialize sample weights $\omega$ with 1; Initialize GNN’s parameters $\theta$ with random uniform distribution; Iteration $t \gets 0$
+
+1 while not converged or t < maxIter do
+
+2 Optimize ${ \boldsymbol { \theta } } ^ { ( t ) }$ to minimize $\mathcal { L } _ { G }$ ;   
+3 Calculate variable weights α(t) from W(K−1);   
+4 Optimize ω(t) to minimize $\mathcal { L } _ { D V D } ( \tilde { \mathbf { H } } ^ { ( K - 1 ) } )$ ;   
+5 $t = t + 1$ ;   
+6 end   
+7 Return: $\theta$ and $\mathbf { w } = { \boldsymbol { \omega } } \odot { \boldsymbol { \omega } }$
+
+To optimize our GNN-DVD algorithm, we propose an iterative method. Firstly, we let $\mathbf { w } = { \boldsymbol { \omega } } \odot { \boldsymbol { \omega } }$ to ensure non-negativity of w and initialize sample weight $\omega _ { i } = 1$ for each sample $i$ and GNN’s parameters $\theta$ with random uniform distribution. Once the initial values are given, in each iteration, we fix the sample weights $\omega$ and update the GNN’s parameters $\theta$ by $\mathcal { L } _ { G }$ with gradient descent, then compute the confounder weights $\alpha$ from the linear transform matrix $\mathbf { W } ^ { ( K - 1 ) }$ . With $\alpha$ and fixing the GNN’s parameters $\theta$ , we update the sample weights $\omega$ with gradient descent to minimize $\mathcal { L } _ { D V D } ( \mathbf { H } ^ { ( K - 1 ) } )$ . We iteratively update the sample weights w and GNN’s parameters $\theta$ until $\mathcal { L } _ { G }$ converges.
+
+Complexity Analysis Compared with base model (e.g., GCN and GAT), the mainly incremental time cost is the complexity from DVD term. The complexity of DVD term is $\mathcal { O } ( { n p } ^ { 2 } )$ , where $n$ is the number of labeled nodes and $p$ is the dimension of embedding. And it is quite smaller than the base model (e.g., the complexity of GCN is linear to the number of edges).
+
+# E DATASET DESCRIPTION AND EXPERIMENTAL SETUP
+
+# E.1 DATASET DESCRIPTION
+
+Table 3: Dataset statistics   
+
+<table><tr><td>Dataset</td><td>Type</td><td>Nodes</td><td>Edges</td><td>Classes</td><td>Features</td><td>Bias degree (c)</td><td>Bias type</td></tr><tr><td>Cora</td><td>Citation network</td><td>2,708</td><td>5,429</td><td>7</td><td>1,433</td><td>0.7/0.8/0.9</td><td>Label selection bias</td></tr><tr><td>Citeseer</td><td>Citation network</td><td>3,327</td><td>4,732</td><td>6</td><td>3,703</td><td>0.7/0.8/0.9</td><td>Label selection bias</td></tr><tr><td>Pubmed</td><td>Citation network</td><td>19,717</td><td>44,338</td><td>3</td><td>500</td><td>0.7/0.8/0.9</td><td>Label selection bias</td></tr><tr><td>NELL</td><td>Knowledge graph</td><td>65,755</td><td>266,144</td><td>210</td><td>5,414</td><td>One labeled node per class</td><td>Small sample selection bias</td></tr></table>
+
+Some statistics of datasets used in our paper are presented in Table 3, including the number of nodes, the number of edges, the number of classes, the number of features, the bias degree $\epsilon$ and bias type. For three citation networks, we conduct the biased labeled node selection process to get three degrees of datasets for each dataset to validate the effect of label selection bias, in which each class in each dataset contains 20 labeled nodes in training set and the validation set and test set are same as Yang et al. (2016). For NELL, because it only has a single labeled node per class in training set, the training nodes are hard to cover all the neighborhood distribution happened in the test set. Hence, we use this dataset to validate the effectiveness of our method on the extreme small labeled nodes size bias. The data splits are also same as Yang et al. (2016). A description of each of dataset is given as follows:
+
+• Cora (Sen et al., 2008) is a citation network of Machine Learning papers that collected from 7 classes:{Theory, Case Based, Reinforcement Learning, Genetic Algorithms, Neural Networks, Probabilistic Methods, Rule Learning }. Nodes represent papers, edges refer to the citation relationship, and features are bag-of-words vectors for each paper.   
+• Citeseer (Sen et al., 2008) is a citation network of Machine Learning papers that collected from 6 classes:{Agents, Artificial Intelligence, Database, Information Retrieval, Machine Learning, Human Computer Interaction }. Nodes represent papers, edges refer to the citation relationship, and features are bag-of-words vectors for each paper.   
+• Pubmed (Sen et al., 2008) is a citation network from the PubMed database, which contains a set of articles (Nodes) related to diabetes and the citation relationship among them. The node features are bag-of-words vectors, and the node label are the diabetes type researched in the articles.   
+• NELL Carlson et al. (2010) is a dataset extracted from the knowledge graph, which is a set of entities connected with directed, labeled edges (relations). Our pre-processing scheme is same as Yang et al. (2016), where each entity pair $( e _ { 1 } , r , e _ { 2 } )$ is assigned with separate relation nodes $r _ { 1 }$ and $r _ { 2 }$ as $( e _ { 1 } , r _ { 1 } )$ and $( e _ { 2 } , r _ { 2 } )$ . We use text bag-of-words representation as feature vector of the entities.
+
+# E.2 EXPERIMENTAL SETUP
+
+As the Section 2.1 has described, for all datasets, to simulate the agnostic selection bias scenario, we first follow the inductive setting in $\mathbf { W } \mathbf { u }$ et al. (2019) that masks the validation and test nodes in the training phase and validation and test with whole graph so that the test nodes will be agnostic. For GCN and GAT, we utilize the same two-layer architecture as their original paper (Kipf & Welling, 2016; Velickovi ˇ c et al., 2017). We use the following sets of hyperparameters for GCN on Cora, ´
+
+Citeseer, Pubmed: 0.5 (dropout rate), $5 \cdot { 1 0 } ^ { - 4 }$ (L2 regularization) and 32 (numbder of hidden units); and for NELL: 0.1 (dropout rate), $1 \cdot { 1 0 } ^ { - 5 }$ (L2 regularization) and 64 (number of hidden units). For GAT on Cora, Citeseer, we use: 8 (first layer attention heads), 8 (features each head), 1 (second layer attention head), 0.6 (dropout), 0.0005 (L2 regularization); and for Pubmed: 8 (second layer attention head), 0.001 (L2 regularization), other parameters are same with Cora and Citeseer. To fair comparison, the GNN part of our model uses the same architecture and hyper-parameters with base model and we grid search $\lambda _ { 1 }$ and $\lambda _ { 2 }$ from $\{ 0 . 0 1 , 0 . 1 , 1 , 1 0 , 1 0 0 \}$ . For other baselines, we use the optimal hyper-parameters in literatures on each dataset. For all the experiments, we run 10 times with different random seed and report its average Accuracy results.
+
+# F EXTEND TO GAT
+
+We can easily incorporate VD/DVD term to other GNNs. We combine them with GAT and more extensions leave as future work. GAT utilizes attention mechanism to aggregate neighbor information. It also follows the linear aggregation and transformation steps. Similar with GCN, the hidden embedding H˜ (K−1) is the input of VD/DVD term, and the variable weights $\alpha$ are calculated from the transformation matrix W(K−1) and the sample weights w are used to reweight the softmax loss. Note that original paper utilizes same transformation matrix $\mathbf { W } ^ { ( K - 1 ) }$ for transforming embedding and learning attention values. Because $\alpha$ means the importance of each variable for classification, and it should be computed from transformation matrix $\mathbf { W } ^ { ( K - 1 ) }$ for transforming embedding, hence we use separate matrix for transforming embedding and learning attention values respectively. This modification does not change the performance of GAT in experiments.
+
+# G ADDITIONAL EXPERIMENTS
+
+# G.1 SAMPLE WEIGHT ANALYSIS
+
+Here we analyze the effect of sample weights w in our model. We compute the amount of correlation in the labeled nodes’ embeddings $\mathbf { \tilde { H } } ^ { ( K - 1 ) }$ learned by standard GCN and the weighted embeddings of the same layer learned by GCN-DVD. Note that, the weights are the last iteration of sample weights of GCN-DVD. Following Cogswell et al. (2016), the amount of correlation of GCN and GCN-DVD are measured by Frobenius norm of cross-corvairance matrix computed from vectors of H˜ (K−1) and weighted H˜ (K−1) respectively. Figure 3 shows the amount of correlation in unweighted and weight embeddings, and we can observe that the embeddings’ correlation in all datasets are reduced, demonstrating that the weights learned by GCN-DVD can reduce the correlations between embedded variables. Moreover, one can observe that it is hard to reduce the correlation to zero. Therefore, the necessity of differentiating variables’ weights will be further validated.
+
+![](images/8e7055d175306162e2607ddcd6ee3fbbedece52cfd2ee7cae1e90a0986af1d96.jpg)  
+Figure 3: Embedding correlation analysis on unweighted and weighted GCN.
+
+# G.2 PARAMETER SENSITIVITY
+
+We study the sensitiveness of parameters and report the results of GCN-DVD on three citation networks in Fig. 4-6. The experimental results show that GCN-DVD is relatively stable to $\lambda _ { 1 }$ and $\lambda _ { 2 }$ with wide ranges in most cases, indicating the robustness of our model.
+
+![](images/ec4f4214181ae77906f6c57ce25ec97965756b749b1f354f67c72acac74a9615.jpg)  
+Figure 4: Accuracy of GCN-DVD with different $\lambda _ { 1 }$ and $\lambda _ { 2 }$ on different biased Cora datasets.
+
+![](images/ef61ad7e39197cfe972a9d8237a8e08f0b7d1ae0941fc39cd7b5b546f26b6f6d.jpg)  
+Figure 5: Accuracy of GCN-DVD with different $\lambda _ { 1 }$ and $\lambda _ { 2 }$ on different biased Citeseer datasets.
+
+![](images/85b635f4a2413fad559b29c5bc2963f2340c3deb1225507dfa476f16a6e95ec4.jpg)  
+Figure 6: Accuracy of GCN-DVD with different $\lambda _ { 1 }$ and $\lambda _ { 2 }$ on different biased Pubmed datasets.