Add files using upload-large-folder tool

parse/train/9xC2tWEwBD/9xC2tWEwBD.md

@@ -0,0 +1,327 @@
+# A PANDA? NO, IT’S A SLOTH: SLOWDOWN ATTACKS ON ADAPTIVE MULTI-EXIT NEURAL NETWORK INFERENCE
+
+Sanghyun Hong∗, Yigitcan Kaya ˇ ∗, Ionut,-Vlad Modoranu†, Tudor Dumitras,
+
+University of Maryland, College Park, USA †Alexandru Ioan Cuza University, Ias,i, Romania
+
+shhong@cs.umd.edu, yigitcan@cs.umd.edu, modoranu.ionut.vlad@hotmail.com, tudor@umd.edu
+
+# ABSTRACT
+
+Recent increases in the computational demands of deep neural networks (DNNs), combined with the observation that most input samples require only simple models, have sparked interest in input-adaptive multi-exit architectures, such as MSDNets or Shallow-Deep Networks. These architectures enable faster inferences and could bring DNNs to low-power devices, e.g., in the Internet of Things (IoT). However, it is unknown if the computational savings provided by this approach are robust against adversarial pressure. In particular, an adversary may aim to slowdown adaptive DNNs by increasing their average inference time—a threat analogous to the denial-of-service attacks from the Internet. In this paper, we conduct a systematic evaluation of this threat by experimenting with three generic multi-exit DNNs (based on VGG16, MobileNet, and ResNet56) and a custom multi-exit architecture, on two popular image classification benchmarks (CIFAR-10 and Tiny ImageNet). To this end, we show that adversarial example-crafting techniques can be modified to cause slowdown, and we propose a metric for comparing their impact on different architectures. We show that a slowdown attack reduces the efficacy of multi-exit DNNs by $9 0 { - } 1 0 0 \%$ , and it amplifies the latency by $1 . 5 – 5 \times$ in a typical IoT deployment. We also show that it is possible to craft universal, reusable perturbations and that the attack can be effective in realistic black-box scenarios, where the attacker has limited knowledge about the victim. Finally, we show that adversarial training provides limited protection against slowdowns. These results suggest that further research is needed for defending multi-exit architectures against this emerging threat. Our code is available at https://github.com/sanghyun-hong/deepsloth.
+
+# 1 INTRODUCTION
+
+The inference-time computational demands of deep neural networks (DNNs) are increasing, owing to the “going deeper" (Szegedy et al., 2015) strategy for improving accuracy: as a DNN gets deeper, it progressively gains the ability to learn higher-level, complex representations. This strategy has enabled breakthroughs in many tasks, such as image classification (Krizhevsky et al., 2012) or speech recognition (Hinton et al., 2012), at the price of costly inferences. For instance, with $4 \times$ more inference cost, a 56-layer ResNet (He et al., 2016) improved the Top-1 accuracy on ImageNet by $19 \%$ over the 8-layer AlexNet. This trend continued with the 57-layer state-of-the-art EfficientNet (Tan & Le, 2019): it improved the accuracy by $10 \%$ over ResNet, with $9 \times$ costlier inferences.
+
+The accuracy improvements stem from the fact that the deeper networks fix the mistakes of the shallow ones (Huang et al., 2018). This implies that some samples, which are already correctly classified by shallow networks, do not necessitate the extra complexity. This observation has motivated research on input-adaptive mechanisms, in particular, multi-exit architectures (Teerapittayanon et al., 2016; Huang et al., 2018; Kaya et al., 2019; Hu et al., 2020). Multi-exit architectures save computation by making input-specific decisions about bypassing the remaining layers, once the model becomes confident, and are orthogonal to techniques that achieve savings by permanently modifying the model (Li et al., 2016; Banner et al., 2018; Han et al., 2015; Taylor et al., 2018). Figure 1 illustrates how a multi-exit model (Kaya et al., 2019), based on a standard VGG-16 architecture, correctly classifies a selection of test images from ‘Tiny ImageNet’ before the final layer. We see that more typical samples, which have more supporting examples in the training set, require less depth and, therefore, less computation.
+
+It is unknown if the computational savings provided by multi-exit architectures are robust against adversarial pressure. Prior research showed that DNNs are vulnerable to a wide range of attacks, which involve imperceptible input perturbations (Szegedy et al., 2014; Goodfellow et al., 2015; Papernot et al., 2016; Hu et al., 2020). Considering that a multi-exit model, on the worst-case input, does not provide any computational savings, we ask: Can the savings from multi-exit models be maliciously negated by input perturbations? As some natural inputs do require the full depth of the model, it may be possible to craft adversarial examples that delay the correct decision; it is unclear, however, how many inputs can be delayed with imperceptible perturbations. Furthermore, it is unknown if universal versions of these adversarial examples exist, if the examples transfer across multi-exit architectures and datasets, or if existing defenses (e.g. adversarial training) are effective against slowdown attacks.
+
+![](images/746d8efde4dde3f7f81419a6f62cb228c7561c4c925bbdc393202621421b32de.jpg)  
+Figure 1: Simple to complex inputs. Some Tiny ImageNet images a VGG-16 model can correctly classify if computation stops at the $1 ^ { s t }$ , $5 ^ { t h }$ , and $1 4 ^ { t h }$ layers.
+
+Threat Model. We consider a new threat against DNNs, analogous to the denial-of-service $( D o S )$ attacks that have been plaguing the Internet for decades. By imperceptibly perturbing the input to trigger this worst-case, the adversary aims to slow down the inferences and increase the cost of using the DNN. This is an important threat for many practical applications, which impose strict limits on the responsiveness and resource usage of DNN models (e.g. in the Internet-of-Things (Taylor et al., 2018)), because the adversary could push the victim outside these limits. For example, against a commercial image classification system, such as Clarifai.com, a slowdown attack might waste valuable computational resources. Against a model partitioning scheme, such as Big-Little (De Coninck et al., 2015), it might introduce network latency by forcing excessive transmissions between local and remote models. A slowdown attack aims to force the victim to do more work than the adversary, e.g. by amplifying the latency needed to process the sample or by crafting reusable perturbations. The adversary may have to achieve this with incomplete information about the multi-exit architecture targeted, the training data used by the victim or the classification task (see discussion in Appendix A).
+
+Our Contributions. To our best knowledge, we conduct the first study of the robustness of multi-exit architectures against adversarial slowdowns. To this end, we find that examples crafted by prior evasion attacks (Madry et al., 2017; Hu et al., 2020) fail to bypass the victim model’s early exits, and we show that an adversary can adapt such attacks to the goal of model slowdown by modifying its objective function. We call the resulting attack DeepSloth. We also propose an efficacy metric for comparing slowdowns across different multi-exit architectures. We experiment with three generic multi-exit DNNs (based on VGG16, ResNet56 and MobileNet) (Kaya et al., 2019) and a speciallydesigned multi-exit architecture, MSDNets (Huang et al., 2018), on two popular image classification benchmarks (CIFAR-10 and Tiny ImageNet). We find that DeepSloth reduces the efficacy of multiexit DNNs by $9 0 { - } 1 0 0 \%$ , i.e., the perturbations render nearly all early exits ineffective. In a scenario typical for IoT deployments, where the model is partitioned between edge devices and the cloud, our attack amplifies the latency by $1 . 5 – 5 \times$ , negating the benefits of model partitioning. We also show that it is possible to craft a universal DeepSloth perturbation, which can slow down the model on either all or a class of inputs. While more constrained, this attack still reduces the efficacy by $5- 4 5 \%$ . Further, we observe that DeepSloth can be effective in some black-box scenarios, where the attacker has limited knowledge about the victim. Finally, we show that a standard defense against adversarial samples—adversarial training—is inadequate against slowdowns. Our results suggest that further research will be required for protecting multi-exit architectures against this emerging security threat.
+
+# 2 RELATED WORK
+
+Adversarial Examples and Defenses. Prior work on adversarial examples has shown that DNNs are vulnerable to test-time input perturbations (Szegedy et al., 2014; Goodfellow et al., 2015; Papernot et al., 2017; Carlini & Wagner, 2017; Madry et al., 2018). An adversary who wants to maximize a model’s error on specific test-time samples can introduce human-imperceptible perturbations to these samples. Moreover, an adversary can also exploit a surrogate model for launching the attack and still hurt an unknown victim (Athalye et al., 2018; Tramèr et al., 2017b; Inkawhich et al., 2019). This transferability leads to adversarial examples in more practical black-box scenarios. Although many defenses (Kurakin et al., 2016; Xu et al., 2017; Song et al., 2018; Liao et al., 2018; Lecuyer et al., 2019) have been proposed against this threat, adversarial training (AT) has become the frontrunner (Madry et al., 2018). In Sec 5, we evaluate the vulnerability of multi-exit DNNs to adversarial slowdowns in white-box and black-box scenarios. In Sec 6, we show that standard AT and its simple adaptation to our perturbations are not sufficient for preventing slowdown attacks.
+
+Efficient Input-Adaptive Inference. Recent input-adaptive DNN architectures have brought two seemingly distant goals closer: achieving both high predictive quality and computational efficiency. There are two types of input-adaptive DNNs: adaptive neural networks (AdNNs) and multi-exit architectures. During the inference, AdNNs (Wang et al., 2018; Figurnov et al., 2017) dynamically skip a certain part of the model to reduce the number of computations. This mechanism can be used only for ResNet-based architectures as they facilitate skipping within a network. On the other hand, multi-exit architectures (Teerapittayanon et al., 2016; Huang et al., 2018; Kaya et al., 2019) introduce multiple side branches—or early-exits—to a model. During the inference on an input sample, these models can preemptively stop the computation altogether once the stopping criteria are met at one of the branches. Kaya et al. (2019) have also identified that standard, non-adaptive DNNs are susceptible to overthinking, i.e., their inability to stop computation leads to inefficient inferences on many inputs.
+
+Haque et al. (2020) presented attacks specifically designed for reducing the energy-efficiency of AdNNs by using adversarial input perturbations. However, our work studies a new threat model that an adversary causes slowdowns on multi-exit architectures. By imperceptibly perturbing the inputs, our attacker can (i) introduce network latency to an infrastructure that utilizes multi-exit architectures and (ii) waste the victim’s computational resources. To quantify this vulnerability, we define a new metric to measure the impact of adversarial input perturbation on different multi-exit architectures (Sec 3). In Sec 5, we also study practical attack scenarios and the transferability of adversarial input perturbations crafted by our attacker. Moreover, we discuss the potential defense mechanisms against this vulnerability, by proposing a simple adaptation of adversarial training (Sec 6). To the best of our knowledge, our work is the first systematic study of this new vulnerability.
+
+Model Partitioning. Model partitioning has been proposed to bring DNNs to resource-constrained devices (De Coninck et al., 2015; Taylor et al., 2018). These schemes split a multi-exit model into sequential components and deploy them in separate endpoints, e.g., a small, local on-device part and a large, cloud-based part. For bringing DNNs to the Internet of Things (IoT), partitioning is instrumental as it reduces the transmissions between endpoints, a major bottleneck. In Sec 5.1, on a partitioning scenario, we show that our attack can force excessive transmissions.
+
+# 3 EXPERIMENTAL SETUP
+
+Datasets. We use two datasets: CIFAR-10 (Krizhevsky et al., 2009) and Tiny-ImageNet (Tiny). For testing the cross-domain transferability of our attacks, we use the CIFAR-100 dataset.
+
+Architectures and Hyper-parameters. To demonstrate that the vulnerability to adversarial slowdowns is common among multi-exit architectures, we experiment on two recent techniques: ShallowDeep Networks (SDNs) (Kaya et al., 2019) and MSDNets (Huang et al., 2018). These architectures were designed for different purposes: SDNs are generic and can convert any DNN into a multi-exit model, and MSDNets are custom designed for efficiency. We evaluate an MSDNet architecture (6 exits) and three SDN architectures, based on VGG-16 (Simonyan & Zisserman, 2014) (14 exits), ResNet-56 (He et al., 2016) (27 exits), and MobileNet (Howard et al., 2017) (14 exits).
+
+Metrics. We define the early-exit capability (EEC) curve of a multi-exit model to indicate the fraction of the test samples that exit early at a specific fraction of the model’s full inference cost.
+
+Figure 2 shows the EEC curves of our SDNs on Tiny ImageNet, assuming that the computation stops when there is a correct classification at an exit point. For example, VGG-16-based SDN model can correctly classify ${ \sim } 5 0 \%$ of the samples using ${ \sim } 5 0 \%$ of its full cost. Note that this stopping criterion is impractical; in Sec 4, we will discuss the practical ones.
+
+We define the early-exit efficacy, or efficacy in short, to quantify a model’s ability of utilizing its exit points. The efficacy of a multi-exit model is the area under its EEC curve, estimated via the trapezoidal rule. An ideal efficacy for a model is close to 1, when most of the input samples the computation stops very early; models that do not use their early exits have 0 efficacy. A model with low efficacy generally exhibits a higher latency; in a partitioned model, the low efficacy will cause more input transmissions to the cloud, and the latency is further amplified by the network round trips. A multi-exit model’s efficacy and accuracy are dictated by its stopping criteria, which we discuss in the next section. As for the classification performance, we report the Top-1 accuracy on the test data.
+
+![](images/2bf06ae00279a3cedeb142c999740cbd1b60e5613928b8a30f86d951383600a5.jpg)  
+tinyimagenet-vgg16bn(ACC 59.0) resnet56(ACC 53.5) mobilenet(ACC 59.5)   
+Figure 2: The EEC curves. Each curve shows the fraction of test samples a model classifies using a certain fraction of its full inference cost. ‘EFCY’ is short for the model’s efficacy.
+
+# 4 ATTACKING THE MULTI-EXIT ARCHITECTURES
+
+Setting. We consider the supervised classification setting with standard feedforward DNN architectures. A DNN model consists of $N$ blocks, or layers, that process the input sample, $x \in \mathbb { R } ^ { d }$ , from beginning to end and produce a classification. A classification, $F ( x , \theta ) \in \mathbf { \mathbb { R } } ^ { m }$ , is the predicted probability distribution of $x$ belonging to each label $y \in M = \{ 1 , . . . , m \}$ . Here, $\theta$ denotes the tunable parameters, or the weights, of the model. The parameters are learned on a training set $\mathcal { D }$ that contains multiple $( x _ { i } , y _ { i } )$ pairs; where $y _ { i }$ is the ground-truth label of the training sample $x _ { i }$ . We use $\theta _ { i }$ to denote the parameters at and before the $i ^ { t h }$ block; i.e., $\theta _ { i } \subset \theta _ { i + 1 }$ and $\theta _ { N } = \theta$ . Once a model is trained, its performance is then tested on a set of unseen samples, $s$ .
+
+Multi-Exit Architectures. A multi-exit model contains $K$ exit points—internal classifiers—attached to a model’s hidden blocks. We use $F _ { i }$ to denote the $i ^ { t h }$ exit point, which is attached to the $j ^ { t h }$ block. Using the output of the $j ^ { t h } \left( j < N \right)$ block on $x$ , $F _ { i }$ produces an internal classification, i.e., $F _ { i } ( x , \theta _ { j } )$ , which we simply denote as $F _ { i } ( x )$ . In our experiments, we set $K = N$ for SDNs, i.e., one internal classifier at each block and $K = 6$ for MSDNets. Given $F _ { i } ( x )$ , a multi-exit model uses deterministic criteria to decide between forwarding $x$ to compute $F _ { i + 1 } ( x )$ and stopping for taking the early-exit at this block. Bypassing early-exits decreases a network’s efficacy as each additional block increases the inference cost. Note that multi-exit models process each sample individually, not in batches.
+
+Practical Stopping Criteria. Ideally, a multi-exit model stops when it reaches a correct classification at an exit point, i.e., $\begin{array} { r } { \operatorname * { a r g m a x } _ { j \in M } F _ { i } ^ { ( \bar { j } ) } ( x ) = \hat { y } _ { i } = y ; y } \end{array}$ is the ground-truth label. However, for unseen samples, this is impractical as $y$ is unknown. The prior work has proposed two simple strategies to judge whether ${ \hat { y } } _ { i } = y$ : $F _ { i } ( x )$ ’s entropy (Teerapittayanon et al., 2016; Huang et al., 2018) or its confidence (Kaya et al., 2019). Our attack (see Sec 4.3) leverages the fact that a uniform $F _ { i } ( x )$ has both the highest entropy and the lowest confidence. For generality, we experiment with both confidence-based—SDNs—and entropy-based—MSDNets—strategies.
+
+A strategy selects confidence, or entropy, thresholds, $T _ { i }$ , that determine whether the model should take the $\overline { { i } } ^ { t h }$ exit for an input sample. Conservative $T _ { i }$ ’s lead to fewer early exits and the opposite hurts the accuracy as the estimate of whether ${ \hat { y } } _ { i } = y$ becomes unreliable. As utility is a major practical concern, we set $T _ { i }$ ’s for balancing between efficiency and accuracy. On a holdout set, we set the thresholds to maximize a model’s efficacy while keeping its relative accuracy drop (RAD) over its maximum accuracy within $5 \%$ and $15 \%$ . We refer to these two settings as RAD $123 \%$ and RAD ${ < } 1 5 \%$ Table 2 (first segment) shows how accuracy and efficacy change in each setting.
+
+# 4.1 THREAT MODEL
+
+We consider an adversary who aims to decrease the early-exit efficacy of a victim model. The attacker crafts an imperceptible adversarial perturbation, $v \in \mathbb { R } ^ { d }$ that, when added to a test-time sample $x \in S$ , prevents the model from taking early-exits.
+
+Adversary’s Capabilities. The attacker is able to modify the victim’s test-time samples to apply the perturbations, e.g., by compromising a camera that collects the data for inference. To ensure the imperceptibility, we focus on $\ell _ { \infty }$ norm bounded perturbations as they (i) are well are studied; (ii) have successful defenses (Madry et al., 2018); (iii) have prior extension to multi-exit models (Hu et al., 2020); and (iv) are usually the most efficient to craft. We show results on $\ell _ { 2 }$ and $\ell _ { 1 }$ perturbations in Appendix C. In line with the prior work, we bound the perturbations as follows: for CIFAR-10, $\lvert | v \rvert | _ { \infty } \leq \epsilon = 0 . 0 3$ (Madry et al., 2017), $| | v | | _ { 1 } \leq 8$ (Tramèr & Boneh, 2019) and $| | v | | _ { 2 } \leq 0 . 3 5$ (Chen et al., 2017); for Tiny ImageNet, $| | v | | _ { \infty } \leq \epsilon = 0 . 0 3$ (Yang et al., 2019), $| | \boldsymbol { v } | | _ { 1 } \le \mathrm { \dot { 1 6 } }$ and $| | v | | _ { 2 } \leq 0 . 6$
+
+Adversary’s Knowledge. To assess the security vulnerability of multi-exit architectures, we study white-box scenarios, i.e., the attacker knows all the details of the victim model, including its $\mathcal { D }$ and $\theta$ . Further, in Sec 5.2, we study more practical black-box scenarios, i.e., the attacker crafts $v$ on a surrogate model and applies it to an unknown victim model.
+
+Adversary’s Goals. We consider three DeepSloth variants, (i) the standard, (ii) the universal and (iii) the class-universal. The adversary, in (i) crafts a different $v$ for each $x \in S$ ; in (ii) crafts a single $v$ for all $x \in S$ ; in (iii) crafts a single $v$ for a target class $i \in M$ . Further, although the adversary does not explicitly target it; we observe that DeepSloth usually hurts the accuracy. By modifying the objective function we describe in Sec 4.3, we also experiment with DeepSloth variants that can explicitly preserve or hurt the accuracy, in addition to causing slowdowns.
+
+# 4.2 STANDARD ADVERSARIAL ATTACKS DO NOT CAUSE DELAYS
+
+To motivate DeepSloth, we first evaluate whether previous adversarial attacks have any effect on the efficacy of multi-exit models. These attacks add imperceptible perturbations to a victim’s test-time samples to force misclassifications. We experiment with the standard PGD attack (Madry et al., 2017); PGD-avg and PGD-max variants against multi-exit models (Hu et al., 2020) and the Universal Adversarial Perturbation (UAP) attack that crafts a single perturbation for all test samples (MoosaviDezfooli et al., 2017). Table 1 summarizes our findings that these attacks, although they hurt the accuracy, fail to cause any meaningful decrease in efficacy. In many cases, we observe that the attacks actually increase the efficacy. These experiments help us to identify the critical elements of the objective function of an attack that decreases the efficacy.
+
+Table 1: Impact of existing evasion attacks on efficacy. Each entry shows a model’s efficacy (left) and accuracy (right) when subjected to the respective attack. The multi-exit models are trained on CIFAR-10 and use RAD ${ < } 5 \%$ as their early-exit strategy.   
+
+<table><tr><td>NETWORK</td><td>NO ATTACK</td><td>PGD-20</td><td>PGD-20 (AVG.)</td><td>PGD-20 (MAX.)</td><td>UAP</td></tr><tr><td>VGG-16</td><td>0.77 /89%</td><td>0.79 / 29%</td><td>0.85 /10%</td><td>0.81/27%</td><td>0.71/68%</td></tr><tr><td>REsNET-56</td><td>0.52 / 87%</td><td>0.55 / 12%</td><td>0.82/1%</td><td>0.70/ 6%</td><td>0.55 / 44%</td></tr><tr><td>MOBILENET</td><td>0.83/87%</td><td>0.85 /14%</td><td>0.93/ 3%</td><td>0.89 / 12%</td><td>0.77 / 60%</td></tr></table>
+
+# 4.3 THE DEEPSLOTH ATTACK
+
+The Layer-Wise Objective Function. Figure 3 shows that the attacks that only optimize for the final output, e.g., PGD or UAP, do not perturb the model’s earlier layer representations. This does not bypass the early-exits, which makes these attacks ineffective for decreasing the efficacy. Therefore, we modify the objective functions of adversarial example-crafting algorithms to incorporate the outputs of all $F _ { i } | i < K$ . For crafting $\ell _ { \infty }$ , $\ell _ { 2 }$ and $\ell _ { 1 }$ -bounded perturbations, we adapt the PGD (Madry et al., 2017), the DDN (Rony et al., 2019) and the SLIDE algorithms (Tramèr & Boneh, 2019), respectively. Next, we describe how we modify the PGD algorithm—we modify the others similarly:
+
+$$
+v ^ { t + 1 } = \prod _ { | | v | | _ { \infty } < \epsilon } \left( v ^ { t } + \alpha \operatorname { s g n } \left( { \nabla } _ { v } \sum _ { x \in D ^ { \prime } } \sum _ { 0 < i < K } { \mathcal { L } } \left( F _ { i } \left( x + v \right) , \bar { y } \right) \right) \right)
+$$
+
+Here, $t$ is the current attack iteration; $\alpha$ is the step size; $\Pi$ is the projection operator that enforces $| | v | | _ { \infty } < \epsilon$ and $\mathcal { L }$ is the cross-entropy loss function. The selection of $\mathcal { D } ^ { \prime }$ determines the type of the attack. For the standard variant: ${ \mathcal { D } } ^ { \prime } = \{ x \}$ , i.e., a single test-time sample. For the universal variant: $\mathcal { D } ^ { \prime } = \mathcal { D }$ , i.e., the whole training set. For the class-universal variant against the target class $i \in M$ : $\mathcal { D } ^ { \prime } = \{ ( x , y ) \in \mathcal { D } | y = i \}$ , i.e., the training set samples from the $i ^ { t h }$ class. Finally, $\bar { y }$ is the target label distribution our objective pushes $F _ { i } ( x )$ towards. Next, we explain how we select $\bar { y }$ .
+
+Pushing $F _ { i } ( x )$ Towards a Uniform Distribution. Despite including all $F _ { i }$ , attacks such as PGDavg and PGD-max $\mathrm { H u }$ et al., 2020) still fail to decrease efficacy. How these attacks select $\bar { y }$ reflects their goal of causing misclassifications and, therefore, they trigger errors in early-exits, i.e., $\mathrm { a r g m a x } _ { j \in M } \bar { F } _ { i } ^ { ( j ) } ( x ) = \bar { y } \bar { \ne y }$ . However, as the early-exits still have high confidence, or low entropy, the model still stops its computation early. We select $\bar { y }$ as a uniform distribution over the class labels, i.e., $\bar { y } ^ { ( i ) } = 1 / m$ . This ensures that $( x + v )$ bypasses common stopping criteria as a uniform $F _ { i } ( x )$ has both the lowest confidence and the highest entropy.
+
+# 5 EMPIRICAL EVALUATION
+
+Here, we present the results for $\ell _ { \infty }$ DeepSloth against two SDNs—VGG-16 and MobileNet-based— and against the MSDNets. In the Appendix, we report the hyperparameters; the $\ell _ { 1 }$ and $\ell _ { 2 }$ attacks; the results on ResNet-56-based SDNs; the cost of the attacks; and some perturbed samples. Overall, we observe that $\ell _ { \infty }$ -bounded perturbations are more effective for slowdowns. The optimization challenges might explain this, as $\ell _ { 1 }$ and $\ell _ { 2 }$ attacks are usually harder to optimize (Carlini & Wagner, 2017; Tramèr & Boneh, 2019). Unlike objectives for misclassifications, the objective for slowdowns involves multiple loss terms and optimizes over all the output logits.
+
+# 5.1 WHITE-BOX SCENARIOS
+
+Perturbations Eliminate Early-Exits. Table 2 (second segment) shows that the victim models have $\sim 0$ efficacy on the samples perturbed by DeepSloth. Across the board, the attack makes the early-exit completely ineffective and force the victim models to forward all input samples till the end. Further, DeepSloth also drops the victim’s accuracy by $7 5 - 9 9 \%$ , comparable to the PGD attack. These results give an answer to our main research question: the multi-exit mechanisms are vulnerable and their benefits can be maliciously offset by adversarial input perturbations. In particular, as SDN modification mitigates overthinking in standard, non-adaptive DNNs (Kaya et al., 2019), DeepSloth also leads SDN-based models to overthink on almost all samples by forcing extra computations.
+
+Note that crafting a single perturbation requires multiple back-propagations through the model and more floating points operations $( F L O P s )$ than the forward pass. The high cost of crafting, relative to the computational damage to the victim, might make this vulnerability unattractive for the adversary. In the next sections, we highlight scenarios where this vulnerability might lead to practical exploitation. First, we show that in an IoT-like scenarios, the input transmission is a major bottleneck and DeepSloth can exploit it. Second, we evaluate universal DeepSloth attacks that enable the adversary to craft the perturbation only once and reuse it on multiple inputs.
+
+Attacking an IoT Scenario. Many IoT scenarios, e.g., health monitoring for elderly (Park et al., 2017), require collecting data from edge devices and making low-latency inferences on this data. However, complex deep learning models are impractical for low-power edge devices, such as an Arduino, that are common in the IoT scenarios (Chen & Ran, 2019). For example, on standard hardware, an average inference takes MSDNet model on Tiny ImageNet 35M FLOPs and ${ \sim } 1 0 \mathrm { m s }$ .
+
+A potential solution is sending the inputs from the edge to a cloud model, which then returns the prediction. Even in our optimistic estimate with a nearby AWS EC2 instance, this back-and-forth introduces ${ \sim } 1 1 \mathrm { m s }$ latency per inference. Model partitioning alleviates this bottleneck by splitting a multi-exit model into two; deploying the small first part at the edge and the large second part at the cloud (De Coninck et al., 2015). The edge part sends an input only when its prediction does not meet the stopping criteria. For example, the first early-exit of MSDNets sends only $5 \%$ and $67 \%$ of all test samples, on CIFAR-10 and Tiny ImageNet, respectively. This leads to a lower average latency per inference, i.e., from 11ms down to $0 . 5 \mathrm { m s }$ and $7 . 4 \mathrm { m s }$ , respectively.
+
+Table 2: The effectiveness of $\ell _ { \infty }$ DeepSloth. ‘ $\mathrm { 2 A D { < } } 5 , 1 5 \%$ ’ columns list the results in each early-exit setting. Each entry includes the model’s efficacy (left) and accuracy (right). The class-universal attack’s results are an average of 10 classes. ‘TI’: Tiny ImageNet and $\mathbf { \dot { C } } 1 0 ^ { \circ }$ : CIFAR-10.   
+
+<table><tr><td>NETWORK</td><td colspan="2">MSDNET</td><td colspan="2">VGG16</td><td colspan="2">MOBILENET</td></tr><tr><td>SET.</td><td>RAD&lt;5%</td><td>RAD&lt;15%</td><td>RAD&lt;5%</td><td>RAD&lt;15%</td><td>RAD&lt;5%</td><td>RAD&lt;15%</td></tr><tr><td colspan="7">BASELINE (NO ATTACK)</td></tr><tr><td>C10</td><td>0.89 / 85%</td><td>0.89 / 85%</td><td>0.77 /88%</td><td>0.89 / 79%</td><td>0.83 /87%</td><td>0.92 /79%</td></tr><tr><td>TI</td><td>0.64 / 55%</td><td>0.83 /50%</td><td>0.39 /57%</td><td>0.51 / 52%</td><td>0.42 /57%</td><td>0.59 /51%</td></tr><tr><td colspan="7">DEEPSLOTH</td></tr><tr><td>C10</td><td>0.06 / 17%</td><td>0.06 / 17%</td><td>0.01 /13%</td><td>0.04 / 16%</td><td>0.01 /12%</td><td>0.06 /16%</td></tr><tr><td>TI</td><td>0.06 /7%</td><td>0.06 /7%</td><td>0.00 /2%</td><td>0.01/2%</td><td>0.02 / 6%</td><td>0.04 / 6%</td></tr><tr><td colspan="7">UNIVERSAL DEEPSLOTH</td></tr><tr><td>C10</td><td>0.85 / 65%</td><td>0.85 /65%</td><td>0.62 / 65%</td><td>0.86 / 60%</td><td>0.73 / 61%</td><td>0.90 / 59%</td></tr><tr><td>TI</td><td>0.58 / 46%</td><td>0.81 /41%</td><td>0.31 / 47%</td><td>0.44 / 44%</td><td>0.33 / 47%</td><td>0.51 / 43%</td></tr><tr><td colspan="7">CLASS-UNIVERSAL DEEPSLOTH</td></tr><tr><td>C10</td><td>0.82/32%</td><td>0.82 /32%</td><td>0.47 /35%</td><td>0.78 /33%</td><td>0.60 /30%</td><td>0.85 /27%</td></tr><tr><td>TI</td><td>0.41 / 21%</td><td>0.71 /17%</td><td>0.20 /28%</td><td>0.33 /27%</td><td>0.21 /27%</td><td>0.38 /25%</td></tr></table>
+
+The adversary we study uses DeepSloth perturbations to force the edge part to send all the input samples to the cloud. For the victim, we deploy MSDNet models that we split into two parts at their first exit point. Targeting the first part with DeepSloth forces it to send $96 \%$ and $9 9 . 9 7 \%$ of all test samples to the second part. This increases average inference latency to ${ \sim } 1 1 \mathrm { m s }$ and invalidates the benefits of model partitioning. In this scenario, perturbing each sample takes ${ \sim } 2 \mathrm { m s }$ on a Tesla V-100 GPU, i.e., the time adversary spends is amplified by $1 . 5 – 5 \times$ as the victim’s latency increase.
+
+Reusable Universal Perturbations. The universal attacks, although limited, are a practical as the adversary can reuse the same perturbation indefinitely to cause minor slowdowns. Table 2 (third segment) shows that they decrease the efficacy by $3- 2 1 \%$ and the accuracy by $1 5 \mathrm { - } 2 5 \%$ , over the baselines. Having a less conservative early-exit strategy, e.g., RAD ${ < } 1 5 \%$ , increases the resilience to the attack at the cost of accuracy. Further, MSDNets are fairly resilient with only $3- 9 \%$ efficacy drop; whereas SDNs are more vulnerable with $12 \mathrm { - } 2 1 \%$ drop. The attack is also slightly more effective on the more complex task, Tiny ImageNet, as the early-exits become easier to bypass. Using random noise as a baseline, i.e., $v \sim U ^ { d } ( - \epsilon , \epsilon )$ , we find that at most it decreases the efficacy by ${ \sim } 3 \%$ .
+
+In the universal attack, we observe a phenomenon: it pushes the samples towards a small subset of all classes. For example, ${ \sim } 1 7 \%$ of the perturbed samples are classified into the ’bird’ class of CIFAR-10; up from ${ \sim } 1 0 \%$ for the clean samples. Considering certain classes are distant in the feature space, e.g., ’truck’ and ’bird’; we expect the class-universal variant to be more effective. The results in Table 2 (fourth segment) confirm our intuition. We see that this attack decreases the baseline efficacy by $8 - 5 0 \%$ and the accuracy by $5 0 \mathrm { - } 6 5 \%$ . We report the average results across multiple classes; however, we observe that certain classes are slightly more vulnerable to this attack.
+
+Feature Visualization of DeepSloth. In Figure 3, to shed light on how DeepSloth differs from prior attacks, e.g., PGD and PGD-avg, we visualize a model’s hidden block (layer) features on the original and perturbed test-time samples. We observe that in an earlier block (left panel), DeepSloth seems to disrupt the original features slightly more than the PGD attacks. Leaving earlier representations intact prevents PGDs from bypassing the early-exits. The behaviors of the attacks diverge in the middle blocks (middle panel). Here, DeepSloth features remain closer to the original features than prior attacks. The significant disruption of prior attacks leads to high-confidence misclassifications and fails to bypass early-exits. In the later block (right panel), we see that the divergent behavior persists.
+
+Preserving or Hurting the Accuracy with DeepSloth. Here, we aim to answer whether DeepSloth can be applied when the adversary explicitly aims to cause or prevent misclassifications, while still causing slowdowns. Our main threat model has no explicit goal regarding misclassifications that hurt the user of the model, i.e., who consumes the output of the model. Whereas, slowdowns additionally hurt the executor or the owner of the model through the computations and latency increased at the cloud providers. In some ML-in-the-cloud scenarios, where these two are different actors, the adversary might aim to target only the executor or both the executor and the user. To this end, we modify our objective function to push $F _ { i } ( x )$ towards a slightly non-uniform distribution, favoring either the ground truth label for preventing misclassifications or a wrong label for causing them. We test this idea on our VGG-16-based SDN model on CIFAR-10 in RAD ${ < } 5 \%$ setting. We see that DeepSloth for preserving the accuracy leads to $81 \%$ accuracy with 0.02 efficacy and DeepSloth for hurting the accuracy leads to $4 \%$ accuracy with 0.01 efficacy—the original DeepSloth led to $13 \%$ accuracy with 0.01 efficacy. These results show the flexibility of DeepSloth and how it could be modified depending on the attacker’s goals.
+
+![](images/eb4db376fcea7527d2b8a56c5918847e8a4e1a6ae201be0033e35f93b1112bd1.jpg)  
+Figure 3: Visualising features against attacks using UMAP. VGG-16’s 3rd (left), 8th (middle), and 14th (right) hidden block features on CIFAR-10’s ’dog’ class (Best viewed in color, zoomed in).
+
+5.2 TOWARDS A BLACK-BOX ATTACK: TRANSFERABILITY OF DEEPSLOTH
+
+Transferability of adversarial examples imply that they can still hurt a model that they were not crafted on (Tramèr et al., 2017a; Liu et al., 2017). Even though white-box attacks are important to expose the vulnerability, black-box attacks, by requiring fewer assumptions, are more practical. Here, on four distinct scenarios, we investigate whether DeepSloth is transferable. Based on the scenario’s constraints, we (i) train a surrogate model; (ii) craft the DeepSloth samples on it; and (iii) use these samples on the victim. We run these experiments on CIFAR-10 in the RAD ${ < } 5 \%$ .
+
+Cross-Architecture. First, we relax the assumption that the attacker knows the victim architecture. We evaluate the transferability between a VGG-16-based SDN an an MSDNet—all trained using the same $\mathcal { D }$ . We find that the samples crafted on the MSDNet can slowdown the SDN: reducing its efficacy to 0.63 (from 0.77) and accuracy to $78 \%$ (from $8 8 \%$ ). Interestingly, the opposite seems not to be the case: on the samples crafted against the SDN, the MSDNet still has 0.87 efficacy (from 0.89) and $73 \%$ accuracy (from $8 5 \%$ ). This hints that DeepSloth transfers if the adversary uses an effective multi-exit models as the surrogate.
+
+Limited Training Set Knowledge. Second, we relax the assumption that the attacker knows the victim’s training set, $\mathcal { D }$ . Here, the attacker only knows a random portion of $\mathcal { D }$ , i.e., $10 \%$ , $2 5 \%$ , and $50 \%$ . We use VGG-16 architecture for both the surrogate and victim models. In the $10 \%$ , $2 5 \%$ and $50 \%$ settings, respectively, the attacks reduce the victim’s efficacy to 0.66, 0.5, 0.45 and 0.43 (from 0.77); its accuracy to $81 \%$ , $73 \%$ , $72 \%$ and $74 \%$ (from $8 8 \%$ ). Overall, the more limited the adversary’s $\mathcal { D }$ is, the less generalization ability the surrogate has and the less transferable the attacks are.
+
+Cross-Domain. Third, we relax the assumption that the attacker exactly knows the victim’s task. Here, the attacker uses $\mathcal { D } _ { \boldsymbol { \mathcal { J } } }$ to train the surrogate, different from the victim’s $\mathcal { D }$ altogether. We use a VGG-16 on CIFAR-100 as the surrogate and attack a VGG-16-based victim model on CIFAR-10. This transfer attack reduces the victim’s efficacy to 0.63 (from 0.77) and its accuracy to $83 \%$ (from $8 8 \%$ ). We see that the cross-domain attack might be more effective than the limited $\mathcal { D }$ scenarios. This makes DeepSloth particularly dangerous as the attacker, without knowing the victim’s $\mathcal { D }$ , can collect a similar dataset and still slowdown the victim. We hypothesize the transferability of earlier layer features in CNNs (Yosinski et al., 2014) enables the perturbations attack to transfer from one domain to another, as long as they are similar enough.
+
+Cross-Mechnanism. Finally, we test the scenario where the victim uses a completely different mechanism than a multi-exit architecture to implement input adaptiveness, i.e., SkipNet (Wang et al., 2018). A SkipNet, a modified residual network, selectively skips convolutional blocks based on the activations of the previous layer and, therefore, does not include any internal classifiers. We use a pre-trained SkipNet on CIFAR-10 that reduces the average computation for each input sample by ${ \sim } 5 0 \%$ over an equivalent ResNet and achieves ${ \sim } 9 4 \%$ accuracy. We then feed DeepSloth samples crafted on a MSDNet to this SkipNet, which reduces its average computational saving to ${ \sim } 3 2 \%$ $3 6 \%$ less effective) and its accuracy to $37 \%$ . This result suggests that the two different mechanisms have more in common than previously known and might share the vulnerability. We believe that understanding the underlying mechanisms through which adaptive models save computation is an important research question for future work.
+
+# 6 STANDARD ADVERSARIAL TRAINING IS NOT A COUNTERMEASURE
+
+In this section, we examine whether a defender can adapt a standard countermeasure against adversarial perturbations, adversarial training (AT) (Madry et al., 2018), to mitigate our attack. AT decreases a model’s sensitivity to perturbations that significantly change the model’s outputs. While this scheme is effective against adversarial examples that aim to trigger misclassifications; it is unclear whether using our DeepSloth samples for AT can also robustify a multi-exit model against slowdown attacks.
+
+To evaluate, we train our multi-exit models as follows. We first take a base network—VGG-16—and train it on CIFAR-10 on PGD-10 adversarial examples. We then convert the resulting model into a multi-exit architecture, using the modification from (Kaya et al., 2019). During this conversion, we adversarially train individual exit points using PGD-10, PGD-10 (avg.), PGD-10 (max.), and DeepSloth; similar to (Hu et al., 2020). Finally, we measure the efficacy and accuracy of the trained models against PGD-20, PGD-20 (avg.), PGD-20 (max.), and DeepSloth, on CIFAR-10’s test-set.
+
+Table 3: Evaluating adversarial training against slowdown attacks. Each entry includes the model’s efficacy score (left) and accuracy (right). Results are on CIFAR-10, in the RAD ${ < } 5 \%$ setting.   
+
+<table><tr><td>ADV. TRAINING</td><td>NO ATTACK</td><td>PGD-20</td><td>PGD-20 (AVG.)</td><td>PGD-20 (MAX.)</td><td>DEEPSLOTH</td></tr><tr><td>UNDEFENDED</td><td>0.77 /89%</td><td>0.79/29%</td><td>0.85 /10%</td><td>0.81/27%</td><td>0.01 / 13%</td></tr><tr><td>PGD-10</td><td>0.61/ 72%</td><td>0.55 /38%</td><td>0.64 /23%</td><td>0.58 /29%</td><td>0.33 / 70%</td></tr><tr><td>PGD-10 (AVG.)</td><td>0.53 / 72%</td><td>0.47 / 36%</td><td>0.47 /35%</td><td>0.47 /35%</td><td>0.32 / 70%</td></tr><tr><td>PGD-10 (MAX.)</td><td>0.57 /72%</td><td>0.51/37%</td><td>0.54 / 30%</td><td>0.52 /34%</td><td>0.32 / 70%</td></tr><tr><td>OURS</td><td>0.74/72%</td><td>0.71/38%</td><td>0.82 /14%</td><td>0.77 /21%</td><td>0.44/ 67%</td></tr><tr><td>OURS + PGD-10</td><td>0.61/73%</td><td>0.55 /38%</td><td>0.63 /23%</td><td>0.58 /28%</td><td>0.33 / 70%</td></tr></table>
+
+Our results in Table 3 verify that AT provides resilience against all PGD attacks. Besides, AT provides some resilience to our attack: DeepSloth reduces the efficacy to ${ \sim } 0 . 3 2$ on robust models vs. 0.01 on the undefended one. However, we identify a trade-off between the robustness and efficiency of multi-exits. Compared to the undefended model, on clean samples, we see that robust models have lower efficacy—0.77 vs. $0 . 5 3 \sim 0 . 6 1$ . We observe that the model trained only with our DeepSloth samples (Ours) can recover the efficacy on both the clean and our DeepSloth samples, but this model loses its robustness against PGD attacks. Moreover, when we train a model on both our DeepSloth samples and PGD-10 $\mathrm { \ O u r s } + \mathrm { P G D } { - } 1 0$ ), the trained model suffers from low efficacy. Our results imply that a defender may require an out-of-the-box defense, such as flagging the users whose queries bypass the early-exits more often than clean samples for which the multi-exit network was calibrated.
+
+# 7 CONCLUSIONS
+
+This work exposes the vulnerability of input-adaptive inference mechanisms against adversarial slowdowns. As a vehicle for exploring this vulnerability systematically, we propose DeepSloth, an attack that introduces imperceptible adversarial perturbations to test-time inputs for offsetting the computational benefits of multi-exit inference mechanisms. We show that a white-box attack, which perturbs each sample individually, eliminates any computational savings these mechanisms provide. We also show that it is possible to craft universal slowdown perturbations, which can be reused, and transferable samples, in a black-box setting. Moreover, adversarial training, a standard countermeasure for adversarial perturbations, is not effective against DeepSloth. Our analysis suggests that slowdown attacks are a realistic, yet under-appreciated, threat against adaptive models.
+
+# ACKNOWLEDGMENT
+
+We thank the anonymous reviewers for their feedback. This research was partially supported by the Department of Defense.
+
+# REFERENCES
+
+Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 274–283, Stockholmsmässan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL http: //proceedings.mlr.press/v80/athalye18a.html.
+
+Ron Banner, Itay Hubara, Elad Hoffer, and Daniel Soudry. Scalable methods for 8-bit training of neural networks. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 5145–5153. Curran Associates, Inc., 2018. URL http://papers.nips.cc/paper/ 7761-scalable-methods-for-8-bit-training-of-neural-networks.pdf.
+
+N. Carlini and D. Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy (SP), pp. 39–57, 2017.
+
+Jiasi Chen and Xukan Ran. Deep learning with edge computing: A review. Proceedings of the IEEE, 107(8): 1655–1674, 2019.
+
+Pin-Yu Chen, Yash Sharma, Huan Zhang, Jinfeng Yi, and Cho-Jui Hsieh. Ead: elastic-net attacks to deep neural networks via adversarial examples. arXiv preprint arXiv:1709.04114, 2017.
+
+Elias De Coninck, Tim Verbelen, Bert Vankeirsbilck, Steven Bohez, Pieter Simoens, Piet Demeester, and Bart Dhoedt. Distributed neural networks for internet of things: The big-little approach. In International Internet of Things Summit, pp. 484–492. Springer, 2015.
+
+Michael Figurnov, Maxwell D. Collins, Yukun Zhu, Li Zhang, Jonathan Huang, Dmitry Vetrov, and Ruslan Salakhutdinov. Spatially Adaptive Computation Time for Residual Networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.
+
+Ian Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In International Conference on Learning Representations, 2015. URL http://arxiv.org/abs/1412. 6572.
+
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015.
+
+Mirazul Haque, Anki Chauhan, Cong Liu, and Wei Yang. Ilfo: Adversarial attack on adaptive neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.
+
+K. He, X. Zhang, S. Ren, and J. Sun. Deep Residual Learning for Image Recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 770–778, 2016.
+
+Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal processing magazine, 29(6): 82–97, 2012.
+
+Lu Hou, Zhiqi Huang, Lifeng Shang, Xin Jiang, Xiao Chen, and Qun Liu. DynaBERT: Dynamic BERT with Adaptive Width and Depth. In Advances in Neural Information Processing Systems, 2020.
+
+Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications, 2017.
+
+C. Hu, W. Bao, D. Wang, and F. Liu. Dynamic adaptive dnn surgery for inference acceleration on the edge. In IEEE INFOCOM 2019 - IEEE Conference on Computer Communications, pp. 1423–1431, 2019. doi: 10.1109/INFOCOM.2019.8737614.
+
+Ting-Kuei Hu, Tianlong Chen, Haotao Wang, and Zhangyang Wang. Triple wins: Boosting accuracy, robustness and efficiency together by enabling input-adaptive inference. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\equiv$ rJgzzJHtDB.
+
+Gao Huang, Danlu Chen, Tianhong Li, Felix Wu, Laurens van der Maaten, and Kilian Weinberger. Multiscale dense networks for resource efficient image classification. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $\equiv$ Hk2aImxAb.
+
+Nathan Inkawhich, Wei Wen, Hai (Helen) Li, and Yiran Chen. Feature space perturbations yield more transferable adversarial examples. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.
+
+Weiwen Jiang, Edwin H.-M. Sha, Xinyi Zhang, Lei Yang, Qingfeng Zhuge, Yiyu Shi, and Jingtong Hu. Achieving super-linear speedup across multi-fpga for real-time dnn inference. ACM Trans. Embed. Comput. Syst., 18(5s), October 2019. ISSN 1539-9087. doi: 10.1145/3358192. URL https://doi.org/10.1145/3358192.
+
+Yiping Kang, Johann Hauswald, Cao Gao, Austin Rovinski, Trevor Mudge, Jason Mars, and Lingjia Tang. Neurosurgeon: Collaborative intelligence between the cloud and mobile edge. In Proceedings of the TwentySecond International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS’17, pp. 615–629, New York, NY, USA, 2017. Association for Computing Machinery. ISBN 9781450344654. doi: 10.1145/3037697.3037698. URL https://doi.org/10.1145/3037697. 3037698.
+
+Yigitcan Kaya, Sanghyun Hong, and Tudor Dumitra¸s. Shallow-Deep Networks: Understanding and mitigating ˘ network overthinking. In Proceedings of the 2019 International Conference on Machine Learning (ICML), Long Beach, CA, Jun 2019.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning Multiple Layers of Features from Tiny Images. 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016.
+
+M. Lecuyer, V. Atlidakis, R. Geambasu, D. Hsu, and S. Jana. Certified robustness to adversarial examples with differential privacy. In 2019 IEEE Symposium on Security and Privacy (SP), pp. 656–672, 2019.
+
+En Li, Zhi Zhou, and Xu Chen. Edge intelligence: On-demand deep learning model co-inference with deviceedge synergy. In Proceedings of the 2018 Workshop on Mobile Edge Communications, MECOMM’18, pp. 31–36, New York, NY, USA, 2018. Association for Computing Machinery. ISBN 9781450359061. doi: 10.1145/3229556.3229562. URL https://doi.org/10.1145/3229556.3229562.
+
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. CoRR, abs/1608.08710, 2016. URL http://arxiv.org/abs/1608.08710.
+
+Fangzhou Liao, Ming Liang, Yinpeng Dong, Tianyu Pang, Xiaolin Hu, and Jun Zhu. Defense against adversarial attacks using high-level representation guided denoiser. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017. URL https://openreview. net/forum?id $\equiv$ Sys6GJqxl.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id=rJzIBfZAb.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.
+
+N. Papernot, P. McDaniel, S. Jha, M. Fredrikson, Z. B. Celik, and A. Swami. The limitations of deep learning in adversarial settings. In 2016 IEEE European Symposium on Security and Privacy (EuroS P), pp. 372–387, 2016.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia conference on computer and communications security, pp. 506–519, 2017.
+
+Se Jin Park, Murali Subramaniyam, Seoung Eun Kim, Seunghee Hong, Joo Hyeong Lee, Chan Min Jo, and Youngseob Seo. Development of the elderly healthcare monitoring system with iot. In Advances in Human Factors and Ergonomics in Healthcare, pp. 309–315. Springer, 2017.
+
+Jérôme Rony, Luiz G Hafemann, Luiz S Oliveira, Ismail Ben Ayed, Robert Sabourin, and Eric Granger. Decoupling direction and norm for efficient gradient-based l2 adversarial attacks and defenses. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4322–4330, 2019.
+
+Karen Simonyan and Andrew Zisserman. Very Deep Convolutional Networks for Large-Scale Image Recognition, 2014.
+
+Yang Song, Taesup Kim, Sebastian Nowozin, Stefano Ermon, and Nate Kushman. Pixeldefend: Leveraging generative models to understand and defend against adversarial examples. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $=$ rJUYGxbCW.
+
+C. Szegedy, Wei Liu, Yangqing Jia, P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, and A. Rabinovich. Going deeper with convolutions. In 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1–9, 2015.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In International Conference on Learning Representations, 2014. URL http://arxiv.org/abs/1312.6199.
+
+Mingxing Tan and Quoc Le. EfficientNet: Rethinking model scaling for convolutional neural networks. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 6105–6114, Long Beach, California, USA, 09–15 Jun 2019. PMLR. URL http://proceedings.mlr.press/v97/tan19a. html.
+
+Ben Taylor, Vicent Sanz Marco, Willy Wolff, Yehia Elkhatib, and Zheng Wang. Adaptive deep learning model selection on embedded systems. ACM SIGPLAN Notices, 53(6):31–43, 2018.
+
+S. Teerapittayanon, B. McDanel, and H. T. Kung. Branchynet: Fast inference via early exiting from deep neural networks. In 2016 23rd International Conference on Pattern Recognition (ICPR), pp. 2464–2469, 2016.
+
+Tiny. Tiny ImageNet Visual Recognition Challenge. http://tiny-imagenet.herokuapp.com/. Accessed: 2020-09-28.
+
+Florian Tramèr and Dan Boneh. Adversarial training and robustness for multiple perturbations. In Advances in Neural Information Processing Systems, pp. 5866–5876, 2019.
+
+Florian Tramèr, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick McDaniel. The space of transferable adversarial examples. arXiv preprint arXiv:1704.03453, 2017a.
+
+Florian Tramèr, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick McDaniel. The space of transferable adversarial examples. arXiv preprint arXiv:1704.03453, 2017b.
+
+Xin Wang, Fisher Yu, Zi-Yi Dou, Trevor Darrell, and Joseph E. Gonzalez. SkipNet: Learning Dynamic Routing in Convolutional Networks. In The European Conference on Computer Vision (ECCV), September 2018.
+
+Weilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep neural networks. arXiv preprint arXiv:1704.01155, 2017.
+
+Yuzhe Yang, Guo Zhang, Dina Katabi, and Zhi Xu. Me-net: Towards effective adversarial robustness with matrix estimation. arXiv preprint arXiv:1905.11971, 2019.
+
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Advances in neural information processing systems, pp. 3320–3328, 2014.
+
+Li Zhou, Hao Wen, Radu Teodorescu, and David H.C. Du. Distributing deep neural networks with containerized partitions at the edge. In 2nd USENIX Workshop on Hot Topics in Edge Computing (HotEdge 19), Renton, WA, July 2019. USENIX Association. URL https://www.usenix.org/conference/hotedge19/ presentation/zhou.
+
+Wangchunshu Zhou, Canwen Xu, Tao Ge, Julian McAuley, Ke Xu, and Furu Wei. BERT Loses Patience: Fast and Robust Inference with Early Exit. In Advances in Neural Information Processing Systems, 2020.
+
+# A MOTIVATING EXAMPLES
+
+Here, we discuss two exemplary scenarios where an adversary can exploit the slowdown attacks.
+
+• (Case 1) Attacks on cloud-based IoT applications. In most cases, cloud-based IoT applications, such as Apple Siri, Google Now, or Microsoft Cortana, run their DNN inferences in the cloud. This cloud-only approach puts all the computational burden on cloud servers and increases the communications between the servers and IoT devices. In consequence, recent work (Kang et al., 2017; Li et al., 2018; Zhou et al., 2019) utilizes multi-exit architectures for bringing computationally expensive models, e.g. language models (Zhou et al., 2020; Hou et al., 2020), in the cloud to IoT (or mobile) devices. They split a multi-exit model into two partitions and deploy each of them to a server and IoT devices, respectively. Under this scheme, the cloud server only takes care of complex inputs that the shallow partition cannot correctly classify at the edge. As a result, one can reduce the computations in the cloud and decrease communications between the cloud and edge.
+
+On the other hand, our adversary, by applying human-imperceptible perturbations, can convert simple inputs into complex inputs. These adversarial inputs will bypass early-exits and, as a result, reduce (or even offset) the computational and communication savings provided by prior work.
+
+Here, a defender may deploy DoS defenses such as firewalls or rate-limiting. In this setting, the attacker may not cause DoS because defenses keep the communications between the server and IoT devices under a certain-level. Nevertheless, the attacker still increases: (i) the computations at the edge (by making inputs skip early-exits) and (ii) the number of samples that cloud servers process. Recall that a VGG-16 SDN model classifies $90 \%$ of clean CIFAR-10 instances correctly at the first exit. If the adversarial examples crafted by the attacker bypass only the first exit, one can easily increase the computations on IoT devices and make them send requests to the cloud.
+
+• (Case 2) Attacks on real-time DNN inference for resource- and time-constrained scenarios. Recent work on the real-time systems (Hu et al., 2019; Jiang et al., 2019) harnesses multi-exit architectures and model partitioning as a solution to optimize real-time DNN inference for resourceand time-constrained scenarios. Hu et al. (2019) showed a real-world prototype of an optimal model partitioning, which is based on a self-driving car video dataset, can improve latency and throughput of partitioned models on the cloud and edge by $6 . 5 – 1 4 \times$ , respectively.
+
+However, the prior work does not consider the danger of slowdown attacks; our threat model has not been discussed before in the literature. Our results in Sec 5 suggest that slowdown can be induced adversarially, potentially violating real-time guarantees. For example, our attacker can force partitioned models on the cloud and edge to use maximal computations for inference. Further, the same adversarial examples also require the inference results from the model running on the cloud, which potentially increases the response time of the edge devices by $1 . 5 – 5 \times$ . Our work showed that multi-exit architectures should be used with caution in real-time systems.
+
+# B HYPERPARAMETERS
+
+In our experiments, we use the following hyperparameters to craft adversarial perturbations.
+
+$\ell _ { \infty }$ -based DeepSloth. We find that $\ell _ { \infty }$ -based DeepSloth does not require careful tuning. For the standard attack, we set the total number of iterations to 30 and the step size to $\alpha = 0 . 0 0 2$ . For the modified attacks for hurting or preserving the accuracy, we set the total number of iterations to 75 and the step size to $\alpha = 0 . 0 0 1$ . We compute the standard perturbations using the entire $1 0 \mathrm { k }$ test-set samples in CIFAR-10 and Tiny Imagenet. For the universal variants, we set the total number of iterations to 12 and reduce the initial step size of $\alpha = 0 . 0 0 5$ by a factor of 10 every 4 iterations. To compute a universal perturbation, we use randomly chosen 250 (CIFAR-10) and 200 (Tiny Imagenet) training samples.
+
+$\ell _ { 2 }$ -based DeepSloth. For both the standard and universal attacks, we set the total number of iterations to 550 and the step size $\gamma$ to 0.1. Our initial perturbation has the $\ell _ { 2 }$ -norm of 1.0. Here, we use the same number of samples for crafting the standard and universal perturbations as the $\ell _ { \infty }$ -based attacks.
+
+$\ell _ { 1 }$ -based DeepSloth. For our standard $\ell _ { 1 }$ -based DeepSloth, we set the total number of iterations to 250, the step size $\alpha$ to 0.5, and the gradient sparsity to 99. For the universal variants, we reduce the total number of iterations to 100 and set the gradient sparsity to 90. Other hyperparameters remain the same. We use the same number of samples as the $\ell _ { \infty }$ -based attacks, to craft the perturbations.
+
+# C EMPIRICAL EVALUATION OF $\ell _ { 1 }$ AND $\ell _ { 2 }$ DEEPSLOTH
+
+Table 4 and Table 5 shows the effectiveness of $\ell _ { 1 }$ -based and $\ell _ { 2 }$ -based DeepSloth attacks, respectively.
+
+Table 4: The effectiveness of $\ell _ { 1 }$ DeepSloth. ‘ $R \mathrm { A D } { < } 5 , 1 5 \%$ ’ columns list the results in each early-exit setting. Each entry includes the model’s efficacy score (left) and accuracy (right). The class-universal attack’s results are an average of 10 classes. ‘TI’ is Tiny Imagenet and $\mathbf { \dot { C } } 1 0 ^ { \circ }$ is CIFAR-10.   
+
+<table><tr><td>NETWORK</td><td colspan="2">MSDNET</td><td colspan="2">VGG16</td><td colspan="2">MOBILENET</td></tr><tr><td>SET.</td><td>RAD&lt;5%</td><td>RAD&lt;15%</td><td>RAD&lt;5%</td><td>RAD&lt;15%</td><td>RAD&lt;5%</td><td>RAD&lt;15%</td></tr><tr><td colspan="7">BASELINE (NO ATTACK)</td></tr><tr><td>C10</td><td>0.89 /85%</td><td>0.89 /85%</td><td>0.77 /89%</td><td>0.89 / 79%</td><td>0.83 /87%</td><td>0.92 /79%</td></tr><tr><td>TI</td><td>0.64 / 55%</td><td>0.83 /50%</td><td>0.39 / 57%</td><td>0.51 /52%</td><td>0.42 /57%</td><td>0.59 / 51%</td></tr><tr><td colspan="7">DEEPSLOTH</td></tr><tr><td>C10</td><td>0.36 / 51%</td><td>0.35 / 51%</td><td>0.12 /36%</td><td>0.34 /45%</td><td>0.18 / 41%</td><td>0.49 / 53%</td></tr><tr><td>TI</td><td>0.23 /37%</td><td>0.51 / 40%</td><td>0.08 /22%</td><td>0.15 / 25%</td><td>0.08 /33%</td><td>0.19 /35%</td></tr><tr><td colspan="7">UNIVERSAL DEEPSLOTH</td></tr><tr><td>C10</td><td>0.89 /83%</td><td>0.89 /83%</td><td>0.75 /85%</td><td>0.88 / 75%</td><td>0.82 /85%</td><td>0.92 /77%</td></tr><tr><td>TI</td><td>0.64 / 55%</td><td>0.83/50%</td><td>0.38 /57%</td><td>0.51 / 52%</td><td>0.41 / 57%</td><td>0.59 / 51%</td></tr><tr><td colspan="7">CLASS-UNIVERSAL DEEPSLOTH</td></tr><tr><td>C10</td><td>0.88/ 73%</td><td>0.88 / 73%</td><td>0.69 / 78%</td><td>0.86 /67%</td><td>0.76 /74%</td><td>0.89 / 65%</td></tr><tr><td>TI</td><td>0.64 /54%</td><td>0.83 /49%</td><td>0.39 / 59%</td><td>0.50 / 58%</td><td>0.41 / 60%</td><td>0.58 / 53%</td></tr></table>
+
+Table 5: The effectiveness of $\ell _ { 2 }$ DeepSloth. $\cdot \mathrm { R A D } { < } 5 , 1 5 \%$ ’ columns list the results in each early-exit setting. Each entry includes the model’s efficacy score (left) and accuracy (right). The class-universal attack’s results are an average of 10 classes. ‘TI’ is Tiny Imagenet and $\mathbf { \dot { C } } 1 0 ^ { \circ }$ is CIFAR-10.   
+
+<table><tr><td>NETWORK</td><td colspan="2">MSDNET</td><td colspan="2">VGG16</td><td colspan="2">MOBILENET</td></tr><tr><td>SET.</td><td>RAD&lt;5%</td><td>RAD&lt;15%</td><td>RAD&lt;5%</td><td>RAD&lt;15%</td><td>RAD&lt;5%</td><td>RAD&lt;15%</td></tr><tr><td colspan="7">BASELINE (NO ATTACK)</td></tr><tr><td>C10</td><td>0.89 /85%</td><td>0.89 /85%</td><td>0.77 / 89%</td><td>0.89 / 79%</td><td>0.83 /87%</td><td>0.92 /79%</td></tr><tr><td>TI</td><td>0.64 / 55%</td><td>0.83 / 50%</td><td>0.39 / 57%</td><td>0.51 / 52%</td><td>0.42 /57%</td><td>0.59 / 51%</td></tr><tr><td colspan="7">DEEPSLOTH</td></tr><tr><td>C10</td><td>0.52 / 64%</td><td>0.52 /64%</td><td>0.22 /60%</td><td>0.45 / 62%</td><td>0.23 /46%</td><td>0.48 / 55%</td></tr><tr><td>TI</td><td>0.24 /42%</td><td>0.52 / 44%</td><td>0.13 /35%</td><td>0.21 /36%</td><td>0.12 /38%</td><td>0.25 /40%</td></tr><tr><td colspan="7">UNIVERSAL DEEPSLOTH</td></tr><tr><td>C10</td><td>0.89 /81%</td><td>0.89 /81%</td><td>0.75 /87%</td><td>0.88 / 76%</td><td>0.81/84%</td><td>0.92 /76%</td></tr><tr><td>TI</td><td>0.63 / 54%</td><td>0.82 /48%</td><td>0.38 /56%</td><td>0.51 / 52%</td><td>0.41 / 56%</td><td>0.58 / 51%</td></tr><tr><td colspan="7">CLASS-UNIVERSAL DEEPSLOTH</td></tr><tr><td>C10</td><td>0.88 /73%</td><td>0.88 / 73%</td><td>0.71 /81%</td><td>0.86 / 70%</td><td>0.76 /76%</td><td>0.89 /66%</td></tr><tr><td>TI</td><td>0.64 / 53%</td><td>0.83 /49%</td><td>0.38 /57%</td><td>0.50 / 57%</td><td>0.41 /58%</td><td>0.58 / 53%</td></tr></table>
+
+Our results show that the $\ell _ { 1 } \cdot$ - and $\ell _ { 2 }$ -based attacks are less effective than the $\ell _ { \infty }$ -based attacks. In contrast to the $\ell _ { \infty }$ -based attacks that eliminate the efficacy of victim multi-exit models, the $\ell _ { 1 }$ - and $\ell _ { 2 }$ -based attacks reduce the efficacy of the same models by $0 . 2 4 { \sim } 0 . 6 5$ . Besides, the accuracy drops caused by $\ell _ { 1 } \cdot$ - and $\ell _ { 2 }$ -based attacks are in $6 \sim 2 1 \%$ , smaller than that of $\ell _ { \infty }$ -based DeepSloth $( 7 5 \sim 9 9 \% )$ . Moreover, we see that the universal variants of $\ell _ { 1 }$ - and $\ell _ { 2 }$ -based attacks can barely reduce the efficacy of multi-exit models—they decrease the efficacy up to 0.08 and the accuracy by $12 \%$ .
+
+# D EMPIRICAL EVALUATION OF DEEPSLOTH ON RESNET56
+
+Table 6 shows the the effectiveness of our DeepSloth attacks on ResNet56-base models.
+
+Table 6: The effectiveness of DeepSloth on the ResNet-based models. $\cdot \mathrm { R A D } { < } 5 , 1 5 \%$ ’ columns list the results in each early-exit setting. Each entry includes the model’s efficacy score (left) and accuracy (right). The class-universal attack’s results are an average of 10 classes.   
+
+<table><tr><td>NETWORK</td><td colspan="2">RESNET(lo)</td><td colspan="2">RESNET (l1)</td><td colspan="2">RESNET(2)</td></tr><tr><td>SET.</td><td>RAD&lt;5%</td><td>RAD&lt;15%</td><td>RAD&lt;5%</td><td>RAD&lt;15%</td><td>RAD&lt;5%</td><td>RAD&lt;15%</td></tr><tr><td colspan="7">BASELINE (NO ATTACK)</td></tr><tr><td>C10</td><td>0.52 /87%</td><td>0.69 /80%</td><td>0.52/87%</td><td>0.69 / 80%</td><td>0.51 /87%</td><td>0.69 / 80%</td></tr><tr><td>TI</td><td>0.25 / 51%</td><td>0.39 /46%</td><td>0.25 /51%</td><td>0.39 /46%</td><td>0.25 /51%</td><td>0.39 / 46%</td></tr><tr><td colspan="7">DEEPSLOTH</td></tr><tr><td>C10</td><td>0.00 /19%</td><td>0.01 /19%</td><td>0.05 /43%</td><td>0.18 /47%</td><td>0.06 /45%</td><td>0.17 /48%</td></tr><tr><td>TI</td><td>0.00 /7%</td><td>0.01 / 7%</td><td>0.04 /27%</td><td>0.10 /28%</td><td>0.05 /34%</td><td>0.13 /35%</td></tr><tr><td colspan="7">UNIVERSAL DEEPSLOTH</td></tr><tr><td>C10</td><td>0.35 / 63%</td><td>0.59 /60%</td><td>0.49 /84%</td><td>0.68 /75%</td><td>0.48 /85%</td><td>0.67 /76%</td></tr><tr><td>TI</td><td>0.25 / 25%</td><td>0.34 / 37%</td><td>0.25 / 51%</td><td>0.39 / 46%</td><td>0.25 / 51%</td><td>0.38 /46%</td></tr><tr><td colspan="7">CLASS-UNIVERSAL DEEPSLOTH</td></tr><tr><td>C10</td><td>0.23 / 33%</td><td>0.48 / 29%</td><td>0.39 / 70%</td><td>0.60 / 61%</td><td>0.39 / 71%</td><td>0.60 / 61%</td></tr><tr><td>TI</td><td>0.11 /21%</td><td>0.23 /18%</td><td>0.23 / 51%</td><td>0.36 /46%</td><td>0.23 / 50%</td><td>0.36 /46%</td></tr></table>
+
+Our results show that ResNet56-based models are vulnerable to all the $\ell _ { \infty }$ , $\ell _ { 2 }$ , and $\ell _ { 1 }$ -based DeepSloth attacks. Using our $\ell _ { \infty }$ -based DeepSloth, the attacker can reduce the efficacy of the victim models to $0 . 0 0 { \sim } 0 . 0 1$ and the accuracy by $3 9 \sim 6 8 \%$ . Besides, the $\ell _ { 2 }$ , and $\ell _ { 1 }$ -based attacks also decrease the efficacy to $0 . 0 4 { \sim } 0 . 1 8$ and the accuracy by $1 1 { \sim } 4 4 \%$ . Compared to the results on MSDNet, VGG16, and MobileNet in Table 4 and 5, the same attacks are more effective. The universal variants decrease the efficacy up to 0.21 and the accuracy up to $24 \%$ . In particular, the $\ell _ { 2 }$ , and $\ell _ { 1 }$ -based attacks (on CIFAR-10 models) are effective than the same attacks on MSDNet, VGG16, and MobileNet models.
+
+# E COST OF CRAFTING DEEPSLOTH SAMPLES
+
+In Table 7, we compare the cost of DeepSloth with other attack algorithms on a VGG16-based CIFAR10 model—executed on a single Nvidia Tesla-V100 GPU. For the universal DeepSloth, we measure the execution time for crafting a perturbation using one batch (250 samples) of the training set. For the other attacks, we measure the time for perturbing the whole test set of CIFAR-10. Our DeepSloth takes roughly the same time as the PGD and PGD-avg attacks and significantly less time than the PGD-max attack. Our
+
+<table><tr><td>ATTACKS</td><td>TIME (SEC.)</td></tr><tr><td>PGD-20</td><td>38</td></tr><tr><td>PGD-20 (AVG.)</td><td>48</td></tr><tr><td>PGD-20 (MAX.)</td><td>475</td></tr><tr><td>DEEPSLOTH</td><td>44</td></tr><tr><td>UNIVERSAL DEEPSLOTH</td><td>2</td></tr></table>
+
+Table 7: Time it takes to craft attacks.   
+universal DeepSloth takes only 2 seconds ( $1 0 \mathrm { x }$ faster than DeepSloth) as it only uses 250 samples.
+
+# F ADVERSARIAL EXAMPLES FROM STANDARD ATTACKS AND DEEPSLOTH
+
+In Figure 4, we visualize the adversarial examples from the PGD, UAP and our DeepSloth attacks.
+
+![](images/0bdcaea5dbd66848101c989036785e7979050485b14922c9d380c77e29ee961e.jpg)  
+Figure 4: Adversarial examples from the standard and our DeepSloth attacks. The leftmost column shows the clean images. In the next four columns, we show adversarial examples from PGD, PGD (avg.), PGD (max.), and UAP attacks, respectively. The last four columns include adversarial examples from the three variants of DeepSloth. Each row corresponds to each sample, and the last row contains the average $\ell _ { \mathrm { i n f } }$ -norm of the perturbations over the eight samples in each attack.

parse/train/B1al7jg0b/B1al7jg0b.md

@@ -0,0 +1,279 @@
+# OVERCOMING CATASTROPHIC INTERFERENCE USING CONCEPTOR-AIDED BACKPROPAGATION
+
+Xu He, Herbert Jaeger   
+Department of Computer Science and Electrical Engineering   
+Jacobs University Bremen   
+Bremen, 28759, Germany   
+{x.he,h.jaeger}@jacobs-university.de
+
+# ABSTRACT
+
+Catastrophic interference has been a major roadblock in the research of continual learning. Here we propose a variant of the back-propagation algorithm, “conceptor-aided backprop” (CAB), in which gradients are shielded by conceptors against degradation of previously learned tasks. Conceptors have their origin in reservoir computing, where they have been previously shown to overcome catastrophic forgetting. CAB extends these results to deep feedforward networks. On the disjoint and permuted MNIST tasks, CAB outperforms two other methods for coping with catastrophic interference that have recently been proposed.
+
+# 1 INTRODUCTION
+
+Agents with general artificial intelligence are supposed to learn and perform well on multiple tasks. Continual learning refers to the scenarios where a machine learning system can retain previously acquired skills while learning new ones. However, when trained on a sequence of tasks, neural networks usually forget about previous tasks after their weights are adjusted for a new task. This notorious problem known as catastrophic interference (CI) (McCloskey & Cohen, 1989; Ratcliff, 1990; French, 1999; Kumaran et al., 2016) poses a serious challenge towards continual learning.
+
+Many approaches have been proposed to overcome or mitigate the problem of CI in the last three decades (Hinton & Plaut, 1987; French, 1991; Ans & Rousset, 1997; French, 1997; Srivastava et al., 2014). Especially recently, an avalanche of new methods in the deep learning field has brought about dramatic improvements in continual learning in neural networks. Kirkpatrick et al. (2017) introduced a regularization-based method called elastic weight consolidation (EWC), which uses the posterior distribution of parameters for the old tasks as a prior for the new task. They approximated the posterior by a Gaussian distribution with the parameters for old tasks as the mean and the inverse diagonal of the Fisher information matrix as the variance. Lee et al. (2017) introduced two incremental moment matching (IMM) methods called mean-IMM and mode-IMM. Mean-IMM approximates the distribution of parameters for both old and new tasks by a Gaussian distribution, which is estimated by minimizing its KL-divergence from the mixture of two Gaussian posteriors, one for the old task and the other one for the new task. Mode-IMM estimates the mode of this mixture of two Gaussians and uses it as the optimal parameters for both tasks.
+
+In the field of Reservoir Computing (Jaeger, 2001; Maass et al., 2002), an effective solution to CI using conceptors was proposed by Jaeger (2014) to incrementally train a recurrent neural network to generate spatial-temporal signals. Conceptors are a general-purpose neuro-computational mechanism that can be used in a diversity of neural information processing tasks including temporal pattern classification, one-shot learning, human motion pattern generation, de-noising and signal separation (Jaeger, 2017). In this paper, we adopt and extend the method introduced in Jaeger (2014) and propose a conceptor-aided backpropagation (CAB) algorithm to train feed-forward networks. For each layer of a network, CAB computes a conceptor to characterize the linear subspace spanned by the neural activations in that layer that have appeared in already learned tasks. When the network is trained on a new task, CAB uses the conceptor to adjust the gradients given by backpropagation so that the linear transformation restricted to the characterized subspace will be preserved after the gradient descent procedure. Experiment results of two benchmark tests showed highly competitive performance of CAB.
+
+The rest of this paper is structured as follows. Section 2 introduces conceptors and their application to incremental learning by ridge regression. Section 3 extends the method to stochastic gradient descent and describes the CAB algorithm. Section 4 compares its performance on the permuted and disjoint MNIST tasks to recent methods that address the same problem. Finally we conclude our paper in Section 5.
+
+# 2 INCREMENTAL RIDGE REGRESSION BY CONCEPTORS
+
+This section reviews the basics of conceptor theory and its application to incrementally training linear readouts of recurrent neural networks as used in reservoir computing. A comprehensive treatment can be found in (Jaeger, 2014).
+
+# 2.1 CONCEPTORS
+
+![](images/8cc681eef02ddc59f5850e76547b11fae2efd1c7890b07b3a27fa22575869775.jpg)  
+Figure 1: 3D point clouds (black dots) and their corresponding conceptors, represented by ellipsoids whose axes are the singular vectors of conceptors and the lengths of these axes match the singular values of conceptors. Each edge of the plot boxes range from $- 1$ to $+ 1$ admitted by neural dynamics with a tanh nonlinearity; conceptor ellipsiods lie inside the unit sphere.
+
+In brief, a matrix conceptor $C$ for some vector-valued random variable $\boldsymbol { x } \in \mathbb { R } ^ { N }$ is defined as a linear transformation that minimizes the following loss function.
+
+$$
+\mathbb { E } _ { x } [ | | x - C x | | ^ { 2 } ] + \alpha ^ { - 2 } | | C | | _ { \mathrm { f r o } } ^ { 2 }
+$$
+
+where $\alpha$ is a control parameter called aperture and $| | \cdot | | _ { \mathrm { f r o } }$ is the Frobenius norm. This optimization problem has a closed-form solution
+
+$$
+C = R ( R + \alpha ^ { - 2 } I ) ^ { - 1 }
+$$
+
+where $R = \mathbb { E } _ { x } [ x x ^ { \top } ]$ is the $N \times N$ correlation matrix of $x$ , and $I$ is the $N \times N$ identity matrix. This result given in (2) can be understood by studying the singular value decomposition (SVD) of $C$ . If $R = \bar { U } \Sigma U ^ { \top }$ is the SVD of $R$ , then the SVD of $C$ is given as $U S U ^ { \top }$ , where the singular values $s _ { i }$ of $C$ can be written in terms of the singular values $\sigma _ { i }$ of $R$ : $s _ { i } = \sigma _ { i } / ( \sigma _ { i } + \alpha ^ { - 2 } ) \mathbf { \bar { \Omega } } \in [ 0 , 1 )$ . In intuitive terms, $C$ is a soft projection matrix on the linear subspace where the samples of $x$ lie. For a vector $y$ in this subspace, $C$ acts like the identity: $C y \approx y$ , and when some noise $\epsilon$ orthogonal to the subspace is added to $y$ , $C$ de-noises: $C ( y + \epsilon ) \approx y$ . Figure 1 shows the ellipsoids corresponding to three sets of $\mathbb { R } ^ { 3 }$ points. We define the quota $Q ( C )$ of a conceptor to be the mean singular values: $\begin{array} { r } { Q ( C ) : = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } s _ { i } } \end{array}$ . Intuitively, the quota measures the fraction of the total dimensions of the entire vector space that is claimed by $C$ .
+
+Moreover, logic operations that satisfy most laws of Boolean logic can be defined on matrix conceptors as the following:
+
+$$
+\begin{array} { c } { { \neg C : = I - C , } } \\ { { C ^ { i } \vee C ^ { j } : = ( R ^ { i } + R ^ { j } ) ( R ^ { i } + R ^ { j } + \alpha ^ { - 2 } I ) ^ { - 1 } } } \\ { { C ^ { i } \wedge C ^ { j } : = \neg ( \neg C ^ { i } \vee \neg C ^ { j } ) } } \end{array}
+$$
+
+where $\lnot C$ softly projects onto a linear subspace that can be roughly understood as the orthogonal complement of the subspace characterized by $C$ . $C ^ { i } \vee C ^ { j }$ is the conceptor computed from the union of the two sets of sample points from which $C ^ { i }$ and $C ^ { j }$ are computed. It describes a space that is approximately the sum of linear subspaces characterized by $C ^ { i }$ and $C ^ { j }$ , respectively. The definition of $\bar { C } ^ { i } \wedge C ^ { j }$ reflects de Morgan’s law. Figure 2 illustrates the geometry of these operations.
+
+![](images/ac40caea8a02c56128dcbbb6714517c35c39b998c541267522f8ca3c04099e23.jpg)  
+Figure 2: Geometry of Boolean operations on 2-dimensional conceptors. The OR (resp. AND) operation gives a conceptor whose ellipsoid approximately is the smallest (largest) ellipsoid enclosing (contained in) the argument conceptor’s ellipsoids.
+
+# 2.2 INCREMENTAL RIDGE REGRESSION
+
+This subsection explains how conceptors can be applied to master continual learning in a simple linear model trained on a supervised task by ridge regression. The training is done sequentially on multiple input-to-output mapping tasks. This simplified scenario illustrates the working principle of continual learning with conceptors and will later be used repeatedly as a sub-procedure in the CAB algorithm for training multilayer feed-forward networks.
+
+Consider a sequence of $m$ incoming tasks indexed by $j$ . We denote the training dataset for the $j$ -th task by $\{ ( x _ { 1 } ^ { j } , y _ { 1 } ^ { j } ) , \cdot \cdot \cdot , ( x _ { n } ^ { j } , y _ { n } ^ { j } ) \}$ , where $\boldsymbol { x } _ { i } ^ { j } \in \mathbb { R } ^ { N }$ are input vectors and $y _ { i } ^ { j } \in \mathbb { R } ^ { M }$ their corresponding target outputs. Whenever the training dataset for a new task is available, the incremental learning method will compute a matrix conceptor $C ^ { j }$ for the input variable of the new task using Equation 2 and update the linear model, resulting in a sequence of linear models $W ^ { 1 } , \ldots W ^ { m }$ such that $W ^ { j }$ solves not only the $j$ -th task but also all previous tasks: for $k \leq j , y ^ { k } \approx W ^ { j } x ^ { k }$ . The conceptor $C ^ { j }$ is a soft projection matrix onto the linear subspace spanned by input patterns from the $j$ -th task. Then, $A ^ { j - 1 } \overset { \cdot } { = } \overset { \cdot } { C } ^ { 1 } \vee \cdots \vee C ^ { j - 1 }$ characterizes the memory space already claimed by the tasks $1 , \ldots , j - 1$ and $F ^ { j } = \neg A ^ { j - 1 }$ , the orthogonal complement of $A ^ { j } - 1$ , represents the memory space still free for the $j$ -th task. Here “memory space” refers to the linear space of input vectors. In detail, this method proceeds in the following way:
+
+• Initialization (no task trained yet): $W ^ { 0 } = 0 _ { M \times N } , A ^ { 0 } = 0 _ { N \times N }$ • Incremental task learning: For tasks $j = 1 , \ldots , m$ do:
+
+1. Store the input vectors from the $j$ -th training dataset of size $n$ into a $N \times n$ sized input collection matrix $X ^ { j }$ , and store the output vectors into a $M \times n$ sized output collection matrix $Y ^ { j }$ .
+
+2. Compute the conceptor for this task by $C ^ { j } ~ = ~ R ^ { j } ( R ^ { j } + \alpha ^ { - 2 } I ) ^ { - 1 }$ , where $R ^ { j } \ =$ $\scriptstyle { \frac { 1 } { n } } X ^ { j ^ { \prime } } X ^ { j ^ { \top } }$
+
+3. Train an increment matrix $W _ { i n c } ^ { j }$ (to be added to $W ^ { j - 1 }$ , yielding $W ^ { j }$ ), with the crucial aid of a helper conceptor $F ^ { j }$ :
+
+(a) $F ^ { j } : = \neg A ^ { j - 1 }$ (comment: this conceptor characterizes the “still disposable” memory space for the $j$ -th task),   
+(b) $T : = Y ^ { j } - ( W ^ { j - 1 } X ^ { j } )$ (comment: this matrix consists of target values for a linear regression to compute $W _ { i n c . } ^ { j }$ ),   
+(c) $S : = F ^ { j } X ^ { j }$ (comment: this matrix consists of input arguments for the linear regression),
+
+(d) $W _ { i n c } ^ { j } \ : = \ : ( ( S S ^ { \top } / n + \lambda ^ { - 2 } I ) ^ { - 1 } S T ^ { \top } / n ) ^ { \top }$ (comment: carry out the regression, regularized by $\lambda ^ { - 2 }$ ),
+
+$W ^ { j }$ : $W ^ { j } = W ^ { j - 1 } + W _ { i n c } ^ { j }$
+
+5. Update $A : A ^ { j } = A ^ { j - 1 } \vee C ^ { j }$ (comment: this is possible due to the associativity of the ∨ operation on conceptors)
+
+The weight increment $W _ { i n c } ^ { j }$ does not interfere much with the previously learned weights $W ^ { j - 1 }$ because the regularization in step 3(d) constrains the row space of $W _ { i n c } ^ { j }$ to be only the linear subspace spanned by input arguments defined in 3(c), which are inside the kernel of $W ^ { j - 1 }$ due to the projection by $F ^ { j }$ . Intuitively speaking, when learning a new task, this algorithm exploits only the components of input vectors in the still unused space (kernel of $W ^ { j - 1 }$ , characterized by $F ^ { j }$ ) to compensate errors for the new task and leaves the directions in the already used memory space (row space of $W ^ { j - 1 }$ , characterized by $A ^ { j - 1 }$ ) intact.
+
+# 3 CONCEPTOR-AIDED SGD AND BACK-PROP
+
+In this section, we first derive a stochastic gradient descent version of the algorithm described in the previous section, then present the procedure of CAB.
+
+# 3.1 SGD
+
+In the algorithm introduced in the previous section, $W _ { i n c } ^ { j }$ is computed by ridge regression, which offers a closed-form solution to minimize the following cost function
+
+$$
+\mathcal { I } ( W _ { i n c } ^ { j } ) : = \mathbb { E } [ | W _ { i n c } ^ { j } s - t | ^ { 2 } ] + \lambda ^ { - 2 } | W _ { i n c } ^ { j } | _ { \mathrm { f r o } } ^ { 2 }
+$$
+
+where $t = y ^ { j } - W ^ { j - 1 } x ^ { j } , s = F ^ { j } x ^ { j }$ . One can also minimize this cost function by stochastic gradient descent (SGD), which starts from an initial guess of $W _ { i n c } ^ { j }$ and repeatedly performs the following update
+
+$$
+W _ { i n c } ^ { j }  W _ { i n c } ^ { j } - \eta \nabla _ { W _ { i n c } ^ { j } } \mathcal { I } ( W _ { i n c } ^ { j } )
+$$
+
+where $\eta$ is the learning rate and the gradient is given by:
+
+$$
+\nabla _ { W _ { i n c } ^ { j } } \mathcal { I } ( W _ { i n c } ^ { j } ) = 2 \mathbb { E } [ ( W _ { i n c } ^ { j } s - t ) s ^ { \top } ] + 2 \lambda ^ { - 2 } W _ { i n c } ^ { j }
+$$
+
+Substituting $t$ by $y ^ { j } - W ^ { j - 1 } x ^ { j }$ and $s$ by $F ^ { j } x ^ { j } = ( I - A ^ { j - 1 } ) x ^ { j }$ in (8), we get
+
+$$
+\begin{array} { r l } & { \nabla _ { W _ { i n c } ^ { j } } \mathcal { I } ( W _ { i n c } ^ { j } ) = 2 \mathbb { E } [ ( W _ { i n c } ^ { j } ( I - A ^ { j - 1 } ) x ^ { j } - y ^ { j } + W ^ { j - 1 } x ^ { j } ) s ^ { \top } ] + 2 \lambda ^ { - 2 } W _ { i n c } ^ { j } } \\ & { \phantom { \frac { 1 } { 1 } } = 2 \mathbb { E } [ ( - W _ { i n c } ^ { j } A ^ { j - 1 } x ^ { j } + ( W ^ { j - 1 } + W _ { i n c } ^ { j } ) x ^ { j } - y ^ { j } ) s ^ { \top } ] + 2 \lambda ^ { - 2 } W _ { i n c } ^ { j } } \end{array}
+$$
+
+Due to the regularization term in the cost function, as the optimization goes on, eventually $W _ { i n c }$ will null the input components that are not inside the linear subspace characterized by $F ^ { j }$ , hence $W _ { i n c } ^ { j } A ^ { j - 1 } x ^ { j }$ will converge to 0 as the algorithm proceeds. In addition, since $W ^ { j } = W ^ { j - 1 } + W _ { i n c } ^ { j }$ , (10) can be simplified to
+
+$$
+\nabla _ { { W _ { i n c } ^ { j } } } \mathcal { I } ( W _ { i n c } ^ { j } ) = 2 \mathbb { E } [ ( W ^ { j } x ^ { j } - y ^ { j } ) s ^ { \top } ] + 2 \lambda ^ { - 2 } W _ { i n c } ^ { j }
+$$
+
+Adding $W ^ { j - 1 }$ to both sides of (7), we obtain the update rule for $W ^ { j }$ :
+
+$$
+\begin{array} { r } { W ^ { j }  W ^ { j } - 2 \eta \mathbb { E } [ e s ^ { \top } ] + 2 \eta \lambda ^ { - 2 } W _ { i n c } ^ { j } } \end{array}
+$$
+
+where $e : = W ^ { j } x ^ { j } - y ^ { j }$ . In practice, at every iteration, the expected value can be approximated by a mini-batch of size $n _ { B }$ , indexed by $i _ { B }$ :
+
+$$
+\hat { \mathbb { E } } [ e s ^ { \top } ] = \frac { 1 } { n _ { B } } \sum _ { i _ { B } = 0 } ^ { L } ( W ^ { j } x _ { i _ { B } } ^ { j } - y _ { i _ { B } } ^ { j } ) ( F ^ { j } x _ { i _ { B } } ^ { j } ) ^ { \top } = \frac { 1 } { n _ { B } } \sum _ { i _ { B } = 0 } ^ { L } ( W ^ { j } x _ { i _ { B } } ^ { j } - y _ { i _ { B } } ^ { j } ) x _ { i _ { B } } ^ { j ^ { \top } } F ^ { j ^ { \top } }
+$$
+
+where the transpose for $F ^ { j }$ can be dropped since it is symmetric.
+
+If we only train the $j$ −th task without considering the previous tasks, the update rule given by normal SGD is
+
+$$
+W ^ { j }  W ^ { j } - 2 \eta \mathbb { E } [ e x ^ { j \top } ] + 2 \eta \lambda ^ { - 2 } W ^ { j }
+$$
+
+Comparing this to the update rule in (12), we notice two modifications when a conceptor is adopted to avoid CI: first, the gradient of weights are calculated using the conceptor-projected input vector $s = F ^ { j } x ^ { j }$ instead of the original input vector $x ^ { j }$ ; second, regularization is done on the weight increment $W _ { i n c } ^ { j }$ rather than the final weight $W ^ { j }$ . These two modifications lead to our design of the conceptor-aided algorithm for training multilayer feed-forward networks.
+
+# 3.2 BACKPROP
+
+The basic idea of CAB is to guide the gradients of the loss function on every linear component of the network by a matrix conceptor computed from previous tasks during error back-propagation (Rumelhart et al., 1986), repeatedly applying the conceptor-aided SGD technique introduced in the previous section in every layer.
+
+Consider a feed-forward network with $L + 1$ layers, indexed by $l = 0 , \ldots L$ , such that the 0-th and the $L$ -th layers are the input and output layers respectively. $W ^ { ( l ) }$ represents the linear connections between the $( l - 1 )$ -th and the $l$ -th layer, where we refer to the former as the pre-synaptic layer with respect to $W ^ { ( l ) }$ , and to the latter as the post-synaptic layer. We denote by $N ^ { ( l ) }$ the size of the $l$ -th layer (excluding the bias unit) and $A ^ { ( l ) ^ { j } }$ a conceptor characterizing the memory space in the $l$ -th layer used up by the first $j$ tasks. Let $\sigma ( \cdot )$ be the activation function of the nonlinear neurons and $\theta$ all the parameters of the network to be trained. Then the incremental training method with CAB proceeds as follows:
+
+• Initialization (no task trained yet): $\forall l = 0 , \ldots , L - 1$ , $A ^ { ( l ) ^ { 0 } } : = 0 _ { ( N ^ { ( l ) } + 1 ) \times ( N ^ { ( l ) } + 1 ) }$ , and randomly initialize $W ^ { ( l + 1 ) ^ { 0 } }$ to be a matrix of size $\boldsymbol { N } ^ { ( l + 1 ) } \times \left( \boldsymbol { N } ^ { ( l ) } + 1 \right)$ .
+
+• Incremental task learning: For $j = 1 , \ldots , m$ do:
+
+1. $\forall l = 0 , \ldots , L - 1 , F ^ { ( l ) ^ { j } } = \lnot A ^ { ( l ) ^ { ( j - 1 ) } }$ . (This conceptor characterizes the still disposable vector space in layer l for learning task $j$ )
+
+2. Update the network parameters $\theta ^ { ( j - 1 ) }$ obtained after training the first $j - 1$ tasks to $\theta ^ { j }$ by stochastic gradient descent, where the gradients are computed by CAB instead of the classical backprop. Algorithms 1 and 2 detail the forward and backward pass of CAB, respectively. Different from classical backprop, the gradients are guided by a matrix conceptor $F ^ { ( l ) ^ { j } }$ , such that in each layer only the activity in the still disposable memory space will contribute to the gradient. Note that the conceptors remain the same until convergence of the network for task $j$ .
+
+3. After training on the vectors, indexed by $i _ { B }$ $j$ -th task, run the forward procedure again on a batch of , taken from the $j$ -th training dataset, to collect activations $n _ { B }$ input $h _ { i _ { B } } ^ { ( l ) ^ { j } }$ of each layer into a $N ^ { ( l ) } \times n _ { B }$ sized matrix $H ^ { ( l ) ^ { j } }$ , and set the correlation matrix $\begin{array} { r } { R ^ { ( l ) ^ { j } } = \frac { \dot { 1 } } { n _ { B } } H ^ { ( l ) ^ { j } } ( H ^ { ( l ) ^ { j } } ) ^ { \top } } \end{array}$ .
+
+4. Compute a conceptor on the $l$ -th layer for the $j$ -th pattern by $C ^ { ( l ) ^ { j } } = R ^ { ( l ) ^ { j } } ( R ^ { ( l ) ^ { j } } +$ $\alpha ^ { - 2 } \hat { I } _ { N ^ { ( l ) } \times N ^ { ( l ) } } ) ^ { - 1 } , \forall l = 0 , \dots , L \bar { - } 1$ . Finding an optimal aperture can be done by a cross-validation search1.
+
+5. Update the conceptor for already used space in every layer: $A ^ { ( l ) ^ { j } } ~ = ~ A ^ { ( l ) ^ { j } } ~ \vee$ $C ^ { ( l ) ^ { j } } , \forall l = 0 , \dots , L - 1$ .
+
+Algorithm 1 The forward procedure of conceptor-aided backprop, adapted from the traditional backprop. Input vectors are passed through a feed-forward network to compute the cost function. $\mathcal { L } ( \hat { y } ^ { j } , y ^ { j } )$ denotes the loss for the $j$ -th task, to which a regularizer $\Omega ( \theta _ { i n c } ^ { j } ) = \Omega ( \theta ^ { j } - \theta ^ { j - 1 } ) =$ $| | \theta ^ { j } - \theta ^ { j - 1 } | | _ { \mathrm { f r o } } ^ { 2 }$ is added to obtain the total cost $\mathcal { I }$ , where $\theta$ contains all the weights (biases are considered as weights connected to the bias units). The increment of parameters rather than the parameters themselves are regularized, similar to the conceptor-aided SGD.
+
+Require: Network depth, $l$   
+Require: $W _ { . } ^ { ( l ) ^ { j } } , l \in \bar { \{ 1 , \ldots , L \} }$ , the weight matrices of the network   
+Require: $x ^ { j }$ , one input vector of the $j$ -th task   
+Require: $y ^ { j }$ , the target output for $x ^ { j }$   
+1: $h ^ { ( 0 ) } = x ^ { j }$   
+2: for $l = 1 , \dots L$ do 3: $b ^ { ( l ) } = [ h ^ { ( l - 1 ) \top } , 1 ] ^ { \top }$ , include the bias unit 4: $a ^ { ( l ) } = W ^ { ( l ) ^ { j } } b ^ { ( l ) }$ 5: $h ^ { ( l ) } = \sigma ( a ^ { ( l ) } )$   
+6: end for   
+7: ${ \hat { y } } ^ { j } = h ^ { ( l ) }$   
+8: $\mathcal { I } = \mathcal { L } ( \hat { y } ^ { j } , y ^ { j } ) + \lambda \Omega ( \theta _ { i n c } ^ { j } )$
+
+Algorithm 2 The backward procedure of conceptor-aided backprop for the $j$ -th task, adapted from the traditional backprop. The gradient $g$ of the loss function $\mathcal { L }$ on the activations $a ^ { ( l ) }$ represents the error for the linear transformation $W ^ { ( l ) ^ { j } }$ between the $( l - 1 )$ -th and the l−th layers. In the standard backprop algorithm, the gradient of $\mathcal { L }$ on $W ^ { ( l ) ^ { j } }$ is computed as an outer product of the post-synaptic errors $g$ and the pre-synaptic activities $\boldsymbol { h } ^ { ( l - 1 ) }$ . This resembles the computation of the gradient in the linear SGD algorithm, which motivates us to apply conceptors in a similar fashion as in the conceptor-aided SGD. Specifically, we project the gradient $\nabla _ { W ^ { ( l ) } } j \mathcal { L }$ by the matrix conceptor F (l−1)  that indicates the free memory space on the pre-synaptic layer.
+
+1:
+
+$$
+\boldsymbol { g } \gets \nabla _ { \boldsymbol { \hat { y } } } \mathcal { I } = \nabla _ { \boldsymbol { \hat { y } } } \mathcal { L } ( \boldsymbol { \hat { y } } , \boldsymbol { y } )
+$$
+
+2: for $l = L , L - 1 , \ldots , 1$ do
+
+3: Convert the gradient on the layer’s output into a gradient on the pre-nonlinearity activation ( $\odot$ denotes element-wise multiplication):
+
+$$
+g  \nabla _ { a ^ { ( l ) } } \mathcal { I } = g \odot \sigma ^ { \prime } ( a ^ { ( l ) } )
+$$
+
+4: Compute the gradient of weights, project it by $F ^ { ( l - 1 ) ^ { j } }$ , and add it to the regularization term on the increment:
+
+$$
+\begin{array} { l } { { \nabla _ { W ^ { ( l ) ^ { j } } } \mathcal { I } = g \big ( F ^ { ( l - 1 ) ^ { j } } b ^ { ( l - 1 ) } \big ) ^ { \top } + \lambda \nabla _ { W ^ { ( l ) ^ { j } } } \Omega \big ( \theta _ { i n c } ^ { j } \big ) = g b ^ { ( l - 1 ) ^ { \top } } F ^ { ( l - 1 ) ^ { j } } + 2 \lambda W _ { i n c } ^ { ( l ) ^ { j } } } } \\ { { \quad \quad = g b ^ { ( l - 1 ) ^ { \top } } F ^ { ( l - 1 ) ^ { j } } + 2 \lambda \big ( W ^ { ( l ) ^ { j } } - W ^ { ( l ) ^ { j - 1 } } \big ) } } \end{array}
+$$
+
+5: Propagate the gradients w.r.t. the next lower-level hidden layers activations:
+
+$$
+g \gets \nabla _ { h ^ { ( l - 1 ) } } \mathcal { I } = W ^ { ( l ) ^ { j } } { } ^ { \top } g
+$$
+
+6: end for
+
+![](images/1eda451ad86ac6f785232ef35b6928bbd7acc61b0179a85d29239e094465def7.jpg)  
+Figure 3: Average performance across already learned permuted MNIST tasks using CAB or EWC
+
+# 4 EXPERIMENTS
+
+# 4.1 PERMUTED MNIST EXPERIMENT
+
+To test the performance of CAB, we evaluated it on the permuted MNIST experiment (Srivastava et al., 2013; Goodfellow et al., 2014; Kirkpatrick et al., 2017; Lee et al., 2017), where a sequence of pattern recognition tasks are created from the MNIST dataset (LeCun et al., 1998). For each task, a random permutation of input image pixels is generated and applied to all images in MNIST to obtain a new shuffled dataset, equally difficult to recognize as the original one, the objective of each task is to recognize these images with shuffled pixels.
+
+For a proof-of-concept demonstration, we trained a simple but sufficient feed-forward network with [784-100-10] of neurons to classify 10 permuted MNIST datasets. The network has logistic sigmoid neurons in both hidden and output layers, and is trained with mean squared error as the cost function. Vanilla SGD was used in all experiments to optimize the cost function. Learning rate and aperture were set to 0.1 and 4, respectively. For comparison, we also tested EWC on the same task with the same network architecture, based on the implementation by Seff (2017). The parameters chosen for the EWC algorithm were 0.01 for the learning rate and 15 for the weight of the Fisher penalty term. Figure 3 shows the performance of CAB on this task, the average testing accuracy is $9 5 . 2 \%$ after learning all 10 tasks sequentially. Although a fair amount of effort was spent on searching for optimal parameters for EWC, the accuracies shown here might still not reflect its best performance. However, the same experiment with EWC was also conducted in Kemker et al. (2017), where the authors reimplemented EWC on a network with higher capacity (2 hidden layers and 400 ReLU neurons per layer) and the resulting average accuracy after learning 10 tasks sequentially was shown to be around $93 \%$ .
+
+Since all tasks are generated by permuting the same dataset, the portion of the input space occupied by each of them should have the same size. However, as more tasks are learned, the chance that the space of a new task will overlap with the already used input space increases. Figure 4 shows the singular value spectra and quota of the input and hidden layer conceptors every time after a new task is learned. As the incremental learning proceeds, it becomes less likely for a new task to be in the free space. For example, the second task increases the quota of the input layer memory space by 0.1, whereas the 10th task increases it by only 0.03. However, CAB still manages to make the network learn new tasks based on their input components in the non-overlapping space.
+
+![](images/53ed68df2db8177a3a69102033ca7c87cdf1a0c0aff09975806a8fe949298c3e.jpg)  
+(b) Singular value spectra of conceptors $A ^ { ( 1 ) ^ { j } }$ on the hidden layer.   
+Figure 4: The development of singular value spectra of conceptors for “used-up” space on the input layer and hidden layer during incremental learning of 10 permuted MNIST tasks. Quota of these conceptors are displayed in the legends.
+
+# 4.2 DISJOINT MNIST EXPERIMENT
+
+We then applied CAB to categorize the disjoint MNIST datasets into 10 classes (Srivastava et al., 2013; Lee et al., 2017). In this experiment, the original MNIST dataset is divided into two disjoint datasets with the first one consisting of data for the first five digits (0 to 4), and the second one of the remaining five digits (5 to 9). This task requires a network to learn these two datasets one after the other, then examines its performance of classifying the entire MNIST testing images into 10 classes. The current state-of-the-art accuracy on this task, averaged over 10 learning trials, is $9 4 . 1 2 ( \pm 0 . 2 7 ) \%$ , achieved by Lee et al. (2017) using IMM. They also tested EWC on the same task and the average accuracy was $5 2 . 7 2 ( \pm 1 . 3 6 ) \%$ .
+
+To test our method, we trained a feed-forward network with [784-800-10] neurons. Logistic sigmoid nonlinearities were used in both hidden and output layers, and the network was trained with vanilla SGD to minimize mean squared errors. The aperture $\alpha = 9$ was used for all conceptors on all layers, learning rate $\eta$ and regularization coefficient $\lambda$ were chosen to be 0.1 and 0.005 respectively. The accuracy of CAB on this task, measured by repeating the experiment 10 times, is $9 4 . 9 1 ( \pm 0 . { \dot { 3 } } 0 ) \%$ . It is worth mentioning that the network used by Lee et al. (2017) for testing IMM and EWC had [784-800-800-10] rectified linear units (ReLU), so CAB achieved better performance with fewer layers and neurons.
+
+# 4.3 COMPUTATIONAL COST
+
+If a conceptor is computed by ridge regression, the time complexity is $O ( n N ^ { 2 } + N ^ { 3 } )$ when the design matrix is dense, where $n$ is the number of samples and $N$ the number of features. In terms of wall time measures, the time taken to compute a conceptor from the entire MNIST training set (in this case, $n = 5 5 0 0 0$ images and $N = 7 8 4$ pixels, corresponding to the input layer in our networks) is 0.42 seconds of standard notebook CPU time on average. Although we did not implement it in these experiments, incremental online adaptation of conceptors by gradient descent is also possible in principle and would come at a cost of $\dot { O ( N ^ { 2 } ) }$ per update.
+
+# 5 CONCLUSION
+
+In this work, we first reviewed the conceptor-based incremental ridge regression algorithm, introduced in section 3.11 of Jaeger (2014) for memory management in recurrent neural networks. Then we derived its stochastic gradient descent version for optimizing the same objective. Finally we designed a conceptor-aided backprop algorithm by applying a conceptor to every linear layer of a feed-forward network. This method uses conceptors to guide gradients of parameters during the backpropagation procedure. As a result, learning a new task interferes only minimally with previously learned tasks, and the amount of already used network capacity can be monitored via the singular value spectra and quota of conceptors.
+
+In Jaeger (2014), different scenarios for continual learning are investigated in a reservoir computing setting. Two extreme cases are obtained when (i) the involved learning tasks are entirely unrelated to each other, versus (ii) all tasks come from the same parametric family of learning tasks. The two cases differ conspicuously with regards to the geometry of involved conceptors, and with regards to opportunities to re-use previously acquired functionality in subsequent learning episodes. The permuted MNIST task is an example of (i) while the disjoint MNIST task rather is of type (ii). Conceptors provide an analytical tool to discuss the “family relatedness” and enabling/disabling conditions for continual learning in geometrical terms. Ongoing and future research is devoted to a comprehensive mathematical analysis of these phenomena which in our view lie at the heart of understanding continual learning.
+
+# ACKNOWLEDGMENTS
+
+The work reported in this article was partly funded through the European H2020 collaborative project NeuRAM3 (grant Nr 687299).
+
+# REFERENCES
+
+Bernard Ans and Stephane Rousset. Avoiding catastrophic forgetting by coupling two reverberating ´ neural networks. Comptes Rendus de l’Academie des Sciences-Series III-Sciences de la Vie ´ , 320 (12):989–997, 1997.
+
+Robert M French. Using semi-distributed representations to overcome catastrophic forgetting in connectionist networks. Proceedings of the 13th Annual Cognitive Science Society Conference, pp. 173178, 1991.
+
+Robert M French. Pseudo-recurrent connectionist networks: An approach to the ‘sensitivitystability’ dilemma. Connection Science, 9(4):353–380, 1997.
+
+Robert M French. Catastrophic forgetting in connectionist networks. Trends in Cognitive Sciences, 3(4):128–135, 1999.
+
+Ian J Goodfellow, Mehdi Mirza, Da Xiao, Aaron Courville, and Yoshua Bengio. An empirical investigation of catastrophic forgetting in gradient-based neural networks. International Conference on Learning Representations, 2014.
+
+Geoffrey E Hinton and David C Plaut. Using fast weights to deblur old memories. In Proceedings of the Ninth Annual Conference of the Cognitive Science Society, pp. 177–186. Lawrence Erlbaum Associates, 1987.
+
+Herbert Jaeger. The echo state approach to analysing and training recurrent neural networks-with an erratum note. German National Research Center for Information Technology GMD Technical Report, 148(34):13, 2001.
+
+Herbert Jaeger. Controlling recurrent neural networks by conceptors. Jacobs University Technical Reports, (31), 2014. https://arxiv.org/abs/1403.3369.
+
+Herbert Jaeger. Using conceptors to manage neural long-term memories for temporal patterns. Journal of Machine Learning Research, 18(13):1–43, 2017. URL http://jmlr.org/papers/ v18/15-449.html.
+
+Ronald Kemker, Angelina Abitino, Marc McClure, and Christopher Kanan. Measuring catastrophic forgetting in neural networks. Computing Research Repository, abs/1708.02072, 2017. http: //arxiv.org/abs/1708.02072.
+
+James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A. Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, Demis Hassabis, Claudia Clopath, Dharshan Kumaran, and Raia Hadsell. Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy of Sciences, 114(13):3521, 2017.
+
+Dharshan Kumaran, Demis Hassabis, and James L McClelland. What learning systems do intelligent agents need? complementary learning systems theory updated. Trends in Cognitive Sciences, 20 (7):512–534, 2016.
+
+Yann LeCun, Corinna Cortes, and Christopher JC Burges. The MNIST database of handwritten digits. 1998. http://yann.lecun.com/exdb/mnist/.
+
+Sang-Woo Lee, Jin-Hwa Kim, JungWoo Ha, and Byoung-Tak Zhang. Overcoming catastrophic forgetting by incremental moment matching. Computing Research Repository, abs/1703.08475, 2017. http://arxiv.org/abs/1703.08475.
+
+Wolfgang Maass, Thomas Natschlager, and Henry Markram. Real-time computing without stable ¨ states: A new framework for neural computation based on perturbations. Neural Computation, 14(11):2531–2560, 2002.
+
+Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. Psychology of Learning and Motivation, 24:109–165, 1989.
+
+Roger Ratcliff. Connectionist models of recognition memory: Constraints imposed by learning and forgetting functions. Psychological Review, 97(2):285–308, 1990.
+
+David E Rumelhart, Geoffrey E Hinton, and Ronald J Williams. Learning representations by backpropagating errors. Nature, 323:533–535, 1986.   
+Ari Seff. Implementation of overcoming catastrophic forgetting in neural networks in tensorflow. GitHub Repository, 2017. https://github.com/ariseff/ overcoming-catastrophic.   
+Rupesh K Srivastava, Jonathan Masci, Sohrob Kazerounian, Faustino Gomez, and Jurgen Schmid- ¨ huber. Compete to compute. In Advances in Neural Information Processing Systems, pp. 2310– 2318, 2013. http://papers.nips.cc/paper/5059-compete-to-compute.pdf.   
+Vipin Srivastava, Suchitra Sampath, and David J Parker. Overcoming catastrophic interference in connectionist networks using Gram-Schmidt orthogonalization. PloS ONE, 9(9):e105619, 2014.

parse/train/B1ewdt9xe/B1ewdt9xe.md

@@ -0,0 +1,301 @@
+# DEEP PREDICTIVE CODING NETWORKS FOR VIDEO PREDICTION AND UNSUPERVISED LEARNING
+
+William Lotter, Gabriel Kreiman & David Cox   
+Harvard University   
+Cambridge, MA 02215, USA   
+{lotter,davidcox}@fas.harvard.edu   
+gabriel.kreiman@tch.harvard.edu
+
+# ABSTRACT
+
+While great strides have been made in using deep learning algorithms to solve supervised learning tasks, the problem of unsupervised learning — leveraging unlabeled examples to learn about the structure of a domain — remains a difficult unsolved challenge. Here, we explore prediction of future frames in a video sequence as an unsupervised learning rule for learning about the structure of the visual world. We describe a predictive neural network (“PredNet”) architecture that is inspired by the concept of “predictive coding” from the neuroscience literature. These networks learn to predict future frames in a video sequence, with each layer in the network making local predictions and only forwarding deviations from those predictions to subsequent network layers. We show that these networks are able to robustly learn to predict the movement of synthetic (rendered) objects, and that in doing so, the networks learn internal representations that are useful for decoding latent object parameters (e.g. pose) that support object recognition with fewer training views. We also show that these networks can scale to complex natural image streams (car-mounted camera videos), capturing key aspects of both egocentric movement and the movement of objects in the visual scene, and the representation learned in this setting is useful for estimating the steering angle. Altogether, these results suggest that prediction represents a powerful framework for unsupervised learning, allowing for implicit learning of object and scene structure.
+
+# 1 INTRODUCTION
+
+Many of the most successful current deep learning architectures for vision rely on supervised learning from large sets of labeled training images. While the performance of these networks is undoubtedly impressive, reliance on such large numbers of training examples limits the utility of deep learning in many domains where such datasets are not available. Furthermore, the need for large numbers of labeled examples stands at odds with human visual learning, where one or a few views of an object is often all that is needed to enable robust recognition of that object across a wide range of different views, lightings and contexts. The development of a representation that facilitates such abilities, especially in an unsupervised way, is a largely unsolved problem.
+
+In addition, while computer vision models are typically trained using static images, in the real world, visual objects are rarely experienced as disjoint snapshots. Instead, the visual world is alive with movement, driven both by self-motion of the viewer and the movement of objects within the scene. Many have suggested that temporal experience with objects as they move and undergo transformations can serve as an important signal for learning about the structure of objects (Foldi ¨ ak, 1991; ´ Softky, 1996; Wiskott & Sejnowski, 2002; George & Hawkins, 2005; Palm, 2012; O’Reilly et al., 2014; Agrawal et al., 2015; Goroshin et al., 2015a; Lotter et al., 2015; Mathieu et al., 2016; Srivastava et al., 2015; Wang & Gupta, 2015; Whitney et al., 2016). For instance, Wiskott and Sejnowski proposed “slow feature analysis” as a framework for exploiting temporal structure in video streams (Wiskott & Sejnowski, 2002). Their approach attempts to build feature representations that extract slowly-varying parameters, such as object identity, from parameters that produce fast changes in the image, such as movement of the object. While approaches that rely on temporal coherence have arguably not yet yielded representations as powerful as those learned by supervised methods, they nonetheless point to the potential of learning useful representations from video (Mohabi et al., 2009; Sun et al., 2014; Goroshin et al., 2015a; Maltoni & Lomonaco, 2015; Wang & Gupta, 2015).
+
+Here, we explore another potential principle for exploiting video for unsupervised learning: prediction of future image frames (Softky, 1996; Palm, 2012; O’Reilly et al., 2014; Goroshin et al., 2015b; Srivastava et al., 2015; Mathieu et al., 2016; Patraucean et al., 2015; Finn et al., 2016; Vondrick et al., 2016). A key insight here is that in order to be able to predict how the visual world will change over time, an agent must have at least some implicit model of object structure and the possible transformations objects can undergo. To this end, we have designed a neural network architecture, which we informally call a “PredNet,” that attempts to continually predict the appearance of future video frames, using a deep, recurrent convolutional network with both bottom-up and topdown connections. Our work here builds on previous work in next-frame video prediction (Ranzato et al., 2014; Michalski et al., 2014; Srivastava et al., 2015; Mathieu et al., 2016; Lotter et al., 2015; Patraucean et al., 2015; Oh et al., 2015; Finn et al., 2016; Xue et al., 2016; Vondrick et al., 2016; Brabandere et al., 2016), but we take particular inspiration from the concept of “predictive coding” from the neuroscience literature (Rao & Ballard, 1999; Rao & Sejnowski, 2000; Lee & Mumford, 2003; Friston, 2005; Summerfield et al., 2006; Egner et al., 2010; Bastos et al., 2012; Spratling, 2012; Chalasani & Principe, 2013; Clark, 2013; O’Reilly et al., 2014; Kanai et al., 2015). Predictive coding posits that the brain is continually making predictions of incoming sensory stimuli (Rao & Ballard, 1999; Friston, 2005). Top-down (and perhaps lateral) connections convey these predictions, which are compared against actual observations to generate an error signal. The error signal is then propagated back up the hierarchy, eventually leading to an update of the predictions.
+
+We demonstrate the effectiveness of our model for both synthetic sequences, where we have access to the underlying generative model and can investigate what the model learns, as well as natural videos. Consistent with the idea that prediction requires knowledge of object structure, we find that these networks successfully learn internal representations that are well-suited to subsequent recognition and decoding of latent object parameters (e.g. identity, view, rotation speed, etc.). We also find that our architecture can scale effectively to natural image sequences, by training using car-mounted camera videos. The network is able to successfully learn to predict both the movement of the camera and the movement of objects in the camera’s view. Again supporting the notion of prediction as an unsupervised learning rule, the model’s learned representation in this setting supports decoding of the current steering angle.
+
+![](images/96a1440b9f8c8bf098c1b691d0dce930f9e50a5bd99be7f869e6ae09b81b7762.jpg)  
+Figure 1: Predictive Coding Network (PredNet). Left: Illustration of information flow within two layers. Each layer consists of representation neurons $( R _ { l } )$ , which output a layer-specific prediction at each time step $( \hat { A } _ { l } )$ , which is compared against a target $( A _ { l } )$ (Bengio, 2014) to produce an error term $( E _ { l } )$ , which is then propagated laterally and vertically in the network. Right: Module operations for case of video sequences.
+
+# 2 THE PREDNET MODEL
+
+The PredNet architecture is diagrammed in Figure 1. The network consists of a series of repeating stacked modules that attempt to make local predictions of the input to the module, which is then subtracted from the actual input and passed along to the next layer. Briefly, each module of the network consists of four basic parts: an input convolutional layer $( A _ { l } )$ , a recurrent representation layer $( R _ { l } )$ , a prediction layer $( \hat { \hat { A } } _ { l } )$ , and an error representation $( E _ { l } )$ . The representation layer, $R _ { l }$ , is a recurrent convolutional network that generates a prediction, $\hat { A } _ { l }$ , of what the layer input, $A _ { l }$ , will be on the next frame. The network takes the difference between $A _ { l }$ and $\hat { A } _ { l }$ and outputs an error representation, $E _ { l }$ , which is split into separate rectified positive and negative error populations. The error, $E _ { l }$ , is then passed forward through a convolutional layer to become the input to the next layer $( A _ { l + 1 } )$ . The recurrent prediction layer $R _ { l }$ receives a copy of the error signal $E _ { l }$ , along with top-down input from the representation layer of the next level of the network $( R _ { l + 1 } )$ . The organization of the network is such that on the first time step of operation, the “right” side of the network ( $A _ { l }$ ’s and $E _ { l }$ ’s) is equivalent to a standard deep convolutional network. Meanwhile, the “left” side of the network (the $R _ { l }$ ’s) is equivalent to a generative deconvolutional network with local recurrence at each stage. The architecture described here is inspired by that originally proposed by (Rao & Ballard, 1999), but is formulated in a modern deep learning framework and trained end-to-end using gradient descent, with a loss function implicitly embedded in the network as the firing rates of the error neurons. Our work also shares motivation with the Deep Predictive Coding Networks of Chalasani & Principe (2013); however, their framework is based upon sparse coding and a linear dynamical system with greedy layer-wise training, whereas ours is rooted in convolutional and recurrent neural networks trained with backprop.
+
+While the architecture is general with respect to the kinds of data it models, here we focus on image sequence (video) data. Consider a sequence of images, $x _ { t }$ . The target for the lowest layer is set to the the actual sequence itself, i.e. $\bar { A } _ { 0 } ^ { t } = x _ { t } \forall t$ . The targets for higher layers, $A _ { l } ^ { t }$ for $l > 0$ , are computed by a convolution over the error units from the layer below, $E _ { l - 1 } ^ { t }$ , followed by rectified linear unit (ReLU) activation and max-pooling. For the representation neurons, we specifically use convolutional LSTM units (Hochreiter & Schmidhuber, 1997; Shi et al., 2015). In our setting, the $R _ { l } ^ { t }$ hidden state is updated according to $R _ { l } ^ { t - 1 }$ , $E _ { l } ^ { t - 1 }$ , as well as $R _ { l + 1 } ^ { t }$ , which is first spatially upsampled (nearest-neighbor), due to the pooling present in the feedforward path. The predictions, $\hat { A } _ { l } ^ { t }$ are made through a convolution of the $R _ { l } ^ { t }$ stack followed by a ReLU non-linearity. For the lowest layer, $\hat { A } _ { l } ^ { t }$ is also passed through a saturating non-linearity set at the maximum pixel value: $\operatorname { S a t L U } ( x ; p _ { m a x } ) : = \operatorname* { m i n } ( p _ { m a x } , x )$ . Finally, the error response, $E _ { l } ^ { t }$ , is calculated from the difference between $\hat { A } _ { l } ^ { t }$ and $A _ { l } ^ { t }$ and is split into ReLU-activated positive and negative prediction errors, which are concatenated along the feature dimension. As discussed in (Rao & Ballard, 1999), although not explicit in their model, the separate error populations are analogous to the existence of on-center, off-surround and off-center, on-surround neurons early in the visual system.
+
+The full set of update rules are listed in Equations (1) to (4). The model is trained to minimize the weighted sum of the activity of the error units. Explicitly, the training loss is formalized in Equation 5 with weighting factors by time, $\lambda _ { t }$ , and layer, $\lambda _ { l }$ , and where $n _ { l }$ is the number of units in the lth layer. With error units consisting of subtraction followed by ReLU activation, the loss at each layer is equivalent to an L1 error. Although not explored here, other error unit implementations, potentially even probabilistic or adversarial (Goodfellow et al., 2014), could also be used.
+
+$$
+\begin{array} { r l } & { A _ { l } ^ { t } = \bigg \{ x _ { t } } & { \mathrm { i f } l = 0 } \\ & { \mathbf { M } _ { \mathrm { A X P o o L } } ( \operatorname { R E L U } ( \operatorname { C o N v } ( E _ { l - 1 } ^ { t } ) ) ) } & { l > 0 } \\ & { \hat { A } _ { l } ^ { t } = \operatorname { R E L U } ( \operatorname { C o N v } ( R _ { l } ^ { t } ) ) } \\ & { E _ { l } ^ { t } = [ \operatorname { R E L U } ( A _ { l } ^ { t } - \hat { A } _ { l } ^ { t } ) ; \operatorname { R E L U } ( \hat { A } _ { l } ^ { t } - A _ { l } ^ { t } ) ] } \\ & { R _ { l } ^ { t } = \operatorname { C o N v L S T M } ( E _ { l } ^ { t - 1 } , R _ { l } ^ { t - 1 } , \operatorname { U P S A M P L E } ( R _ { l + 1 } ^ { t } ) ) } \end{array}
+$$
+
+$$
+L _ { t r a i n } = \sum _ { t } \lambda _ { t } \sum _ { l } \frac { \lambda _ { l } } { n _ { l } } \sum _ { n _ { l } } E _ { l } ^ { t }
+$$
+
+# Algorithm 1 Calculation of PredNet states
+
+<table><tr><td>Require: Xt</td><td></td></tr><tr><td>1:A←xt 2:</td><td>E,R←0</td></tr><tr><td>3:</td><td>fort=1 to Tdo</td></tr><tr><td>4:</td><td>for l = L to O do</td></tr><tr><td>5:</td><td>if l=L then</td></tr><tr><td>6:</td><td>Rt =CONVLSTM(Et-1,Rt-1)</td></tr><tr><td>7:</td><td>else</td></tr><tr><td>8:</td><td>Rt = CONVLSTM(E𝑡-1,Rt-1,UPSAMPLE(Rt+1))</td></tr><tr><td>9:</td><td>for l= O to L do</td></tr><tr><td>10:</td><td>if l= O then</td></tr><tr><td>11:</td><td>At = SATLU(RELU(CONV(Rδ)))</td></tr><tr><td>12:</td><td>else</td></tr><tr><td>13:</td><td>At = RELU(CoNv(Rt))</td></tr><tr><td>14:</td><td>Et = [RELU(At - At); RELU(At - A)]</td></tr><tr><td>15:</td><td>ifl&lt;L then</td></tr><tr><td>16:</td><td>At+1 = MAXPOOL(CONV(E))</td></tr></table>
+
+The order in which each unit in the model is updated must also be specified, and our implementation is described in Algorithm 1. Updating of states occurs through two passes: a top-down pass where the $R _ { l } ^ { t }$ states are computed, and then a forward pass to calculate the predictions, errors, and higher level targets. A last detail of note is that $R _ { l }$ and $E _ { l }$ are initialized to zero, which, due to the convolutional nature of the network, means that the initial prediction is spatially uniform.
+
+# 3 EXPERIMENTS
+
+# 3.1 RENDERED IMAGE SEQUENCES
+
+To gain an understanding of the representations learned in the proposed framework, we first trained PredNet models using synthetic images, for which we have access to the underlying generative stimulus model and all latent parameters. We created sequences of rendered faces rotating with two degrees of freedom, along the “pan” (out-of-plane) and “roll” (in-plane) axes. The faces start at a random orientation and rotate at a random constant velocity for a total of 10 frames. A different face was sampled for each sequence. The images were processed to be grayscale, with values normalized between 0 and 1, and 64x64 pixels in size. We used 16K sequences for training and 800 for both validation and testing.
+
+Predictions generated by a PredNet model are shown in Figure 2. The model is able to accumulate information over time to make accurate predictions of future frames. Since the representation neurons are initialized to zero, the prediction at the first time step is uniform. On the second time step, with no motion information yet, the prediction is a blurry reconstruction of the first time step. After further iterations, the model adapts to the underlying dynamics to generate predictions that closely match the incoming frame.
+
+For choosing the hyperparameters of the model, we performed a random search and chose the model that had the lowest L1 error in frame prediction averaged over time steps 2-10 on a validation set. Given this selection criteria, the best performing models tended to have a loss solely concentrated at the lowest layer (i.e. $\lambda _ { 0 } = 1$ , $\lambda _ { l > 0 } = 0 $ ), which is the case for the model shown. Using an equal loss at each layer considerably degraded predictions, but enforcing a moderate loss on upper layers that was one magnitude smaller than the lowest layer (i.e. $\lambda _ { 0 } = 1$ , $\lambda _ { l > 0 } = 0 . 1$ ) led to only slightly worse predictions, as illustrated in Figure 9 in the Appendix. In all cases, the time loss weight, $\lambda _ { t }$ , was set to zero for the first time step and then one for all time steps after. As for the remaining hyperparameters, the model shown has 5 layers with 3x3 filter sizes for all convolutions, max-pooling of stride 2, and number of channels per layer, for both $A _ { l }$ and $R _ { l }$ units, of (1, 32, 64, 128, 256). Model weights were optimized using the Adam algorithm (Kingma & Ba, 2014).
+
+![](images/47e158f8ba016838740a961f995997b73a4e432fd723f2faa4ecb1fae041441c.jpg)  
+time   
+Figure 2: PredNet next-frame predictions for sequences of rendered faces rotating with two degrees of freedom. Faces shown were not seen during training.
+
+Quantitative evaluation of generative models is a difficult, unsolved problem (Theis et al., 2016), but here we report prediction error in terms of meansquared error (MSE) and the Structural Similarity Index Measure (SSIM) (Wang et al., 2004). SSIM is designed to be more correlated with perceptual judgments, and ranges from $- 1$ and 1, with a larger score indicating greater similarity. We compare the PredNet to the trivial solution of copying the last frame, as well as a control model that shares the overall architecture and training scheme of the PredNet, but that sends forward the layer-wise activations $( A _ { l } )$ rather than the errors $( E _ { l } )$ . This model thus takes the form of a more traditional encoder-decoder pair, with a CNN encoder that has lateral skip connections to a convolutional LSTM decoder. The performance of all models on the rotating faces dataset is summarized in Table 1, where the scores were calculated as an average over all predictions after the first frame. We report results for the PredNet model trained with loss only on the lowest layer, denoted as PredNet $L _ { 0 }$ , as well as the model trained with an 0.1 weight on upper layers, denoted as PredNet $L _ { a l l }$ . Both PredNet models outperformed the baselines on both measures, with the $L _ { 0 }$ model slightly outperforming $L _ { a l l }$ , as expected for evaluating the pixel-level predictions.
+
+Table 1: Evaluation of next-frame predictions on Rotating Faces Dataset (test set).   
+
+<table><tr><td></td><td>MSE</td><td>SSIM</td></tr><tr><td>PredNet Lo</td><td>0.0152</td><td>0.937</td></tr><tr><td>PredNet Lall</td><td>0.0157</td><td>0.921</td></tr><tr><td>CNN-LSTM Enc.-Dec.</td><td>0.0180</td><td>0.907</td></tr><tr><td>Copy Last Frame</td><td>0.125</td><td>0.631</td></tr></table>
+
+Synthetic sequences were chosen as the initial training set in order to better understand what is learned in different layers of the model, specifically with respect to the underlying generative model (Kulkarni et al., 2015). The rotating faces were generated using the FaceGen software package (Singular Inversions, Inc.), which internally generates 3D face meshes by a principal component analysis in “face space”, derived from a corpus of 3D face scans. Thus, the latent parameters of the image sequences used here consist of the initial pan and roll angles, the pan and roll velocities, and the principal component (PC) values, which control the “identity” of the face. To understand the information contained in the trained models, we decoded the latent parameters from the representation neurons $( R _ { l } )$ in different layers, using a ridge regression. The $R _ { l }$ states were taken at the earliest possible informative time steps, which, in the our notation, are the second and third steps, respectively, for the static and dynamic parameters. The regression was trained using $4 K$ sequences with 500 for validation and $1 K$ for testing. For a baseline comparison of the information implicitly embedded in the network architecture, we compare to the decoding accuracies of an untrained network with random initial weights. Note that in this randomly initialized case, we still expect above-chance decoding performance, given past theoretical and empirical work with random networks (Pinto et al., 2009; Jarrett et al., 2009; Saxe et al., 2010).
+
+Latent variable decoding accuracies of the pan and roll velocities, pan initial angle, and first PC are shown in the left panel of Figure 3. There are several interesting patterns. First, the trained models learn a representation that generally permits a better linear decoding of the underlying latent factors than the randomly initialized model, with the most striking difference in terms of the the pan rotation speed $( \alpha _ { p a n } )$ . Second, the most notable difference between the $L _ { a l l }$ and $L _ { 0 }$ versions occurs with the first principle component, where the model trained with loss on all layers has a higher decoding accuracy than the model trained with loss only on the lowest layer.
+
+![](images/0abef2797da5fa19f50184da371c6feb85f35b1d2b18d3d978fa3150145a690d.jpg)  
+Figure 3: Information contained in PredNet representation for rotating faces sequences. Left: Decoding of latent variables using a ridge regression $( \alpha _ { p a n }$ : pan (out-of-frame) angular velocity, $\theta _ { p a n }$ : pan angle, PC-1: first principal component of face, $\alpha _ { r o l l }$ : roll (in-frame) angular velocity). Right: Orientation-invariant classification of static faces.
+
+The latent variable decoding analysis suggests that the model learns a representation that may generalize well to other tasks for which it was not explicitly trained. To investigate this further, we assessed the models in a classification task from single, static images. We created a dataset of 25 previously unseen FaceGen faces at 7 pan angles, equally spaced between $[ - \frac { \pi } { 2 } , \frac { \pi } { 2 } ]$ , and 8 roll angles, equally spaced between $[ 0 , 2 \pi )$ . There were therefore orientations per identity, which were tested in a cross-validated fashion. A linear SVM to decode face identity was fit on a model’s representation of a random subset of orientations and then tested on the remaining angles. For each size of the SVM training set, ranging from 1-40 orientations per face, 50 different random splits were generated, with results averaged over the splits.
+
+For the static face classification task, we compare the PredNets to a standard autoencoder and a variant of the Ladder Network (Valpola, 2015; Rasmus et al., 2015). Both models were constructed to have the same number of layers and channel sizes as the PredNets, as well as a similar alternating convolution/max-pooling, then upsampling/convolution scheme. As both networks are autoencoders, they were trained with a reconstruction loss, with a dataset consisting of all of the individual frames from the sequences used to train the PredNets. For the Ladder Network, which is a denoising autoencoder with lateral skip connections, one must also choose a noise parameter, as well as the relative weights of each layer in the total cost. We tested noise levels ranging from 0 to 0.5 in increments of 0.1, with loss weights either evenly distributed across layers, solely concentrated at the pixel layer, or 1 at the bottom layer and 0.1 at upper layers (analogous to the PredNet $L _ { a l l }$ model). Shown is the model that performed best for classification, which consisted of 0.4 noise and only pixel weighting. Lastly, as in our architecture, the Ladder Network has lateral and top-down streams that are combined by a combinator function. Inspired by (Pezeshki et al., 2015), where a learnable MLP improved results, and to be consistent in comparing to the PredNet, we used a purely convolutional combinator. Given the distributed representation in both networks, we decoded from a concatenation of the feature representations at all layers, except the pixel layer. For the PredNets, the representation units were used and features were extracted after processing one input frame.
+
+Face classification accuracies using the representations learned by the $L _ { 0 }$ and $L _ { a l l }$ PredNets, a standard autoencoder, and a Ladder Network variant are shown in the right panel of Figure 3. Both PredNets compare favorably to the other models at all sizes of the training set, suggesting they learn a representation that is relatively tolerant to object transformations. Similar to the decoding accuracy of the first principle component, the PredNet $L _ { a l l }$ model actually outperformed the $L _ { 0 }$ variant. Altogether, these results suggest that predictive training with the PredNet can be a viable alternative to other models trained with a more traditional reconstructive or denoising loss, and that the relative layer loss weightings $( \lambda _ { l } ^ { } \mathbf { \dot { s } } )$ may be important for the particular task at hand.
+
+# 3.2 NATURAL IMAGE SEQUENCES
+
+We next sought to test the PredNet architecture on complex, real-world sequences. As a testbed, we chose car-mounted camera videos, since these videos span across a wide range of settings and are characterized by rich temporal dynamics, including both self-motion of the vehicle and the motion of other objects in the scene (Agrawal et al., 2015). Models were trained using the raw videos from the KITTI dataset (Geiger et al., 2013), which were captured by a roof-mounted camera on a car driving around an urban environment in Germany. Sequences of 10 frames were sampled from the “City”, “Residential”, and “Road” categories, with 57 recording sessions used for training and 4 used for validation. Frames were center-cropped and downsampled to 128x160 pixels. In total, the training set consisted of roughly 41K frames.
+
+A random hyperparameter search, with model selection based on the validation set, resulted in a 4 layer model with 3x3 convolutions and layer channel sizes of (3, 48, 96, 192). Models were again trained with Adam (Kingma & Ba, 2014) using a loss either solely computed on the lowest layer $( L _ { 0 } )$ or with a weight of 1 on the lowest layer and 0.1 on the upper layers $( L _ { a l l } )$ . Adam parameters were initially set to their default values $\mathbf { \Phi } _ { \mathrm { { ( } } \alpha } = 0 . 0 0 1 $ , $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } = 0 . 9 9 9 )$ with the learning rate, $\alpha$ , decreasing by a factor of 10 halfway through training. To assess that the network had indeed learned a robust representation, we tested on the CalTech Pedestrian dataset (Dollar et al., 2009), which´ consists of videos from a dashboard-mounted camera on a vehicle driving around Los Angeles. Testing sequences were made to match the frame rate of the KITTI dataset and again cropped to 128x160 pixels. Quantitative evaluation was performed on the entire CalTech test partition, split into sequences of 10 frames.
+
+Sample PredNet predictions (for the $L _ { 0 }$ model) on the CalTech Pedestrian dataset are shown in Figure 4, and example videos can be found at https://coxlab.github.io/prednet/. The model is able to make fairly accurate predictions in a wide range of scenarios. In the top sequence of Fig. 4, a car is passing in the opposite direction, and the model, while not perfect, is able to predict its trajectory, as well as fill in the ground it leaves behind. Similarly in Sequence 3, the model is able to predict the motion of a vehicle completing a left turn. Sequences 2 and 5 illustrate that the PredNet can judge its own movement, as it predicts the appearance of shadows and a stationary vehicle as they approach. The model makes reasonable predictions even in difficult scenarios, such as when the camera-mounted vehicle is turning. In Sequence 4, the model predicts the position of a tree, as the vehicle turns onto a road. The turning sequences also further illustrate the model’s ability to “fill-in”, as it is able to extrapolate sky and tree textures as unseen regions come into view. As an additional control, we show a sequence at the bottom of Fig. 4, where the input has been temporally scrambled. In this case, the model generates blurry frames, which mostly just resemble the previous frame. Finally, although the PredNet shown here was trained to predict one frame ahead, it is also possible to predict multiple frames into the future, by feeding back predictions as the inputs and recursively iterating. We explore this in Appendix 5.3.
+
+Quantitatively, the PredNet models again outperformed the CNN-LSTM EncoderDecoder. To ensure that the difference in performance was not simply because of the choice of hyperparameters, we trained models with four other sets of hyperparameters, which were sampled from the initial random search over the number of layers, fil
+
+Table 2: Evaluation of Next-Frame Predictions on CalTech Pedestrian Dataset.   
+
+<table><tr><td></td><td>MSE</td><td>SSIM</td></tr><tr><td>PredNet Lo</td><td>3.13 × 10-3</td><td>0.884</td></tr><tr><td>PredNet Lall</td><td>3.33 ×10-3</td><td>0.875</td></tr><tr><td>CNN-LSTMEnc.-Dec.</td><td>3.67 × 10-3</td><td>0.865</td></tr><tr><td>Copy Last Frame</td><td>7.95 × 10-3</td><td>0.762</td></tr></table>
+
+ter sizes, and number of filters per layer. For each of the four additional sets, the PredNet $L _ { 0 }$ had the best performance, with an average error reduction of $1 4 . 7 \%$ and $1 4 . 9 \%$ for MSE and SSIM,
+
+![](images/f2465bddecf762950203060719579f704eebd5b1c06d29b0051a317691866e37.jpg)  
+time →   
+Figure 4: PredNet predictions for car-cam videos. The first rows contain ground truth and the second rows contain predictions. The sequence below the red line was temporally scrambled. The model was trained on the KITTI dataset and sequences shown are from the CalTech Pedestrian dataset.
+
+respectively, compared to the CNN-LSTM Encoder-Decoder. More details, as well as a thorough investigation of systematically simplified models on the continuum between the PredNet and the CNN-LSTM Encoder-Decoder can be found in Appendix 5.1. Briefly, the elementwise subtraction operation in the PredNet seems to be beneficial, and the nonlinearity of positive/negative splitting also adds modest improvements. Finally, while these experiments measure the benefits of each component of our model, we also directly compare against recent work in a similar car-cam setting, by reporting results on a 64x64 pixel, grayscale car-cam dataset released by Brabandere et al. (2016). Our PredNet model outperforms the model by Brabandere et al. (2016) by $2 9 \%$ . Details can be found in Appendix 5.2. Also in Appendix 5.2, we present results for the Human3.6M (Ionescu et al., 2014) dataset, as reported by Finn et al. (2016). Without re-optimizing hyperparameters, our model underperforms the concurrently developed DNA model by Finn et al. (2016), but outperforms the model by Mathieu et al. (2016).
+
+To test the implicit encoding of latent parameters in the car-cam setting, we used the internal representation in the PredNet to estimate the car’s steering angle (Bojarski et al., 2016; Biasini et al., 2016). We used a dataset released by Comma.ai (Biasini et al., 2016) consisting of 11 videos totaling about 7 hours of mostly highway driving. We first trained networks for next-frame prediction and then fit a linear fully-connected layer on the learned representation to estimate the steering angle, using a MSE loss. We again concatenate the $R _ { l }$ representation at all layers, but first spatially average pool lower layers to match the spatial size of the upper layer, in order to reduce dimensionality. Steering angle estimation results, using the representation on the $1 0 ^ { \mathrm { t h } }$ time step, are shown in Figure 5. Given just 1K labeled training examples, a simple linear readout on the PredNet $L _ { 0 }$ representation explains $7 4 \%$ of the variance in the steering angle and outperforms the CNN-LSTM Enc.-Dec. by $3 5 \%$ . With 25K labeled training examples, the PredNet $L _ { 0 }$ has a MSE (in degrees2) of 2.14. As a point of reference, a CNN model designed to predict the steering angle (Biasini et al., 2016), albeit from a single frame instead of multiple frames, achieve a MSE of ${ \sim } 4$ when trained end-to-end using 396K labeled training examples. Details of this analysis can be found in Appendix 8. Interestingly, in this task, the PredNet $L _ { a l l }$ model actually underperformed the $L _ { 0 }$ model and slightly underperformed the CNN-LSTM Enc.-Dec, again suggesting that the $\lambda _ { l }$ parameter can affect the representation learned, and different values may be preferable in different end tasks. Nonetheless, the readout from the $L _ { a l l }$ model still explained a substantial proportion of the steering angle variance and strongly outperformed the random initial weights. Overall, this analysis again demonstrates that a representation learned through prediction, and particularly with the PredNet model with appropriate hyperparameters, can contain useful information about underlying latent parameters.
+
+![](images/4eacc964ba30df01ba5dfac8e925e09b97a2e2cd91639d41fa77b3ced7bfe30a.jpg)  
+Figure 5: Steering angle estimation accuracy on the Comma.ai dataset (Biasini et al., 2016). Left: Example steering angle curve with model estimations for a segment in the test set. Decoding was performed using a fully-connected readout on the PredNet representation trained with 25K labeled training examples. PredNet representation was trained for next-frame prediction on Comma.ai training set. Right: Mean-squared error of steering angle estimation.
+
+# 4 DISCUSSION
+
+Above, we have demonstrated a predictive coding inspired architecture that is able to predict future frames in both synthetic and natural image sequences. Importantly, we have shown that learning to predict how an object or scene will move in a future frame confers advantages in decoding latent parameters (such as viewing angle) that give rise to an object’s appearance, and can improve recognition performance. More generally, we argue that prediction can serve as a powerful unsupervised learning signal, since accurately predicting future frames requires at least an implicit model of the objects that make up the scene and how they are allowed to move. Developing a deeper understanding of the nature of the representations learned by the networks, and extending the architecture, by, for instance, allowing sampling, are important future directions.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Rasmus Berg Palm for fruitful discussions and early brainstorming. We would also like to thank the developers of Keras (Chollet, 2016). This work was supported by IARPA (contract D16PC00002), the National Science Foundation (NSF IIS 1409097), and the Center for Brains, Minds and Machines (CBMM, NSF STC award CCF-1231216).
+
+# REFERENCES
+
+Pulkit Agrawal, Joao Carreira, and Jitendra Malik. Learning to see by moving. ˜ CoRR, 2015.
+
+Andre M. Bastos, W. Martin Usrey, Rick A. Adams, George R. Mangun, Pascal Fries, and Karl J. Friston. Canonical microcircuits for predictive coding. Neuron, 2012.
+
+Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. CoRR, 2015.
+
+Yoshua Bengio. How auto-encoders could provide credit assignment in deep networks via target propagation. CoRR, 2014.
+
+Riccardo Biasini, George Hotz, Sam Khalandovsky, Eder Santana, and Niel van der Westhuizen. Comma.ai research, 2016. URL https://github.com/commaai/research.
+
+Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D. Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, Xin Zhang, Jake Zhao, and Karol Zieba. End to end learning for self-driving cars. CoRR, 2016.
+
+Bert De Brabandere, Xu Jia, Tinne Tuytelaars, and Luc Van Gool. Dynamic filter networks. CoRR, 2016.
+
+Rakesh Chalasani and Jose C. Principe. Deep predictive coding networks. CoRR, 2013.
+
+Franc¸ois Chollet. Comma.ai, 2016. URL http://keras.io/.
+
+Andy Clark. Whatever next? predictive brains, situated agents, and the future of cognitive science. Behavioral and Brain Sciences, 2013.
+
+Piotr Dollar, Christian Wojek, Bernt Schiele, and Pietro Perona. Pedestrian detection: A benchmark.´ In CVPR, 2009.
+
+Tobias Egner, Jim M. Monti, and Christopher Summerfield. Expectation and surprise determine neural population responses in the ventral visual stream. J Neurosci, 2010.
+
+Chelsea Finn, Ian J. Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction through video prediction. CoRR, 2016.
+
+Peter Foldi ¨ ak. Learning invariance from transformation sequences. ´ Neural Computation, 1991.
+
+Karl Friston. A theory of cortical responses. Philos Trans R Soc Lond B Biol Sci, 2005.
+
+Andreas Geiger, Philip Lenz, Christoph Stiller, and Raquel Urtasun. Vision meets robotics: The kitti dataset. International Journal of Robotics Research (IJRR), 2013.
+
+Dileep George and Jeff Hawkins. A hierarchical bayesian model of invariant pattern recognition in the visual cortex. In Proceedings of the International Joint Conference on Neural Networks. IEEE, 2005.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS. 2014.
+
+Ross Goroshin, Joan Bruna, Jonathan Tompson, David Eigen, and Yann LeCun. Unsupervised learning of spatiotemporally coherent metrics. CoRR, 2015a.
+
+Ross Goroshin, Michael Mathieu, and Yann LeCun. Learning to linearize under uncertainty. ¨ CoRR, 2015b.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. Neural Computation, 1997.
+
+Catalin Ionescu, Dragos Papava, Vlad Olaru, and Cristian Sminchisescu. Human3.6m: Large scale datasets and predictive methods for 3d human sensing in natural environments. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2014.
+
+Kevin Jarrett, Koray Kavukcuoglu, MarcAurelio Ranzato, and Yann LeCun. What is the best multistage architecture for object recognition? In ICCV. 2009.
+
+Ryota Kanai, Yutaka Komura, Stewart Shipp, and Karl Friston. Cerebral hierarchies : predictive processing , precision and the pulvinar. Philos Trans R Soc Lond B Biol Sci, 2015.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, 2014.
+
+Tejas D. Kulkarni, Will Whitney, Pushmeet Kohli, and Joshua B. Tenenbaum. Deep convolutional inverse graphics network. CoRR, 2015.
+
+Tai Sing Lee and David Mumford. Hierarchical bayesian inference in the visual cortex. J Opt Soc Am A Opt Image Sci Vis, 2003.
+
+William Lotter, Gabriel Kreiman, and David Cox. Unsupervised learning of visual structure using predictive generative networks. CoRR, 2015.
+
+Davide Maltoni and Vincenzo Lomonaco. Semi-supervised tuning from temporal coherence. CoRR, 2015.
+
+Michael Mathieu, Camille Couprie, and Yann LeCun. Deep multi-scale video prediction beyond ¨ mean square error. ICLR, 2016.
+
+Vincent Michalski, Roland Memisevic, and Kishore Konda. Modeling deep temporal dependencies with recurrent ”grammar cells”. In NIPS. 2014.
+
+Hossein Mohabi, Ronan Collobert, and Jason Weston. Deep learning from temporal coherence in video. In ICML. 2009.
+
+Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L. Lewis, and Satinder P. Singh. Actionconditional video prediction using deep networks in atari games. CoRR, 2015.
+
+Randall C. O’Reilly, Dean Wyatte, and John Rohrlich. Learning through time in the thalamocortical loops. CoRR, 2014.
+
+Rasmus Berg Palm. Prediction as a candidate for learning deep hierarchical models of data. Master’s thesis, Technical University of Denmark, 2012.
+
+Viorica Patraucean, Ankur Handa, and Roberto Cipolla. Spatio-temporal video autoencoder with differentiable memory. CoRR, 2015.
+
+Mohammad Pezeshki, Linxi Fan, Philemon Brakel, Aaron C. Courville, and Yoshua Bengio. Deconstructing the ladder network architecture. CoRR, 2015.
+
+Nicolas Pinto, David Doukhan, James J. DiCarlo, and David D. Cox. A high-throughput screening approach to discovering good forms of biologically inspired visual representation. PLoS Comput Biol, 2009.
+
+Marc’Aurelio Ranzato, Arthur Szlam, Joan Bruna, Michael Mathieu, Ronan Collobert, and Sumit ¨ Chopra. Video (language) modeling: a baseline for generative models of natural videos. CoRR, 2014.
+
+Rajesh P. N. Rao and Dana H. Ballard. Predictive coding in the visual cortex: a functional interpretation of some extra-classical receptive-field effects. Nature Neuroscience, 1999.
+
+Rajesh P. N. Rao and T. J. Sejnowski. Predictive sequence learning in recurrent neocortical circuits. NIPS, 2000.
+
+Antti Rasmus, Harri Valpola, Mikko Honkala, Mathias Berglund, and Tapani Raiko. Semisupervised learning with ladder network. CoRR, 2015.
+
+Eder Santana and George Hotz. Learning a driving simulator. CoRR, 2016.
+
+Andrew Saxe, Maneesh Bhand, Zhenghao Chen, Pang Wei Koh, Bipin Suresh, and Andrew Y. Ng. On random weights and unsupervised feature learning. In Workshop: Deep Learning and Unsupervised Feature Learning (NIPS). 2010.
+
+Xingjian Shi, Zhourong Chen, Hao Wang, Dit-Yan Yeung, Wai-Kin Wong, and Wang-chun Woo. Convolutional LSTM network: A machine learning approach for precipitation nowcasting. CoRR, 2015.
+
+Singular Inversions, Inc. FaceGen. http://facegen.com.
+
+William R. Softky. Unsupervised pixel-prediction. NIPS, 1996.
+
+M. W. Spratling. Unsupervised learning of generative and discriminative weights encoding elementary image components in a predictive coding model of cortical function. Neural Computation, 2012.
+
+Nitish Srivastava, Elman Mansimov, and Ruslan Salakhutdinov. Unsupervised learning of video representations using lstms. CoRR, 2015.
+
+Christopher Summerfield, Tobias Egner, Matthew Greene, Etienne Koechlin, Jennifer Mangels, and Joy Hirsch. Predictive codes for forthcoming perception in the frontal cortex. Science, 314, 2006.
+
+Lin Sun, Kui Jia, Tsung-Han Chan, Yuqiang Fang, Gang Wang, and Shuicheng Yan. Dl-sfa: Deeplylearned slow feature analysis for action recognition. CVPR, 2014.
+
+Lucas Theis, Aaron van den Oord, and Matthias Bethge. A note on the evaluation of generative models. ICLR, 2016.
+
+Harri Valpola. From neural pca to deep unsupervised learning. CoRR, 2015.
+
+Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. CoRR, 2016.
+
+Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. CoRR, 2015.
+
+Zhou Wang, Alan Bovik, Hamid Sheikh, and Eero Simoncelli. Image quality assessment: From error visibility to structural similarity. IEEE Transactions on Image Processing, 2004.
+
+William F. Whitney, Michael Chang, Tejas D. Kulkarni, and Joshua B. Tenenbaum. Understanding visual concepts with continuation learning. CoRR, 2016.
+
+Laurenz Wiskott and Terrence J. Sejnowski. Learning invariance from transformation sequences. Neural Computation, 2002.
+
+Tianfan Xue, Jiajun Wu, Katherine L. Bouman, and William T. Freeman. Visual dynamics: Probabilistic future frame synthesis via cross convolutional networks. CoRR, 2016.
+
+# 5 APPENDIX
+
+# 5.1 ADDITIONAL CONTROL MODELS
+
+Table 3 contains results for additional variations of the PredNet and CNN-LSTM Encoder-Decoder evaluated on the CalTech Pedestrian Dataset after being trained on KITTI. We evaluate the models in terms of pixel prediction, thus using the PredNet model trained with loss only on the lowest layer (PredNet $L _ { 0 }$ ) as the base model. In addition to mean-squared error (MSE) and the Structural Similarity Index Measure (SSIM), we include calculations of the Peak Signal-To-Noise Ratio (PSNR). For each model, we evaluate it with the original set of hyperparameters (controlling the number of layers, filter sizes, and number of filters per layer), as well as with the four additional sets of hyperparameters that were randomly sampled from the initial random search (see main text for more details). Below is an explanation of the additional control models:
+
+• PredNet (no E split): PredNet model except the error responses $( E _ { l } )$ are simply linear $( \hat { A } _ { l } - A _ { l } )$ instead of being split into positive and negative rectifications.
+
+• CNN-LSTM Enc.-Dec. $2 \mathbf { x } \ A _ { l }$ filts): CNN-LSTM Encoder-Decoder model ( $\mathbf { \delta } _ { \cdot } A _ { l }$ ’s are passed instead of $E _ { l }$ ’s) except the number of filters in $A _ { l }$ is doubled. This controls for the total number of filters in the model compared to the PredNet, since the PredNet has filters to produce $\hat { A } _ { l }$ at each layer, which is integrated into the model’s feedforward response.
+
+• CNN-LSTM Enc.-Dec. (except pass $E _ { 0 }$ ): CNN-LSTM Encoder-Decoder model except the error is passed at the lowest layer. All remaining layers pass the activations $A _ { l }$ . With training loss taken at only the lowest layer, this variation allows us to determine if the “prediction” subtraction operation in upper layers, which is essentially unconstrained and learnable in the $L _ { 0 }$ case, aids in the model’s performance.
+
+• CNN-LSTM Enc.-Dec. $+ / -$ split): CNN-LSTM Encoder-Decoder model except the activations $A _ { l }$ are split into positive and negative populations before being passed to other layers in the network. This isolates the effect of the additional nonlinearity introduced by this procedure.
+
+Table 3: Quantitative evaluation of additional controls for next-frame prediction in CalTech Pedestrian Dataset after training on KITTI. First number indicates score with original hyperparameters. Number in parenthesis indicates score averaged over total of five different hyperparameters.   
+
+<table><tr><td></td><td>MSE (x 10-3)</td><td>PSNR</td><td>SSIM</td></tr><tr><td>PredNet</td><td>3.13 (3.33)</td><td>25.8 (25.5)</td><td>0.884 (0.878)</td></tr><tr><td>PredNet (no Et split)</td><td>3.20 (3.37)</td><td>25.6 (25.4)</td><td>0.883 (0.878)</td></tr><tr><td>CNN-LSTMEnc.-Dec.</td><td>3.67 (3.91)</td><td>25.0 (24.6)</td><td>0.865 (0.856)</td></tr><tr><td>CNN-LSTM Enc.-Dec. (2x At filts)</td><td>3.82 (3.97)</td><td>24.8 (24.6)</td><td>0.857 (0.853)</td></tr><tr><td>CNN-LSTM Enc.-Dec. (except pass Eo)</td><td>3.41 (3.61)</td><td>25.4 (25.1)</td><td>0.873 (0.866)</td></tr><tr><td>CNN-LSTMEnc.-Dec. (+/- split)</td><td>3.71 (3.84)</td><td>24.9 (24.7)</td><td>0.861 (0.857)</td></tr><tr><td>Copy Last Frame</td><td>7.95</td><td>20.0</td><td>0.762</td></tr></table>
+
+Equalizing the number of filters in the CNN-LSTM Encoder-Decoder (2x $A _ { l }$ filts) cannot account for its performance difference with the PredNet, and actually leads to overfitting and a decrease in performance. Passing the error at the lowest layer $( E _ { 0 } )$ in the CNN-LSTM Enc.-Dec. improves performance, but still does not match the PredNet, where errors are passed at all layers. Finally, splitting the activations $A _ { l }$ into positive and negative populations in the CNN-LSTM Enc.-Dec. does not help, but the PredNet with linear error activation (“no $E _ { l }$ split”) performs slightly worse than the original split version. Together, these results suggest that the PredNet’s error passing operation can lead to improvements in next-frame prediction performance.
+
+# 5.2 COMPARING AGAINST OTHER MODELS
+
+While our main comparison in the text was a control model that isolates the effects of the more unique components in the PredNet, here we directly compare against other published models. We report results on a $6 4 \mathrm { x 6 4 }$ pixel, grayscale car-cam dataset and the Human3.6M dataset (Ionescu et al., 2014) to compare against the two concurrently developed models by Brabandere et al. (2016)
+
+and Finn et al. (2016), respectively. For both comparisons, we use a model with the same hyperparameters (# of layers, # of filters, etc.) of the PredNet $L _ { 0 }$ model trained on KITTI, but train from scratch on the new datasets. The only modification we make is to train using an L2 loss instead of the effective L1 loss, since both models train with an L2 loss and report results using L2-based metrics (MSE for Brabandere et al. (2016) and PSNR for Finn et al. (2016)). That is, we keep the original PredNet model intact but directly optimize using MSE between actual and predicted frames. We measure next-frame prediction performance after inputting 3 frames and 10 frames, respectively, for the 64x64 car-cam and Human3.6M datasets, to be consistent with the published works. We also include the results using a feedforward multi-scale network, similar to the model of Mathieu et al. (2016), on Human3.6M, as reported by Finn et al. (2016).
+
+Table 4: Evaluation of Next-Frame Predictions on 64x64 Car-Cam Dataset. MSE (per-pixel)   
+
+<table><tr><td colspan="2">MSE (per-pixel)</td></tr><tr><td>DFN (Brabandere et al., 2016)</td><td>1.71 ×10-3</td></tr><tr><td>PredNet</td><td>1.16 ×10-3</td></tr><tr><td>Copy Last Frame</td><td>3.58 ×10-3</td></tr></table>
+
+Table 5: Evaluation of Next-Frame Predictions on Human3.6M PSNR   
+
+<table><tr><td>DNA (Finn et al., 2016) PredNet FF multi-scale (Mathieu et al.,2016)</td><td>42.1 38.9 26.7 32.0</td></tr></table>
+
+On a dataset similar to KITTI, our model outperforms the model proposed by Brabandere et al. (2016). On Human3.6M, our model outperforms a model similar to (Mathieu et al., 2016), but underperforms Finn et al. (2016), although we note we did not perform any hyperparameter optimization.
+
+# 5.3 MULTIPLE TIME STEP PREDICTION
+
+![](images/d9c247d44b99433c9cfb95c59a9b7fce77018f62bc8529b66fb02544335c6500.jpg)  
+Figure 6: Extrapolation sequences generated by feeding PredNet predictions back into model. Left of the orange line: Normal $t + 1$ predictions; Right: Generated by recursively using the predictions as input. First row: Ground truth sequences. Second row: Generated frames of the original model, trained to solely predict $t + 1$ . Third row: Model fine-tuned for extrapolation.
+
+While the models presented here were originally trained to predict one frame ahead, they can be made to predict multiple frames by treating predictions as actual input and recursively iterating. Examples of this process are shown in Figure 6 for the PredNet $L _ { 0 }$ model. Although the next frame predictions are reasonably accurate, the model naturally breaks down when extrapolating further into the future. This is not surprising since the predictions will unavoidably have different statistics than the natural images for which the model was trained to handle (Bengio et al., 2015). If we additionally train the model to process its own predictions, the model is better able to extrapolate. The third row for every sequence shows the output of the original PredNet fine-tuned for extrapolation. Starting from the trained weights, the model was trained with a loss over 15 time steps, where the actual frame was inputted for the first 10 and then the model’s predictions were used as input to the network for the last 5. For the first 10 time steps, the training loss was calculated on the $E _ { l }$ activations as usual, and for the last 5, it was calculated directly as the mean absolute error with respect to the ground truth frames. Despite eventual blurriness (which might be expected to some extent due to uncertainty), the fine-tuned model captures some key structure in its extrapolations after the tenth time step. For instance, in the first sequence, the model estimates the general shape of an upcoming shadow, despite minimal information in the last seen frame. In the second sequence, the model is able to extrapolate the motion of a car moving to the right. The reader is again encouraged to visit https://coxlab.github.io/prednet/ to view the predictions in video form. Quantitatively, the MSE of the model’s predictions stay well below the trivial solution of copying the last seen frame, as illustrated in Fig 7. The MSE increases fairly linearly from time steps 2-10, even though the model was only trained for up to $t + 5$ prediction.
+
+![](images/386c934c0c7cd4d4bb7e1f0e1e6977d14b386376dbb66698689a1d26524a0395.jpg)  
+Figure 7: MSE of PredNet predictions as a function of number of time steps ahead predicted. Model was fine-tuned for up to $t + 5$ prediction.
+
+# 5.4 ADDITIONAL STEERING ANGLE ANALYSIS
+
+In Figure 8, we show the steering angle estimation accuracy on the Comma.ai (Biasini et al., 2016) dataset using the representation learned by the PredNet $L _ { 0 }$ model, as a function of the number of frames inputted into the model. The PredNet’s representation at all layers was concatenated (after spatially pooling lower layers to a common spatial resolution) and a fully-connected readout was fit using MSE. For each level of the number of training examples, we average over 10 cross-validation splits. To serve as points of reference, we include results for two static models. The first model is an autoencoder trained on single frame reconstruction with appropriately matching hyperparameters. A fully-connected layer was fit on the autoencoder’s representation to estimate the steering angle in the same fashion as the PredNet. The second model is the default model in the posted Comma.ai code (Biasini et al., 2016), which is a five layer CNN. This model is trained end-to-end to estimate the steering angle given the current frame as input, with a MSE loss. In addition to 25K examples, we trained a version using all of the frames in the Comma dataset (\~396K). For all models, the final weights were chosen at the minimum validation error during training. Given the relatively small number of videos in the dataset compared to the average duration of each video, we used $5 \%$ of each video for validation and testing, chosen as a random continuous chunk, and discarded the 10 frames before and after the chosen segments from the training set.
+
+![](images/786ee29cf8d282ebc8e20ea4c6a1d601619f455dd6984bab67feeada0044938e.jpg)  
+Figure 8: Steering angle estimation accuracy as a function of the number of input frames.
+
+As illustrated in Figure 8, the PredNet’s performance gets better over time, as one might expect, as the model is able to accumulate more information. Interestingly, it performs reasonably well after just one time step, in a regime that is orthogonal to the training procedure of the PredNet where there are no dynamics. Altogether, these results again point to the usefulness of the model in learning underlying latent parameters.
+
+# 5.5 PREDNET $L _ { a l l }$ NEXT-FRAME PREDICTIONS
+
+Figures 9 and 10 compare next-frame predictions by the PredNet $L _ { a l l }$ model, trained with a prediction loss on all layers ( $\lambda _ { 0 } = 1$ , $\lambda _ { l > 0 } = 0 . 1 $ ), and the PredNet $L _ { 0 }$ model, trained with a loss only on the lowest layer. At first glance, the difference in predictions seem fairly minor, and indeed, in terms of MSE, the $L _ { a l l }$ model only underperformed the $L _ { 0 }$ version by $3 \%$ and $6 \%$ , respectively, for the rotating faces and CalTech Pedestrian datasets. Upon careful inspection, however, it is apparent that the $L _ { a l l }$ predictions lack some of the finer details of the $L _ { 0 }$ predictions and are more blurry in regions of high variance. For instance, with the rotating faces, the facial features are less defined and with CalTech, details of approaching shadows and cars are less precise.
+
+![](images/235db1e2a31428ae54787e2a5c30dc4c978774edcf9dd06ef6ac6cecc851ece6.jpg)  
+time   
+Figure 9: Next-frame predictions of PredNet $L _ { a l l }$ model on the rotating faces dataset and comparison to $L _ { 0 }$ version. The ”Error ${ \cal L } _ { a l l } { - \cal L } _ { 0 } { } ^ { \cdots }$ visualization shows where the pixel error was smaller for the $L _ { 0 }$ model than the $L _ { a l l }$ model. Green regions correspond to where $L _ { 0 }$ was better and red corresponds to where $L _ { a l l }$ was better.
+
+![](images/5436ead45eb2f3750a49987e6825e0fe9897d10aa4f0e52240e2823c9aafffd5.jpg)  
+time   
+Figure 10: Next-frame predictions of PredNet $L _ { a l l }$ model on the CalTech Pedestrian dataset and comparison to $L _ { 0 }$ version. The ”Error ${ \cal L } _ { a l l } - { \cal L } _ { 0 } { } ^ {  }$ visualization shows where the pixel error was smaller for the $L _ { 0 }$ model than the $L _ { a l l }$ model. Green regions correspond to where $L _ { 0 }$ was better and red corresponds to where $L _ { a l l }$ was better.

parse/train/B1xm3RVtwB/B1xm3RVtwB.md

@@ -0,0 +1,279 @@
+# SIMPLIFIED ACTION DECODER FOR DEEP MULTI-AGENT REINFORCEMENT LEARNING
+
+Hengyuan Hu, Jakob N Foerster Facebook AI Research, CA, USA {hengyuan,jnf}@fb.com
+
+# ABSTRACT
+
+In recent years we have seen fast progress on a number of benchmark problems in AI, with modern methods achieving near or super human performance in Go, Poker and Dota. One common aspect of all of these challenges is that they are by design adversarial or, technically speaking, zero-sum. In contrast to these settings, success in the real world commonly requires humans to collaborate and communicate with others, in settings that are, at least partially, cooperative. In the last year, the card game Hanabi has been established as a new benchmark environment for AI to fill this gap. In particular, Hanabi is interesting to humans since it is entirely focused on theory of mind, i.e., the ability to effectively reason over the intentions, beliefs and point of view of other agents when observing their actions. Learning to be informative when observed by others is an interesting challenge for Reinforcement Learning (RL): Fundamentally, RL requires agents to explore in order to discover good policies. However, when done naively, this randomness will inherently make their actions less informative to others during training. We present a new deep multi-agent RL method, the Simplified Action Decoder (SAD), which resolves this contradiction exploiting the centralized training phase. During training SAD allows other agents to not only observe the (exploratory) action chosen, but agents instead also observe the greedy action of their team mates. By combining this simple intuition with best practices for multi-agent learning, SAD establishes a new SOTA for learning methods for 2-5 players on the self-play part of the Hanabi challenge. Our ablations show the contributions of SAD compared with the best practice components. All of our code and trained agents are available at https://github.com/facebookresearch/Hanabi_SAD.
+
+# 1 INTRODUCTION
+
+Humans are highly social creatures and spend vast amounts of time coordinating, collaborating and communicating with others. In contrast to these, at least partially, cooperative settings most progress on AI in games has been in zero-sum games where agents compete against each other, typically rendering communication futile. This includes examples such as Go (Silver et al., 2016; 2017; 2018), poker (Brown & Sandholm, 2017; Moravcík et al., 2017; Brown & Sandholm, 2019) ˇ and chess (Campbell et al., 2002).
+
+This narrow focus is unfortunate, since communication and coordination require unique abilities. In order to enable smooth and efficient social interactions of groups of people, it is commonly required to reason over the intents, points of views and beliefs of other agents from observing their actions. For example, a driver can reasonably infer that if a truck in front of them is slowing down when approaching an intersection, then there is likely an obstacle ahead. Furthermore, humans are both able to interpret the actions of others and can act in a way that is informative when their actions are being observed by others, capabilities that are commonly called theory of Mind (ToM), (Baker et al., 2017). Importantly, in order to carry out this kind of reasoning, an agent needs to consider why a given action is taken and what this decision indicates about the state of the world. Simply observing what other agents are doing is not sufficient.
+
+While these abilities are particularly relevant in partially observable, fully cooperative multi-agent settings, ToM reasoning clearly matters in a variety of real world scenarios. For example, autonomous cars will likely need to understand the point of view, intents and beliefs of other traffic participants in order to deal with highly interactive settings such as 4-way crossing or dense traffic in cities.
+
+Hanabi is a fully cooperative, partially-observable card game that has recently been proposed as a new benchmark challenge problem for AI research (Bard et al., 2019) to fill the gap around ToM. In Hanabi, players need to find conventions that allow them to effectively exchange information from their local observations through their actions, taking advantage of the fact that actions are observed by all team mates.
+
+Most prior state-of-the-art agents for Hanabi were developed using handcrafted algorithms, which beat off-the-shelf deep multi-agent RL methods by a large margin. This makes intuitive sense: Beyond the “standard” multi-agent challenges of credit assignment, nonstationarity and joint exploration, learning an informative policy presents an additional fundamentally new conflict. On the one hand, an RL agent needs to explore in order to discover good policies through trial and error. On the other hand, when carried out naively, this exploration will add noise to the policy of the agent during the training process, making their actions strictly less informative to their team mates.
+
+One possible solution to this is to explore in the space of deterministic partial policies, rather than actions, and sample these policies from a distribution that conditions on a common knowledge Bayesian belief. This is successfully carried out in the Bayesian Action Decoder (BAD) (Foerster et al., 2019), the only previous Deep RL method to achieve a state-of-the-art in Hanabi. While this is a notable accomplishment, it comes at the cost of simplicity and generality. For a start, BAD requires an explicit common knowledge Bayesian belief to be tracked, which not only adds computational burden due to the required sampling steps, but also uses expert knowledge regarding the game dynamics. Furthermore, BAD, as presented, is trained using actor-critic methods which are sample inefficient and suffer from local optima. In order to get around this, BAD uses population based training, further increasing the number of samples required. Lastly, BAD’s explicit reliance on common knowledge limits the generality of the method.
+
+In this paper we propose the Simplified Action Decoder (SAD), a method that achieves a similar goal to BAD, but addresses all of the issues mentioned above. At the core of SAD is a different approach towards resolving the conflict between exploration and being interpretable, which, like BAD, relies on the centralized training with decentralized control (CT/DC) regime. Under CT/DC information can be exchanged freely amongst all agents during centralized training, as long as the final policies are compatible with decentralized execution.
+
+The key insight is that during training we do not have to chose between being informative, by taking greedy actions, and exploring, by taking random actions. To be informative, the greedy actions do not need to be executed by the environment, but only need to be observed by the team mates. Thus in SAD each agent takes two different actions at each time step: One greedy action, which is not presented to the environment but observed by the team mates at the next time step as an additional input, and the “standard” (exploratory) action that gets executed by the environment and is observed by the team mates as part of the environment dynamics. Importantly, during greedy execution the observed environment action can be used instead of centralized information for the additional input, since now the agent has stopped exploring.
+
+Furthermore, to ensure that these greedy actions and observations get decoded into a meaningful representation, we can optionally train an auxiliary task that predicts key hidden game properties from the action-observation trajectories. While we note that this idea is in principle compatible with any kind of model-free deep RL method with minimal modifications to the core algorithm, we use a distributed version of recurrent DQN in order to improve sample efficiency, account for partial observability and reduce the risk of local optima. We also train a joint-action Q-function that consists of the sum of per-agent Q-values to allow for off-policy learning in this multi-agent setting using Value Decomposition Networks (VDN) (Sunehag et al., 2017).
+
+Using SAD we establish a new SOTA for learning methods for 2-5 players in Hanabi, with a method that not only requires less expert knowledge and compute, but is also more general than previous approaches. In order to ensure that our results can be easily verified and extended, we also evaluate our method on a proof-of-principle matrix game and open-source our training code and agents. Beyond enabling more research into the self-play aspect of Hanabi, we believe these resources will provide a much needed starting point for the ad-hoc teamwork part of the Hanabi challenge.
+
+# 2 RELATED WORK
+
+Our work relates closely to research on emergent communication protocols using deep multi-agent RL, as first undertaken by Sukhbaatar et al. (2016) and Foerster et al. (2016) . There has been a large number of follow-up papers in this area, so listing all relevant work is beyond the scope and we refer the reader to Nguyen et al. (2018), a recent survey on deep multi-agent RL. One major difference to our work is that the environments considered typically contain a cheap-talk channel, which can be modeled as a continuous variable during the course of training. This allows agents to, for example, use differentiation across the communication channel in order to learn protocols. In contrast, in our setting agents have to communicate through the observable environment actions themselves, requiring fundamentally different methods.
+
+Furthermore, our work is an example of cooperative multi-agent learning in partially observable settings under centralized training and decentralized control. There have been a large number of papers in this space, with seminal work including MADDPG (Lowe et al., 2017) and COMA (Foerster et al., 2018a), both of which are actor-critic methods that employ a centralized critic with decentralized actors. Again, we refer the reader to Nguyen et al. (2018) for a more comprehensive survey.
+
+Until 2018, work on Hanabi had been focused on hand-coded methods and heuristics. Some relevant examples include SmartBot (O’Dwyer, 2019) and the so-called “hat-coding” strategies, as implemented by WTFWThat (Wu, 2018). These strategies use the information theoretic ideas that allow each hint to reveal information to all other agents at the same time. While they do not perform well for 2-player Hanabi due to the smaller action space, they get near perfect scores for 3-5 players.
+
+In contrast, so far learning methods have seen limited success on Hanabi. Bard et al. (2019) undertake a systematic evaluation of current Deep RL methods for 2-5 players in two different regimes and open-source the Hanabi-Learning-Environment (HLE) to foster research on the game. They evaluate a feed-forward version of DQN trained on 100 million samples and a recurrent actor-critic agent with population based training using 20 billion samples. Notably, while both agents achieve near $0 \%$ win rate for 3-5 players in Hanabim, at a high level their DQN agent is a good starting point for our work. However, since the authors did not propose any specific method of accounting for the issues introduced by $\epsilon$ -greedy exploration in a ToM task, they resorted to setting $\epsilon$ to zero after a short burn-in phase. The only state-of-the-art in Hanabi established by an RL agent is from Foerster et al. (2019) which we refer to in more detail in Section 1 and Section 4. Recently there have also been attempts to train agents that are robust to different team-mates (Canaan et al., 2019) and even to extend to human-AI collaboration (Liang et al., 2019). For a more comprehensive review on previous results on Hanabi we refer the reader to Bard et al. (2019).
+
+Poker is another partially observable multi-agent setting, although it is fundamentally different due to the game being zero-sum. Recent success in Poker has extensively benefited from search (Brown et al.). Examples of using search in Hanabi include Goodman (2019).
+
+# 3 BACKGROUND
+
+# 3.1 SETTING
+
+In this paper we assume a Dec-POMDP (Oliehoek, 2012), in which $N$ agents interact in a partially observable environment. At each time step agent $a \in 1 . . N$ obtains an observation, $o _ { t } ^ { a } = { \bar { O } } ( s _ { t } , a )$ , where $s _ { t } \in S$ is the Markov state of the system and $O ( s _ { t } , a )$ is the deterministic observation function. Since we are interested in ToM, in our setting the observation function includes the last action of the acting agent, which is observed by all other agents at the next time step. We note that actions are commonly observable not only in board games but also in some real world multi-agent settings, such as autonomous driving.
+
+For simplicity, we restrict ourselves to turn based settings, in which at each time step only the acting agents takes an action, $u _ { t } ^ { a }$ , which is sampled from their policy, $u ^ { a } \sim \pi _ { \theta } ^ { a } ( u ^ { a } | \tau ^ { a } )$ , while all other agents take a no-op action. Here $\tau ^ { a }$ is the action-observation history of agent $a$ , $\tau ^ { a } = \{ o _ { 0 } ^ { a } , u _ { 0 } ^ { a } , r _ { 1 } , . . r _ { T } , o _ { T } ^ { a } \}$ , $T$ is the length of the episode and $\theta$ are the weights of a function approximator that represents the policy, in our case recurrent neural networks, such as LSTMs (Hochreiter & Schmidhuber, 1997).
+
+We further use $\tau _ { t }$ to describe the state-action sequence, $\tau = \{ s _ { 0 } , \mathbf { u _ { 0 } } , r _ { 1 } , . . r _ { T } , s _ { T } \}$ , where $\mathbf { u _ { t } }$ is the joint action of all agents.
+
+As is typical in cooperative multi-agent RL, the goal of the agents is to maximize the total expected return, $J _ { \theta } = \mathbb { E } _ { \tau \sim P ( \tau \mid \theta ) } R _ { 0 } ( \tau )$ , where $R _ { 0 } ( \tau )$ is the return of the trajectory (in general $R _ { t } \bar { ( } \tau ) ~ =$ $\sum _ { t ^ { \prime } \geq t } \gamma ^ { t ^ { \prime } - t } r _ { t ^ { \prime } } )$ and $\gamma$ is an optional discount factor. We have also assumed that agents are sharing parameters, $\theta$ , as is common in cooperative MARL.
+
+# 3.2 DISTRIBUTED RECURRENT DQN AND AUXILIARY TASKS
+
+In Q-learning the agent approximates the expected return for a given state action-pair, $s , u$ , assuming that the agent acts greedily with respect to the Q-function for all future time steps, $Q ( s , u ) =$ $\mathbb { E } _ { \tau \sim P ( \tau | s , u ) } R _ { t } ( \tau )$ , where $\tau = \{ s _ { t } , u _ { t } , r _ { t + 1 } , . . . , s _ { T } \}$ , $u _ { t } = u$ and $u _ { t ^ { \prime } } = \arg \operatorname* { m a x } _ { u ^ { \prime } } Q ( s _ { t ^ { \prime } } , u ^ { \prime } ) , \forall t ^ { \prime } >$ $t$ . A common exploration scheme is $\epsilon$ -greedy, in which the agent takes a random action with probability $\epsilon$ and acts greedily otherwise. Importantly, the Q-function can be trained efficiently using the Bellman equation: $Q ( s , u ) = \mathbb { E } _ { s ^ { \prime } } [ r _ { t + 1 } + \gamma \operatorname* { m a x } _ { u ^ { \prime } } Q ( s ^ { \prime } , u ^ { \prime } ) ]$ , where for simplicity we have assumed a deterministic reward. In Deep Q-Learning (DQN) (Mnih et al., 2015) the Q-function is parameterized by a deep neural network and trained with transitions sampled from experience replay.
+
+In our work we also incorporate other best practice components of the last few years, including doubleDQN (van Hasselt et al., 2015), dueling network architecture (Wang et al., 2015) and prioritized replay (Schaul et al., 2015). We also employ a distributed training architecture similar to the one proposed by Horgan et al. (2018) where a number of different actors with their own exploration rates collect experiences in parallel and feed them into a central replay buffer. Since our setting is partially observable the natural choice for the function approximator is a recurrent neural network. A combination of these techniques was first explored by Kapturowski et al. (2019) in single agent environments such as Atari and DMLab-30.
+
+Another common best-practice in RL are auxiliary tasks Mirowski et al. (2016); Jaderberg et al. (2016), in which the agent produces extra output-heads that are trained on supervised tasks and optimized alongside the RL loss.
+
+3.3 CENTRALISED TRAINING, DECENTRALIZED EXECUTION AND JOINT Q-FUNCTIONS
+
+The most straight forward application of Q-learning to multi-agent settings is Independent Q-Learning (IQL) (Tan, 1993) in which each agent keeps an independent estimate of the expected return, treating all other agents as part of the environment. One challenge with IQL is that the exploratory behavior of other agents is not corrected for via the max operator in the bootstrap. Notably, IQL does typically not take any advantage of centralized training with decentralised control (CT/DC), a paradigm under which information can be exchanged freely amongst agents during the training phase as long as the policies rely only on local observations during execution.
+
+There are various approaches for learning joint-Q-functions in the CT/DC regime. For example, Value-Decomposition-Networks (VDN) (Sunehag et al., 2017) represent the joint-Q-function as a sum of per-agent contributions and QMIX (Rashid et al., 2018) learns a non-linear but monotonic combination of these contributions.
+
+# 4 METHOD
+
+# 4.1 THEORY OF MIND AND BAYESIAN REASONING
+
+At the very core of interpreting the actions of another agent, and ToM in general, is Bayesian reasoning. Fundamentally, asking what a given action by another agent implies about the state of the world requires understanding of why this action was taken. To illustrate this, we start out with an agent that has a given belief about the state-action history of the world, $\tau _ { t }$ , given her own action-observation history $\tau _ { t } ^ { a }$ : $B ( \tau _ { t } ) = P ( \tau _ { t } | \tau _ { t } ^ { a } )$ .
+
+Next the agent observes the action $u _ { t } ^ { a ^ { \prime } }$ of her team mate, $a ^ { \prime }$ , and carries out a Bayesian update:
+
+$$
+\begin{array} { r l } & { P ( \tau _ { t } | \tau _ { t } ^ { a } , u _ { t } ^ { a ^ { \prime } } ) = \frac { P ( u _ { t } ^ { a ^ { \prime } } | \tau _ { t } ) P ( \tau _ { t } | \tau _ { t } ^ { a } ) } { \sum _ { \tau _ { t } ^ { \prime } } P ( u _ { t } ^ { a ^ { \prime } } | \tau _ { t } ^ { \prime } ) P ( \tau _ { t } ^ { \prime } | \tau _ { t } ^ { a } ) } } \\ & { \qquad = \frac { \pi ^ { a ^ { \prime } } ( u _ { t } ^ { a ^ { \prime } } | O ( a ^ { \prime } , \tau _ { t } ) ) B ( \tau _ { t } ) } { \sum _ { \tau _ { t } ^ { \prime } } \pi ^ { a ^ { \prime } } ( u _ { t } ^ { a ^ { \prime } } | O ( a ^ { \prime } , \tau _ { t } ^ { \prime } ) ) B ( \tau _ { t } ^ { \prime } ) } , } \end{array}
+$$
+
+where, with a slight abuse of notation, we have used (and will keep using) $O ( a ^ { \prime } , \tau _ { t } )$ for the actionobservation history, $\tau _ { t } ^ { a ^ { \prime } }$ , that results from applying the observation function for agent $a ^ { \prime }$ to $\tau _ { t }$ at each time step. Note that for non-deterministic observation functions we would have to marginalize over $P ( \tau _ { t } ^ { a ^ { \prime } } | \bar { \tau _ { t } } )$ .
+
+Clearly, since agents have access to the policy of their teammate during centralised training, we could in principle evaluate this explicit Bayesian belief. However, beyond the practical difficulty of computing this explicit belief, when it is used as an input to the policy it will lead to prohibitively costly higher order beliefs. The typical workout for this is a public belief over private features which only conditions on common knowledge and can therefore be calculated by all agents individually, we refer to Moravcík et al. (2017); Nayyar et al. (2013); Foerster et al. (2018b) for more details. ˇ
+
+Instead, in this work we rely on RNNs to learn implicit representations of the sufficient statistics over the distribution of the Markov state given the action-observation histories, noting that they are unlikely to recover exact beliefs due to the issues mentioned above.
+
+# 4.2 EXPLORATION AND BELIEFS
+
+Next we illustrate the impact of exploration on the beliefs, which we will do in the explicit (exact) case, since it serves as an upper bound on the accuracy of the implicit beliefs. Since we are looking at fully-cooperative settings we assume that the optimal policy of the agent is deterministic and any randomness is due to exploration. Given that we are focused on value based methods we furthermore assume an $\epsilon$ -greedy exploration scheme, noting that the same analysis can be extended to other methods. Under this exploration scheme $\pi ^ { a ^ { \prime } } ( u _ { t } ^ { a ^ { \prime } } | O ( a ^ { \prime } , \tau _ { t } ) )$ ) becomes:
+
+$$
+\pi ^ { a ^ { \prime } } ( u _ { t } ^ { a ^ { \prime } } | O ( a ^ { \prime } , \tau _ { t } ) ) = ( 1 - \epsilon ) \mathbf { I } ( u ^ { * } ( \tau _ { t } ) , u _ { t } ^ { a ^ { \prime } } ) + \epsilon / | U | ,
+$$
+
+where we have used $\boldsymbol { u } ^ { * } ( \tau _ { t } )$ to indicate the greedy action of the agent $a ^ { \prime }$ , $\begin{array} { r l } { u ^ { * } ( \tau _ { t } ) } & { { } = } \end{array}$ arg $\operatorname* { m a x } _ { u } Q ^ { a ^ { \prime } } ( u , O ( a ^ { \prime } , \tau _ { t } ) )$ and $\mathbf { I }$ is the indicator function.
+
+While the first part corresponds to a filtering operator, in which the indicator function only attributes finite probability to those histories that are consistent with the action taken under greedy execution, the exploration term adds a fixed (history independent) probability, which effectively ‘blurs’ the posterior:
+
+$$
+\begin{array} { r l r } {  { P ( \tau _ { t } | \tau _ { t } ^ { a } , u _ { t } ^ { a ^ { \prime } } ) = \frac { ( ( 1 - \epsilon ) \mathbf { I } ( u ^ { * } ( \tau _ { t } ) , u _ { t } ^ { a ^ { \prime } } ) + \epsilon / | U | ) B ( \tau _ { t } ) } { \sum _ { \tau ^ { \prime } } ( ( 1 - \epsilon ) \mathbf { I } ( u ^ { * } ( \tau ^ { \prime } ) , u _ { t } ^ { a ^ { \prime } } ) + \epsilon / | U | ) B ( \tau ^ { \prime } ) } } } \\ & { } & { = \frac { ( ( 1 - \epsilon ) \mathbf { I } ( u ^ { * } ( \tau _ { t } ) , u _ { t } ^ { a ^ { \prime } } ) + \epsilon / | U | ) B ( \tau _ { t } ) } { \epsilon / | U | + \sum _ { \tau ^ { \prime } } ( ( 1 - \epsilon ) \mathbf { I } ( u ^ { * } ( \tau ^ { \prime } ) , u _ { t } ^ { a ^ { \prime } } ) ) B ( \tau ^ { \prime } ) } } \\ & { } & { = \frac { B ( \tau _ { t } ) } { 1 + | U | \sum _ { s ^ { \prime } } ( ( 1 / \epsilon - 1 ) \mathbf { I } ( u ^ { * } ( \tau ^ { \prime } ) , u _ { t } ^ { a ^ { \prime } } ) B ( \tau ^ { \prime } ) } } \\ & { } & { + \frac { ( ( 1 - \epsilon ) \mathbf { I } ( u ^ { * } ( \tau _ { t } ) , u _ { t } ^ { a ^ { \prime } } ) ) B ( \tau _ { t } ) } { \epsilon / | U | + \sum _ { \tau ^ { \prime } } ( ( 1 - \epsilon ) \mathbf { I } ( u ^ { * } ( \tau ^ { \prime } ) , u _ { t } ^ { a ^ { \prime } } ) ) B ( \tau ^ { \prime } ) } . } \end{array}
+$$
+
+We find that the posterior includes an additional term of the form $B ( \tau _ { t } )$ which carries over an unfiltered density over the trajectories from the prior. We further confirm that in the limit of $\epsilon = 1$ , the posterior collapses to the prior, $P ( \tau _ { t } | \tau _ { t } ^ { a } , u _ { t } ^ { a ^ { \prime } } ) = B ( \tau _ { t } )$ . This can be particularly worrisome in the context of our training setup, whereby different agents run different, and potentially high,  throughout the course of training. It fundamentally makes the beliefs obtained less informative.
+
+While not making the above argument explicitly, the Bayesian Action Decoder (BAD) (Foerster et al., 2019), resolves this issue by shifting exploration to the level of deterministic partial policies, rather than action-level, and tracking an approximate Bayesian belief. As outlined in Section 1 this comes at a huge cost in the complexity of the method, the computation requirements and in the loss of generality of the method.
+
+# 4.3 SIMPLIFIED ACTION DECODING
+
+In this paper we take a drastically simpler and different approach towards the issue. We note that the ‘blurring’, which makes decoding of an action challenging, is entirely due to the $\epsilon$ -greedy exploration term. Furthermore, in order for another agent to do an implicit Bayesian update over an action taken, it is not required that this action is executed by the environment. Indeed, if we assume that other agents can observe the greedy action, $u ^ { * }$ , at every time step and condition their belief update on this, the terms depending on $\epsilon$ disappear from the Bayesian update:
+
+$$
+P ( \tau _ { t } | \tau _ { t } ^ { a } , u ^ { * } ) = \frac { \mathbf { I } ( u ^ { * } ( \tau _ { t } ) , u ^ { * } ) \big ) B ( \tau _ { t } ) } { \sum _ { \tau ^ { \prime } } \mathbf { I } ( u ^ { * } ( \tau ^ { \prime } ) , u ^ { * } ) \big ) B ( \tau ^ { \prime } ) }
+$$
+
+Therefore, to have our cake and eat it, in the Simplified Action Decoder (SAD) the acting agent is allowed to ‘take’ two actions at any given time step during training. The first action, $u ^ { a }$ , is the standard environment action, which gets executed as usual and is observed by all agents through the observation function at the next time step, as mentioned in Section 3. The second action, $u ^ { * }$ , is the greedy action of the active agent. This action does not get executed by the environment but instead is presented as an additional input to the other agents at the next time step, taking advantage of the centralized training regime during which information can be exchanged freely.
+
+Clearly we are not allowed to pass around extra information during decentralized control, but luckily this is not needed. Since we set $\epsilon$ to 0 at test time we can simply use the, now greedy, environment action obtained from the observation function as our greedy-action input.
+
+While this is most straight forward in settings where the last action is observed by other agents directly, in principle SAD can also be extended to settings where it is indirectly observed by all agents through the environment dynamics. In these cases we can replace the greedy-action side-channel with a learned inverse model that recovers the action from the observation history during execution.
+
+Furthermore, to encourage the agent to meaningfully decode the information contained in the greedy action, we can optionally add an auxiliary task to the training process, such as predicting unobserved information from their observation history .
+
+While this idea is compatible with any deep RL algorithm with minimal modifications, we use a recurrent version of DQN with distributed training, dueling networks and prioritized replay. We also learn a joint Q-function using VDN in order to address the challenges of multi-agent off-policy learning, please see Section 3 for details on all of these standard methods.
+
+# 5 EXPERIMENTS
+
+# 5.1 MATRIX GAME
+
+We first verify the effectiveness of SAD in the two step, two player matrix game from Foerster et al. (2019), which replicates the communication through action challenge of Hanabi in a highly simplified setting. In this fully cooperative game each player obtains a privately observed ‘card’, which is drawn iid from two options (1,2).
+
+After observing her card, the first player takes one of three possible discrete actions (1, 2, 3). Crucially, the second player observes both her own private card and the team mate’s action before acting herself, which establishes the opportunity to communicate. The payout is a function of both the two private cards and the two actions taken by both agents, as shown in Figure 1.
+
+Importantly, there are some obvious strategies that do not “Tiny Hanabi”require any communication. For example, if both player learn to play the 2nd action, the payout is always 8 points, independent of the cards dealt. However, if the players do ● Each player knows their learn to communicate it is possible to achieve 10 points for every pair of cards dealt.
+
+# 5.2 HANABI
+
+● Player 2 observes Player Hanabi is a fully cooperative card game in which all play1’s action and acts ers work together to complete piles of cards referred to as second.fireworks. Each card has a rank, 1 to 5, and a color, G / B $/ \textbf { W } / \textbf { Y } / \textbf { R }$ . Each firework (one per color) starts with a 1 and is finished once the 5 has been added. There are three 1s, one 5 and two of all other ranks for each of the colors, adding up to a total of 50 cards in the deck. The twist in Hanabi is that while players can observe the cards held by their team mates, they cannot observe their own cards and thus need to exchange information with each other in order to understand what cards can be played. There are two main means for doing so: First of all, players can take grounded hint actions, in which they reveal the subset of a team mate’s hand that matches a specific rank or color. An example hint is “Your third and fifth card are 1s”. These hint actions cost scarce information tokens, which can be replenished by discarding a card, an action that both removes the card from the game and makes it visible to all players.
+
+![](images/25f404762b879bc27cf6c88933eae05b823c51b2b16509fef1e770d1b412b811.jpg)  
+Figure 1: Illustration of the matrix game from Foerster et al. (2019)
+
+Finally players can also choose to play a card. If this card is the next card for the firework of the corresponding color, it is added to the firework and the team scores one point. Otherwise the card is removed from the game, the identity is made public, and the team loses one of the 3 life tokens. If the team runs out of life tokens before the end of the game, all points collected so far are lost and the game finishes immediately. These rules result in a maximum score of $5 \times 5 = 2 5$ points in any game, which corresponds to all five fireworks being completed with five cards per firework.
+
+To ensure reproducibility and comparability of our results we use the Hanabi Learning Environment (HLE) (Bard et al., 2019) for all experimentation. For further details regarding Hanabi and the self-play part of the Hanabi challenge please see Bard et al. (2019).
+
+# 5.3 ARCHITECTURE AND COMPUTATION REQUIREMENTS
+
+We borrow some ideas and insights from prior distributed Q-learning methods while bring extensions to MARL as well as innovations to improve throughput and efficiency. Following Horgan et al. (2018) and Kapturowski et al. (2019), we use a distributed prioritized replay buffer shared by $N$ asynchronous actors and a centralized trainer that samples mini-batches from the replay buffer to update the model. In each actor thread, we run $K$ environments sequentially and batch their observations together. The observation batch is then fed into an actor that utilize a GPU to compute a batch of actions. All asynchronous actors share one GPU and the trainer uses another GPU for gradient computation and model updates. This is different from prior works which run single actor and single environment in each thread on a CPU. Our method enables us to run a very large number of simulations with moderate computation resources. In all Hanabi experiments, we run $N = 8 0$ actor threads with $K = 8 0$ environments in each thread on single machine with 40 CPU cores and 2 GPUs. Without this architectural improvement, it may require at least a few hundred CPU cores to run 6400 Hanabi environments, in which case neural network agents and simulations have to be distributed across multiple machines, greatly reducing the reproducibility and accessibility of such research. Please refer to Appendix A for implementation details and hyper-parameters.
+
+# 6 RESULTS
+
+# 6.1 MATRIX GAME
+
+As we can see in Figure 2, even in our simple matrix game the greedy action input makes a drastic difference. With an average reward of around 9.5 points, tabular IQL does well in this task, matching the $B A D$ results from Foerster et al. (2019). However, just by adding the greedy action as an additional input, we obtain an average performance of $9 . 9 7 \pm 0 . 0 2$ . Results are averaged over 100 seeds, and shading is s.e.m. The code is available here: www.bit.ly/2mBJLyk.
+
+![](images/5ad1d82f24e9ee7d32e4c518b21671940bf756b1552a474256a05432182b3238.jpg)  
+Figure 2: Results for the matrix game.
+
+# 6.2 HANABI
+
+As shown in Table 1, our findings from the matrix game are for the most part confirmed on the challenging Hanabi benchmark. To illustrate the contributions of the different components, we compare average scores and win rates across 13 independent training runs of SAD and three different options: IQL is simply the recurrent DQN agent with parameter sharing, VDN is the same agent but also learns a joint Q-function and finally SAD & AuxTask is the SAD agent with the auxiliary task.
+
+While we find that SAD significantly outperforms our baselines (IQL and VDN) for 2, 4 and 5 players in terms of average score and/or win rate, there is no significant difference for 3 players, where VDN matches the performance of SAD.
+
+Interestingly, the auxiliary task only significantly helps the 2-player performance, where it substantially boosts the average score and win rate. In contrast, it drastically hurts performance for 3-5 players, which opens an interesting avenue for future work.
+
+For completeness we have included training curves showing average scores and s.e.m. across all training runs for all numbers of players for our methods and ablations in Appendix B. We find that for 5 players the auxiliary task drastically reduces the variance of SAD and intermittently leads to higher performance during training but ultimately results in lower final performance. We can also clearly see that despite 72 hours of training and billions of samples consumed, the performance has not plateaued for 3-5 players, pointing to an obvious avenue for further improvements.
+
+The original numbers in the Hanabi challenge and BAD used population based training (Jaderberg et al., 2018), effectively reporting maximum performance across a large number of different runs. Therefore, for reproducibility purposes, we report evaluations of the best model from our various training runs for each method in Table 2.
+
+As shown, under this reporting we establish a new SOTA for learning methods on the self-play part of the Hanabi challenge for 2-5 players, with the most drastic improvements being achieved for 3-5 players. In particular, we beat both the ACHA agent from Bard et al. (2019) and the BAD agent on average score, even though both of them used population based training and require more compute. We note that while we follow the counting convention proposed by the challenge paper, BAD was optimized for a different counting scheme, in which agents keep their scores when they run out of lives. This may explain the higher win rate $( 5 8 . 6 \% )$ of BAD combined with a relatively low mean score, which is exceeded even by our baseline methods. Once again, only the performance for 2-player is significantly improved by the auxiliary task and the 3-player setting is an outlier in the sense that SAD does not improve the best performance compared to VDN.
+
+# 7 CONCLUSION AND FUTURE WORK
+
+In this paper we presented the Simplified Action Decoder (SAD), a novel deep multi-agent RL algorithm that allows agents to learn communication protocols in settings where no cheap-talk channel is available. On the challenging benchmark Hanabi our work substantially improves the SOTA for an RL method for all numbers of players. For two players SAD establishes a new high-score across any method. Furthermore we accomplish all of this with a method that is both simpler and requires less compute than previous advances. While these are encouraging steps, there is clearly more work to do. In particular, there remains a large performance gap between the numbers achieved by SAD and the known performance of hat-coding strategies (Wu, 2018) for 3-5 players. One possible reason is that SAD does not undertake any explicit exploration in the space of possible conventions. Another promising route for future work is to integrate search with RL, since this has produced SOTA results in a number of different domains including Poker, Go and backgammon.
+
+Table 1: Mean performance of our methods and baselines on Hanabi. We take the final models of 13 independent runs, i.e. 13 models per algorithm per player setting. Each model is evaluated on 100K games. Mean and s.e.m over the mean scores of the 13 models are shown in the table. The second row of each section is the win rate.   
+
+<table><tr><td>Agent</td><td> 2 Players</td><td> 3 Players</td><td> 4 Players</td><td> 5 Players</td></tr><tr><td>IQL (Baseline)</td><td>23.77 ± 0.04 43.88 ± 1.21 %</td><td>23.02 ± 0.10 26.16 ± 2.01 %</td><td>21.99 ± 0.09 10.15 ± 0.86 %</td><td>20.60 ± 0.11 2.27 ± 0.32 %</td></tr><tr><td>VDN</td><td>23.83 ± 0.03</td><td>23.71 ± 0.06</td><td>23.03 ± 0.15</td><td>21.18 ± 0.12</td></tr><tr><td>(Baseline) SAD</td><td>44.97 ± 1.28 % 23.87 ± 0.03</td><td>41.16 ± 1.27 % 23.69 ± 0.05</td><td>23.57 ± 2.20 % 23.27 ± 0.16</td><td>2.26 ± 0.32 % 22.06 ± 0.23</td></tr><tr><td>SAD AuxTask</td><td>47.90 ± 1.10 % 24.02 ± 0.01</td><td>41.12 ± 1.10 % 23.56 ± 0.07</td><td>29.38 ± 2.63 % 22.78 ± 0.10</td><td>7.22 ± 1.29 % 21.47 ± 0.08</td></tr></table>
+
+Table 2: Comparison between the previous SOTA learning methods and ours. We take the best model of 13 runs for each of our methods and baselines. Each model is evaluated on 100K games with different seeds. Mean and s.e.m over the 100K games are shown in the table. The s.e.m. is less than 0.01 for most models. Bold numbers are the best results achieved with learning algorithms. The second row of each section is the win rate.   
+
+<table><tr><td>Agent</td><td>2 Players</td><td> 3 Players</td><td> 4 Players</td><td> 5 Players</td></tr><tr><td>Rainbow (Bard et al., 2019)</td><td>20.64 ± 0.03 2.5%</td><td>18.71 ±0.01 0.2%</td><td>18.00 ± 0.17 0%</td><td>15.26 ± 0.18 0%</td></tr><tr><td>ACHA (Bard et al., 2019)</td><td>22.73 ± 0.12 15.1%</td><td>20.24 ± 0.15 1.1%</td><td>21.57 ± 0.12 2.4%</td><td>16.80 ± 0.13 0%</td></tr><tr><td>BAD (Foerster et al.,2019)</td><td>23.92 ± 0.01 58.56%</td><td>=</td><td>=</td><td>1</td></tr><tr><td>IQL (Baseline) 50.47%</td><td>23.97 ± 0.01 40.25%</td><td>23.69 ± 0.01 19.39%</td><td>22.76 ± 0.01 4.93%</td><td>21.29 ± 0.01</td></tr><tr><td>VDN (Baseline)</td><td>23.96 ± 0.01 50.27%</td><td>23.99 ± 0.01 50.37%</td><td>23.79 ± 0.00 38.86%</td><td>21.80 ± 0.01 4.98%</td></tr><tr><td>SAD</td><td>24.01 ± 0.01 52.39%</td><td>23.93 ± 0.01 48.05%</td><td>23.81 ± 0.01 41.45%</td><td>23.01 ± 0.01 13.93%</td></tr><tr><td>SAD&amp; AuxTask</td><td>24.08 ± 0.01 56.09%</td><td>23.81 ± 0.01 49.74%</td><td>23.47 ± 0.01 33.87%</td><td>22.25 ± 0.01 7.33%</td></tr></table>
+
+# REFERENCES
+
+Chris L Baker, Julian Jara-Ettinger, Rebecca Saxe, and Joshua B Tenenbaum. Rational quantitative attribution of beliefs, desires and percepts in human mentalizing. Nature Human Behaviour, 1(4): 0064, 2017.
+
+Nolan Bard, Jakob N. Foerster, Sarath Chandar, Neil Burch, Marc Lanctot, H. Francis Song, Emilio Parisotto, Vincent Dumoulin, Subhodeep Moitra, Edward Hughes, Iain Dunning, Shibl Mourad, Hugo Larochelle, Marc G. Bellemare, and Michael Bowling. The Hanabi Challenge: A New Frontier for AI Research. arXiv:1902.00506 [cs, stat], February 2019. URL http://arxiv. org/abs/1902.00506. arXiv: 1902.00506.
+
+Noam Brown and Tuomas Sandholm. Superhuman AI for heads-up no-limit poker: Libratus beats top professionals. Science, pp. eaao1733, 2017.
+
+Noam Brown and Tuomas Sandholm. Superhuman AI for multiplayer poker. Science, pp. eaay2400, 2019.
+
+Noam Brown, Tuomas Sandholm, and Brandon Amos. Depth-Limited Solving for ImperfectInformation Games. pp. 14.
+
+Murray Campbell, A Joseph Hoane Jr, and Feng-hsiung Hsu. Deep Blue. Artificial intelligence, 134 (1-2):57–83, 2002.
+
+Rodrigo Canaan, Julian Togelius, Andy Nealen, and Stefan Menzel. Diverse agents for ad-hoc cooperation in hanabi. arXiv preprint arXiv:1907.03840, 2019.
+
+Jakob Foerster, Ioannis Alexandros Assael, Nando de Freitas, and Shimon Whiteson. Learning to communicate with deep multi-agent reinforcement learning. In Advances in Neural Information Processing Systems, pp. 2137–2145, 2016.
+
+Jakob Foerster, Francis Song, Edward Hughes, Neil Burch, Iain Dunning, Shimon Whiteson, Matthew Botvinick, and Michael Bowling. Bayesian action decoder for deep multi-agent reinforcement learning. In International Conference on Machine Learning, pp. 1942–1951, 2019.
+
+Jakob N Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018a.
+
+Jakob N. Foerster, Francis Song, Edward Hughes, Neil Burch, Iain Dunning, Shimon Whiteson, Matthew Botvinick, and Michael Bowling. Bayesian Action Decoder for Deep Multi-Agent Reinforcement Learning. arXiv:1811.01458 [cs], November 2018b. URL http://arxiv. org/abs/1811.01458. arXiv: 1811.01458.
+
+James Goodman. Re-determinizing information set monte carlo tree search in hanabi. arXiv preprint arXiv:1902.06075, 2019.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural Comput., 9(8):1735– 1780, November 1997. ISSN 0899-7667. doi: 10.1162/neco.1997.9.8.1735. URL http://dx. doi.org/10.1162/neco.1997.9.8.1735.
+
+Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado van Hasselt, and David Silver. Distributed prioritized experience replay. CoRR, abs/1803.00933, 2018. URL http://arxiv.org/abs/1803.00933.
+
+Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016.
+
+Max Jaderberg, Wojciech M. Czarnecki, Iain Dunning, Luke Marris, Guy Lever, Antonio Garcia Castaneda, Charles Beattie, Neil C. Rabinowitz, Ari S. Morcos, Avraham Ruderman, Nicolas Sonnerat, Tim Green, Louise Deason, Joel Z. Leibo, David Silver, Demis Hassabis, Koray Kavukcuoglu, and Thore Graepel. Human-level performance in first-person multiplayer games with population-based deep reinforcement learning. arXiv:1807.01281 [cs, stat], July 2018. doi: 10.1126/science.aau6249. URL http://arxiv.org/abs/1807.01281. arXiv: 1807.01281.
+
+Steven Kapturowski, Georg Ostrovski, John Quan, and Will Dabney. RECURRENT EXPERIENCE REPLAY IN DISTRIBUTED REINFORCEMENT LEARNING. pp. 1–19, 2019.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Claire Liang, Julia Proft, Erik Andersen, and Ross A Knepper. Implicit communication of actionable information in human-ai teams. In Proceedings of the 2019 CHI Conference on Human Factors in Computing Systems, pp. 95. ACM, 2019.
+
+Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, OpenAI Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems, pp. 6379–6390, 2017.
+
+Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andrew J Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, et al. Learning to navigate in complex environments. arXiv preprint arXiv:1611.03673, 2016.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 02 2015. URL http://dx.doi.org/10.1038/nature14236.
+
+Matej Moravcík, Martin Schmid, Neil Burch, Viliam Lis ˇ y, Dustin Morrill, Nolan Bard, Trevor \` Davis, Kevin Waugh, Michael Johanson, and Michael Bowling. Deepstack: Expert-level artificial intelligence in heads-up no-limit poker. Science, 356(6337):508–513, 2017.
+
+Ashutosh Nayyar, Aditya Mahajan, and Demosthenis Teneketzis. Decentralized stochastic control with partial history sharing: A common information approach. IEEE Transactions on Automatic Control, 58(7):1644–1658, 2013.
+
+Thanh Thi Nguyen, Ngoc Duy Nguyen, and Saeid Nahavandi. Deep reinforcement learning for multiagent systems: a review of challenges, solutions and applications. arXiv preprint arXiv:1812.11794, 2018.
+
+Arthur O’Dwyer. Hanabi. https://github.com/Quuxplusone/Hanabi, 2019.
+
+Frans A Oliehoek. Decentralized pomdps. In Reinforcement Learning, pp. 471–503. Springer, 2012.
+
+Tabish Rashid, Mikayel Samvelyan, Christian Schröder de Witt, Gregory Farquhar, Jakob N. Foerster, and Shimon Whiteson. QMIX: monotonic value function factorisation for deep multi-agent reinforcement learning. CoRR, abs/1803.11485, 2018. URL http://arxiv.org/abs/ 1803.11485.
+
+Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized Experience Replay. arXiv e-prints, art. arXiv:1511.05952, Nov 2015.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
+
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354, 2017.
+
+David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, et al. A general reinforcement learning algorithm that masters chess, shogi, and go through self-play. Science, 362(6419): 1140–1144, 2018.
+
+Sainbayar Sukhbaatar, arthur szlam, and Rob Fergus. Learning Multiagent Communication with Backpropagation. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 2244–2252. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/ 6398-learning-multiagent-communication-with-backpropagation.pdf.
+
+Peter Sunehag, Guy Lever, Audrunas Gruslys, Wojciech Marian Czarnecki, Vinícius Flores Zambaldi, Max Jaderberg, Marc Lanctot, Nicolas Sonnerat, Joel Z. Leibo, Karl Tuyls, and Thore Graepel. Value-decomposition networks for cooperative multi-agent learning. CoRR, abs/1706.05296, 2017. URL http://arxiv.org/abs/1706.05296.
+
+Richard S. Sutton. Learning to predict by the methods of temporal differences. Mach. Learn., 3(1):9–44, August 1988. ISSN 0885-6125. doi: 10.1023/A:1022633531479. URL https: //doi.org/10.1023/A:1022633531479.
+
+Ming Tan. Multi-agent reinforcement learning: Independent vs. cooperative agents. In Proceedings of the tenth international conference on machine learning, pp. 330–337, 1993.
+
+Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. CoRR, abs/1509.06461, 2015. URL http://arxiv.org/abs/1509.06461.
+
+Ziyu Wang, Nando de Freitas, and Marc Lanctot. Dueling network architectures for deep reinforcement learning. CoRR, abs/1511.06581, 2015. URL http://arxiv.org/abs/1511.06581.
+
+Jeff Wu. Hanabi simulation in rust. https://github.com/WuTheFWasThat/hanabi.rs, 2018.
+
+# A NETWORK ARCHITECTURE AND HYPER-PAMAMETERS FOR HANABI
+
+Our Hanabi agent uses dueling network architecture (Wang et al., 2015). The main body of the network consists of 1 fully connected layer of 512 units and 2 LSTM (Hochreiter & Schmidhuber, 1997) layers of 512 units, followed by two output heads for value and advantages respectively. The same network configuration is used across all Hanabi experiments. We take the default featurization of HLE and replace the card knowledge section with the V0-Belief proposed by Foerster et al. (2019). The maximum length of an episode is capped at 80 steps and the entire episode is stored in the replay buffer as one training sample. This avoids the “slate hidden states” problem as described in Kapturowski et al. (2019) because we can simply initialize the hidden states of LSTM as zero during training. For exploration and experience prioritization, we follow the simple strategy as in Horgan et al. (2018) and Kapturowski et al. (2019). Each actor executes an $\epsilon _ { i }$ -greedy policy where $\epsilon _ { i } = \bar { \epsilon } ^ { 1 + \frac { 1 } { N - 1 } \alpha }$ for $i \in \{ 0 , . . . , N - 1 \}$ but with a smaller $\epsilon = 0 . 1$ and $\alpha = 7$ . For simplicity, all players of a game use the same epsilon. The per time-step priority $\delta _ { t }$ is the TD error and per episode priority is computed following $\delta _ { e } = \eta \operatorname* { m a x } _ { t } \delta _ { i } + ( 1 - \eta ) \hat { \delta }$ where $\eta = 0 . 9$ . Priority exponent is set to 0.9 and importance sampling exponent is set to 0.6. We use $n$ -step return (Sutton, 1988) and double Q-learning (van Hasselt et al., 2015) for target computation during training. The discount factor $\gamma$ is set to 0.999. The network is updated using Adam optimizer (Kingma & Ba, 2014) with learning rate $l r = 6 . 2 5 \times 1 0 ^ { - 5 }$ and $\epsilon = \dot { 1 . 5 } \times 1 0 ^ { - 5 }$ . Trainer sends its network weights to all actors every 10 updates and target network is synchronized with online network every 2500 updates. These hyper-parameters are fixed across all experiments.
+
+In the baseline, we use Independent Q-Learning where each player estimates the Q value and selects action independently at each time-step. Note that all players need to operate on the observations in order to update their recurrent hidden states while only the current player has non-trivial legal moves and other players can only select ‘pass’. Each player then writes its own version of the episode into the prioritized replay buffer and they are sampled independently during training. The prioritized replay buffer contains $2 ^ { 1 7 } ( 1 3 1 0 7 2 )$ episodes. We warm up the replay buffer with 10,000 episodes before training starts. Batch size during training is 128 for games of different numbers of players.
+
+As mentioned in Section 4, the SAD agent is built on top of joint Q-function where the Q value is the sum of the individual Q value of all players given their own actions. One episode produces only one training sample with an extra dimension for the number of players. The replay buffer size is reduced to $2 ^ { 1 6 }$ for 2-player and 3-player games and $2 ^ { 1 5 }$ for 4-player and 5-player games. The batch sizes for 2-, 3-, 4-, 5-players are 64, 43, 32, 26 respectively to account for the fact that each sample contains more data.
+
+Auxiliary task can be added to the agent to help it decode the greedy action more effectively. In Hanabi, the natural choice is the predict the card of player’s own hand. In our experiments, the auxiliary task is to predict the status of a card, which can be playable, discardable, or unknown. The loss is the average cross entropy loss per card and is simply added to the TD-error of reinforcement learning during training.
+
+# B LEARNING CURVES FOR HANABI
+
+![](images/ccf9077cc9f7d726e6a7f0ea3a2fa7941948d5e7bedb2d3bea373709b6945a93.jpg)  
+Figure 3 shows learning curves of different algorithms averaged over 13 seeds per algorithm per player setting. Shading is error of the mean.   
+Figure 3: Learning Curves

parse/train/B1xm3RVtwB/B1xm3RVtwB_content_list.json

@@ -0,0 +1,1551 @@
+[
+    {
+        "type": "text",
+        "text": "SIMPLIFIED ACTION DECODER FOR DEEP MULTI-AGENT REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            781,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hengyuan Hu, Jakob N Foerster Facebook AI Research, CA, USA {hengyuan,jnf}@fb.com ",
+        "bbox": [
+            184,
+            169,
+            410,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In recent years we have seen fast progress on a number of benchmark problems in AI, with modern methods achieving near or super human performance in Go, Poker and Dota. One common aspect of all of these challenges is that they are by design adversarial or, technically speaking, zero-sum. In contrast to these settings, success in the real world commonly requires humans to collaborate and communicate with others, in settings that are, at least partially, cooperative. In the last year, the card game Hanabi has been established as a new benchmark environment for AI to fill this gap. In particular, Hanabi is interesting to humans since it is entirely focused on theory of mind, i.e., the ability to effectively reason over the intentions, beliefs and point of view of other agents when observing their actions. Learning to be informative when observed by others is an interesting challenge for Reinforcement Learning (RL): Fundamentally, RL requires agents to explore in order to discover good policies. However, when done naively, this randomness will inherently make their actions less informative to others during training. We present a new deep multi-agent RL method, the Simplified Action Decoder (SAD), which resolves this contradiction exploiting the centralized training phase. During training SAD allows other agents to not only observe the (exploratory) action chosen, but agents instead also observe the greedy action of their team mates. By combining this simple intuition with best practices for multi-agent learning, SAD establishes a new SOTA for learning methods for 2-5 players on the self-play part of the Hanabi challenge. Our ablations show the contributions of SAD compared with the best practice components. All of our code and trained agents are available at https://github.com/facebookresearch/Hanabi_SAD. ",
+        "bbox": [
+            232,
+            280,
+            764,
+            599
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            627,
+            336,
+            642
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Humans are highly social creatures and spend vast amounts of time coordinating, collaborating and communicating with others. In contrast to these, at least partially, cooperative settings most progress on AI in games has been in zero-sum games where agents compete against each other, typically rendering communication futile. This includes examples such as Go (Silver et al., 2016; 2017; 2018), poker (Brown & Sandholm, 2017; Moravcík et al., 2017; Brown & Sandholm, 2019) ˇ and chess (Campbell et al., 2002). ",
+        "bbox": [
+            174,
+            659,
+            825,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This narrow focus is unfortunate, since communication and coordination require unique abilities. In order to enable smooth and efficient social interactions of groups of people, it is commonly required to reason over the intents, points of views and beliefs of other agents from observing their actions. For example, a driver can reasonably infer that if a truck in front of them is slowing down when approaching an intersection, then there is likely an obstacle ahead. Furthermore, humans are both able to interpret the actions of others and can act in a way that is informative when their actions are being observed by others, capabilities that are commonly called theory of Mind (ToM), (Baker et al., 2017). Importantly, in order to carry out this kind of reasoning, an agent needs to consider why a given action is taken and what this decision indicates about the state of the world. Simply observing what other agents are doing is not sufficient. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While these abilities are particularly relevant in partially observable, fully cooperative multi-agent settings, ToM reasoning clearly matters in a variety of real world scenarios. For example, autonomous cars will likely need to understand the point of view, intents and beliefs of other traffic participants in order to deal with highly interactive settings such as 4-way crossing or dense traffic in cities. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Hanabi is a fully cooperative, partially-observable card game that has recently been proposed as a new benchmark challenge problem for AI research (Bard et al., 2019) to fill the gap around ToM. In Hanabi, players need to find conventions that allow them to effectively exchange information from their local observations through their actions, taking advantage of the fact that actions are observed by all team mates. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            208
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most prior state-of-the-art agents for Hanabi were developed using handcrafted algorithms, which beat off-the-shelf deep multi-agent RL methods by a large margin. This makes intuitive sense: Beyond the “standard” multi-agent challenges of credit assignment, nonstationarity and joint exploration, learning an informative policy presents an additional fundamentally new conflict. On the one hand, an RL agent needs to explore in order to discover good policies through trial and error. On the other hand, when carried out naively, this exploration will add noise to the policy of the agent during the training process, making their actions strictly less informative to their team mates. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            313
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One possible solution to this is to explore in the space of deterministic partial policies, rather than actions, and sample these policies from a distribution that conditions on a common knowledge Bayesian belief. This is successfully carried out in the Bayesian Action Decoder (BAD) (Foerster et al., 2019), the only previous Deep RL method to achieve a state-of-the-art in Hanabi. While this is a notable accomplishment, it comes at the cost of simplicity and generality. For a start, BAD requires an explicit common knowledge Bayesian belief to be tracked, which not only adds computational burden due to the required sampling steps, but also uses expert knowledge regarding the game dynamics. Furthermore, BAD, as presented, is trained using actor-critic methods which are sample inefficient and suffer from local optima. In order to get around this, BAD uses population based training, further increasing the number of samples required. Lastly, BAD’s explicit reliance on common knowledge limits the generality of the method. ",
+        "bbox": [
+            174,
+            320,
+            825,
+            472
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper we propose the Simplified Action Decoder (SAD), a method that achieves a similar goal to BAD, but addresses all of the issues mentioned above. At the core of SAD is a different approach towards resolving the conflict between exploration and being interpretable, which, like BAD, relies on the centralized training with decentralized control (CT/DC) regime. Under CT/DC information can be exchanged freely amongst all agents during centralized training, as long as the final policies are compatible with decentralized execution. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            563
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The key insight is that during training we do not have to chose between being informative, by taking greedy actions, and exploring, by taking random actions. To be informative, the greedy actions do not need to be executed by the environment, but only need to be observed by the team mates. Thus in SAD each agent takes two different actions at each time step: One greedy action, which is not presented to the environment but observed by the team mates at the next time step as an additional input, and the “standard” (exploratory) action that gets executed by the environment and is observed by the team mates as part of the environment dynamics. Importantly, during greedy execution the observed environment action can be used instead of centralized information for the additional input, since now the agent has stopped exploring. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            695
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, to ensure that these greedy actions and observations get decoded into a meaningful representation, we can optionally train an auxiliary task that predicts key hidden game properties from the action-observation trajectories. While we note that this idea is in principle compatible with any kind of model-free deep RL method with minimal modifications to the core algorithm, we use a distributed version of recurrent DQN in order to improve sample efficiency, account for partial observability and reduce the risk of local optima. We also train a joint-action Q-function that consists of the sum of per-agent Q-values to allow for off-policy learning in this multi-agent setting using Value Decomposition Networks (VDN) (Sunehag et al., 2017). ",
+        "bbox": [
+            174,
+            702,
+            825,
+            814
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Using SAD we establish a new SOTA for learning methods for 2-5 players in Hanabi, with a method that not only requires less expert knowledge and compute, but is also more general than previous approaches. In order to ensure that our results can be easily verified and extended, we also evaluate our method on a proof-of-principle matrix game and open-source our training code and agents. Beyond enabling more research into the self-play aspect of Hanabi, we believe these resources will provide a much needed starting point for the ad-hoc teamwork part of the Hanabi challenge. ",
+        "bbox": [
+            174,
+            820,
+            825,
+            905
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            344,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our work relates closely to research on emergent communication protocols using deep multi-agent RL, as first undertaken by Sukhbaatar et al. (2016) and Foerster et al. (2016) . There has been a large number of follow-up papers in this area, so listing all relevant work is beyond the scope and we refer the reader to Nguyen et al. (2018), a recent survey on deep multi-agent RL. One major difference to our work is that the environments considered typically contain a cheap-talk channel, which can be modeled as a continuous variable during the course of training. This allows agents to, for example, use differentiation across the communication channel in order to learn protocols. In contrast, in our setting agents have to communicate through the observable environment actions themselves, requiring fundamentally different methods. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            263
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, our work is an example of cooperative multi-agent learning in partially observable settings under centralized training and decentralized control. There have been a large number of papers in this space, with seminal work including MADDPG (Lowe et al., 2017) and COMA (Foerster et al., 2018a), both of which are actor-critic methods that employ a centralized critic with decentralized actors. Again, we refer the reader to Nguyen et al. (2018) for a more comprehensive survey. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            340
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Until 2018, work on Hanabi had been focused on hand-coded methods and heuristics. Some relevant examples include SmartBot (O’Dwyer, 2019) and the so-called “hat-coding” strategies, as implemented by WTFWThat (Wu, 2018). These strategies use the information theoretic ideas that allow each hint to reveal information to all other agents at the same time. While they do not perform well for 2-player Hanabi due to the smaller action space, they get near perfect scores for 3-5 players. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In contrast, so far learning methods have seen limited success on Hanabi. Bard et al. (2019) undertake a systematic evaluation of current Deep RL methods for 2-5 players in two different regimes and open-source the Hanabi-Learning-Environment (HLE) to foster research on the game. They evaluate a feed-forward version of DQN trained on 100 million samples and a recurrent actor-critic agent with population based training using 20 billion samples. Notably, while both agents achieve near $0 \\%$ win rate for 3-5 players in Hanabim, at a high level their DQN agent is a good starting point for our work. However, since the authors did not propose any specific method of accounting for the issues introduced by $\\epsilon$ -greedy exploration in a ToM task, they resorted to setting $\\epsilon$ to zero after a short burn-in phase. The only state-of-the-art in Hanabi established by an RL agent is from Foerster et al. (2019) which we refer to in more detail in Section 1 and Section 4. Recently there have also been attempts to train agents that are robust to different team-mates (Canaan et al., 2019) and even to extend to human-AI collaboration (Liang et al., 2019). For a more comprehensive review on previous results on Hanabi we refer the reader to Bard et al. (2019). ",
+        "bbox": [
+            174,
+            424,
+            825,
+            604
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Poker is another partially observable multi-agent setting, although it is fundamentally different due to the game being zero-sum. Recent success in Poker has extensively benefited from search (Brown et al.). Examples of using search in Hanabi include Goodman (2019). ",
+        "bbox": [
+            174,
+            612,
+            825,
+            654
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            683,
+            326,
+            699
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 SETTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            719,
+            276,
+            734
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper we assume a Dec-POMDP (Oliehoek, 2012), in which $N$ agents interact in a partially observable environment. At each time step agent $a \\in 1 . . N$ obtains an observation, $o _ { t } ^ { a } = { \\bar { O } } ( s _ { t } , a )$ , where $s _ { t } \\in S$ is the Markov state of the system and $O ( s _ { t } , a )$ is the deterministic observation function. Since we are interested in ToM, in our setting the observation function includes the last action of the acting agent, which is observed by all other agents at the next time step. We note that actions are commonly observable not only in board games but also in some real world multi-agent settings, such as autonomous driving. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For simplicity, we restrict ourselves to turn based settings, in which at each time step only the acting agents takes an action, $u _ { t } ^ { a }$ , which is sampled from their policy, $u ^ { a } \\sim \\pi _ { \\theta } ^ { a } ( u ^ { a } | \\tau ^ { a } )$ , while all other agents take a no-op action. Here $\\tau ^ { a }$ is the action-observation history of agent $a$ , $\\tau ^ { a } = \\{ o _ { 0 } ^ { a } , u _ { 0 } ^ { a } , r _ { 1 } , . . r _ { T } , o _ { T } ^ { a } \\}$ , $T$ is the length of the episode and $\\theta$ are the weights of a function approximator that represents the policy, in our case recurrent neural networks, such as LSTMs (Hochreiter & Schmidhuber, 1997). ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We further use $\\tau _ { t }$ to describe the state-action sequence, $\\tau = \\{ s _ { 0 } , \\mathbf { u _ { 0 } } , r _ { 1 } , . . r _ { T } , s _ { T } \\}$ , where $\\mathbf { u _ { t } }$ is the joint action of all agents. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As is typical in cooperative multi-agent RL, the goal of the agents is to maximize the total expected return, $J _ { \\theta } = \\mathbb { E } _ { \\tau \\sim P ( \\tau \\mid \\theta ) } R _ { 0 } ( \\tau )$ , where $R _ { 0 } ( \\tau )$ is the return of the trajectory (in general $R _ { t } \\bar { ( } \\tau ) ~ =$ $\\sum _ { t ^ { \\prime } \\geq t } \\gamma ^ { t ^ { \\prime } - t } r _ { t ^ { \\prime } } )$ and $\\gamma$ is an optional discount factor. We have also assumed that agents are sharing parameters, $\\theta$ , as is common in cooperative MARL. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            200
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 DISTRIBUTED RECURRENT DQN AND AUXILIARY TASKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            227,
+            612,
+            242
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Q-learning the agent approximates the expected return for a given state action-pair, $s , u$ , assuming that the agent acts greedily with respect to the Q-function for all future time steps, $Q ( s , u ) =$ $\\mathbb { E } _ { \\tau \\sim P ( \\tau | s , u ) } R _ { t } ( \\tau )$ , where $\\tau = \\{ s _ { t } , u _ { t } , r _ { t + 1 } , . . . , s _ { T } \\}$ , $u _ { t } = u$ and $u _ { t ^ { \\prime } } = \\arg \\operatorname* { m a x } _ { u ^ { \\prime } } Q ( s _ { t ^ { \\prime } } , u ^ { \\prime } ) , \\forall t ^ { \\prime } >$ $t$ . A common exploration scheme is $\\epsilon$ -greedy, in which the agent takes a random action with probability $\\epsilon$ and acts greedily otherwise. Importantly, the Q-function can be trained efficiently using the Bellman equation: $Q ( s , u ) = \\mathbb { E } _ { s ^ { \\prime } } [ r _ { t + 1 } + \\gamma \\operatorname* { m a x } _ { u ^ { \\prime } } Q ( s ^ { \\prime } , u ^ { \\prime } ) ]$ , where for simplicity we have assumed a deterministic reward. In Deep Q-Learning (DQN) (Mnih et al., 2015) the Q-function is parameterized by a deep neural network and trained with transitions sampled from experience replay. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            369
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In our work we also incorporate other best practice components of the last few years, including doubleDQN (van Hasselt et al., 2015), dueling network architecture (Wang et al., 2015) and prioritized replay (Schaul et al., 2015). We also employ a distributed training architecture similar to the one proposed by Horgan et al. (2018) where a number of different actors with their own exploration rates collect experiences in parallel and feed them into a central replay buffer. Since our setting is partially observable the natural choice for the function approximator is a recurrent neural network. A combination of these techniques was first explored by Kapturowski et al. (2019) in single agent environments such as Atari and DMLab-30. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            487
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Another common best-practice in RL are auxiliary tasks Mirowski et al. (2016); Jaderberg et al. (2016), in which the agent produces extra output-heads that are trained on supervised tasks and optimized alongside the RL loss. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            536
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 CENTRALISED TRAINING, DECENTRALIZED EXECUTION AND JOINT Q-FUNCTIONS ",
+        "bbox": [
+            176,
+            564,
+            790,
+            579
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The most straight forward application of Q-learning to multi-agent settings is Independent Q-Learning (IQL) (Tan, 1993) in which each agent keeps an independent estimate of the expected return, treating all other agents as part of the environment. One challenge with IQL is that the exploratory behavior of other agents is not corrected for via the max operator in the bootstrap. Notably, IQL does typically not take any advantage of centralized training with decentralised control (CT/DC), a paradigm under which information can be exchanged freely amongst agents during the training phase as long as the policies rely only on local observations during execution. ",
+        "bbox": [
+            173,
+            594,
+            825,
+            693
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "There are various approaches for learning joint-Q-functions in the CT/DC regime. For example, Value-Decomposition-Networks (VDN) (Sunehag et al., 2017) represent the joint-Q-function as a sum of per-agent contributions and QMIX (Rashid et al., 2018) learns a non-linear but monotonic combination of these contributions. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            755
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            785,
+            281,
+            801
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 THEORY OF MIND AND BAYESIAN REASONING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            823,
+            540,
+            838
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "At the very core of interpreting the actions of another agent, and ToM in general, is Bayesian reasoning. Fundamentally, asking what a given action by another agent implies about the state of the world requires understanding of why this action was taken. To illustrate this, we start out with an agent that has a given belief about the state-action history of the world, $\\tau _ { t }$ , given her own action-observation history $\\tau _ { t } ^ { a }$ : $B ( \\tau _ { t } ) = P ( \\tau _ { t } | \\tau _ { t } ^ { a } )$ . ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next the agent observes the action $u _ { t } ^ { a ^ { \\prime } }$ of her team mate, $a ^ { \\prime }$ , and carries out a Bayesian update: ",
+        "bbox": [
+            169,
+            102,
+            792,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a2a28603de33f151bf7cd0c953e46f71ea22ac1ecdfe82cad7f1eacf3ca3f110.jpg",
+        "text": "$$\n\\begin{array} { r l } & { P ( \\tau _ { t } | \\tau _ { t } ^ { a } , u _ { t } ^ { a ^ { \\prime } } ) = \\frac { P ( u _ { t } ^ { a ^ { \\prime } } | \\tau _ { t } ) P ( \\tau _ { t } | \\tau _ { t } ^ { a } ) } { \\sum _ { \\tau _ { t } ^ { \\prime } } P ( u _ { t } ^ { a ^ { \\prime } } | \\tau _ { t } ^ { \\prime } ) P ( \\tau _ { t } ^ { \\prime } | \\tau _ { t } ^ { a } ) } } \\\\ & { \\qquad = \\frac { \\pi ^ { a ^ { \\prime } } ( u _ { t } ^ { a ^ { \\prime } } | O ( a ^ { \\prime } , \\tau _ { t } ) ) B ( \\tau _ { t } ) } { \\sum _ { \\tau _ { t } ^ { \\prime } } \\pi ^ { a ^ { \\prime } } ( u _ { t } ^ { a ^ { \\prime } } | O ( a ^ { \\prime } , \\tau _ { t } ^ { \\prime } ) ) B ( \\tau _ { t } ^ { \\prime } ) } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            126,
+            655,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where, with a slight abuse of notation, we have used (and will keep using) $O ( a ^ { \\prime } , \\tau _ { t } )$ for the actionobservation history, $\\tau _ { t } ^ { a ^ { \\prime } }$ , that results from applying the observation function for agent $a ^ { \\prime }$ to $\\tau _ { t }$ at each time step. Note that for non-deterministic observation functions we would have to marginalize over $P ( \\tau _ { t } ^ { a ^ { \\prime } } | \\bar { \\tau _ { t } } )$ . ",
+        "bbox": [
+            173,
+            222,
+            826,
+            282
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Clearly, since agents have access to the policy of their teammate during centralised training, we could in principle evaluate this explicit Bayesian belief. However, beyond the practical difficulty of computing this explicit belief, when it is used as an input to the policy it will lead to prohibitively costly higher order beliefs. The typical workout for this is a public belief over private features which only conditions on common knowledge and can therefore be calculated by all agents individually, we refer to Moravcík et al. (2017); Nayyar et al. (2013); Foerster et al. (2018b) for more details. ˇ ",
+        "bbox": [
+            173,
+            289,
+            825,
+            373
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Instead, in this work we rely on RNNs to learn implicit representations of the sufficient statistics over the distribution of the Markov state given the action-observation histories, noting that they are unlikely to recover exact beliefs due to the issues mentioned above. ",
+        "bbox": [
+            176,
+            380,
+            821,
+            422
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPLORATION AND BELIEFS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            440,
+            413,
+            455
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Next we illustrate the impact of exploration on the beliefs, which we will do in the explicit (exact) case, since it serves as an upper bound on the accuracy of the implicit beliefs. Since we are looking at fully-cooperative settings we assume that the optimal policy of the agent is deterministic and any randomness is due to exploration. Given that we are focused on value based methods we furthermore assume an $\\epsilon$ -greedy exploration scheme, noting that the same analysis can be extended to other methods. Under this exploration scheme $\\pi ^ { a ^ { \\prime } } ( u _ { t } ^ { a ^ { \\prime } } | O ( a ^ { \\prime } , \\tau _ { t } ) )$ ) becomes: ",
+        "bbox": [
+            173,
+            465,
+            825,
+            554
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0a52e16234105ddd8c60fd2ee098383204ea93e1db137247763f8bfdcacb7de2.jpg",
+        "text": "$$\n\\pi ^ { a ^ { \\prime } } ( u _ { t } ^ { a ^ { \\prime } } | O ( a ^ { \\prime } , \\tau _ { t } ) ) = ( 1 - \\epsilon ) \\mathbf { I } ( u ^ { * } ( \\tau _ { t } ) , u _ { t } ^ { a ^ { \\prime } } ) + \\epsilon / | U | ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            560,
+            671,
+            582
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we have used $\\boldsymbol { u } ^ { * } ( \\tau _ { t } )$ to indicate the greedy action of the agent $a ^ { \\prime }$ , $\\begin{array} { r l } { u ^ { * } ( \\tau _ { t } ) } & { { } = } \\end{array}$ arg $\\operatorname* { m a x } _ { u } Q ^ { a ^ { \\prime } } ( u , O ( a ^ { \\prime } , \\tau _ { t } ) )$ and $\\mathbf { I }$ is the indicator function. ",
+        "bbox": [
+            173,
+            588,
+            823,
+            619
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While the first part corresponds to a filtering operator, in which the indicator function only attributes finite probability to those histories that are consistent with the action taken under greedy execution, the exploration term adds a fixed (history independent) probability, which effectively ‘blurs’ the posterior: ",
+        "bbox": [
+            174,
+            626,
+            825,
+            683
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8c13d7bf6f8e98e87f500ef80bef560a22101e5bea382a8ce2a57da50625424b.jpg",
+        "text": "$$\n\\begin{array} { r l r } {  { P ( \\tau _ { t } | \\tau _ { t } ^ { a } , u _ { t } ^ { a ^ { \\prime } } ) = \\frac { ( ( 1 - \\epsilon ) \\mathbf { I } ( u ^ { * } ( \\tau _ { t } ) , u _ { t } ^ { a ^ { \\prime } } ) + \\epsilon / | U | ) B ( \\tau _ { t } ) } { \\sum _ { \\tau ^ { \\prime } } ( ( 1 - \\epsilon ) \\mathbf { I } ( u ^ { * } ( \\tau ^ { \\prime } ) , u _ { t } ^ { a ^ { \\prime } } ) + \\epsilon / | U | ) B ( \\tau ^ { \\prime } ) } } } \\\\ & { } & { = \\frac { ( ( 1 - \\epsilon ) \\mathbf { I } ( u ^ { * } ( \\tau _ { t } ) , u _ { t } ^ { a ^ { \\prime } } ) + \\epsilon / | U | ) B ( \\tau _ { t } ) } { \\epsilon / | U | + \\sum _ { \\tau ^ { \\prime } } ( ( 1 - \\epsilon ) \\mathbf { I } ( u ^ { * } ( \\tau ^ { \\prime } ) , u _ { t } ^ { a ^ { \\prime } } ) ) B ( \\tau ^ { \\prime } ) } } \\\\ & { } & { = \\frac { B ( \\tau _ { t } ) } { 1 + | U | \\sum _ { s ^ { \\prime } } ( ( 1 / \\epsilon - 1 ) \\mathbf { I } ( u ^ { * } ( \\tau ^ { \\prime } ) , u _ { t } ^ { a ^ { \\prime } } ) B ( \\tau ^ { \\prime } ) } } \\\\ & { } & { + \\frac { ( ( 1 - \\epsilon ) \\mathbf { I } ( u ^ { * } ( \\tau _ { t } ) , u _ { t } ^ { a ^ { \\prime } } ) ) B ( \\tau _ { t } ) } { \\epsilon / | U | + \\sum _ { \\tau ^ { \\prime } } ( ( 1 - \\epsilon ) \\mathbf { I } ( u ^ { * } ( \\tau ^ { \\prime } ) , u _ { t } ^ { a ^ { \\prime } } ) ) B ( \\tau ^ { \\prime } ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            708,
+            699,
+            867
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We find that the posterior includes an additional term of the form $B ( \\tau _ { t } )$ which carries over an unfiltered density over the trajectories from the prior. We further confirm that in the limit of $\\epsilon = 1$ , the posterior collapses to the prior, $P ( \\tau _ { t } | \\tau _ { t } ^ { a } , u _ { t } ^ { a ^ { \\prime } } ) = B ( \\tau _ { t } )$ . This can be particularly worrisome in the context of our training setup, whereby different agents run different, and potentially high, \u000f throughout the course of training. It fundamentally makes the beliefs obtained less informative. ",
+        "bbox": [
+            173,
+            878,
+            825,
+            925
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While not making the above argument explicitly, the Bayesian Action Decoder (BAD) (Foerster et al., 2019), resolves this issue by shifting exploration to the level of deterministic partial policies, rather than action-level, and tracking an approximate Bayesian belief. As outlined in Section 1 this comes at a huge cost in the complexity of the method, the computation requirements and in the loss of generality of the method. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            208
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 SIMPLIFIED ACTION DECODING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            227,
+            436,
+            242
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this paper we take a drastically simpler and different approach towards the issue. We note that the ‘blurring’, which makes decoding of an action challenging, is entirely due to the $\\epsilon$ -greedy exploration term. Furthermore, in order for another agent to do an implicit Bayesian update over an action taken, it is not required that this action is executed by the environment. Indeed, if we assume that other agents can observe the greedy action, $u ^ { * }$ , at every time step and condition their belief update on this, the terms depending on $\\epsilon$ disappear from the Bayesian update: ",
+        "bbox": [
+            173,
+            253,
+            825,
+            338
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/62bf5170694637a8ab7015c0a7a0e4aeece9279c0b2d28977289192fc59283c5.jpg",
+        "text": "$$\nP ( \\tau _ { t } | \\tau _ { t } ^ { a } , u ^ { * } ) = \\frac { \\mathbf { I } ( u ^ { * } ( \\tau _ { t } ) , u ^ { * } ) \\big ) B ( \\tau _ { t } ) } { \\sum _ { \\tau ^ { \\prime } } \\mathbf { I } ( u ^ { * } ( \\tau ^ { \\prime } ) , u ^ { * } ) \\big ) B ( \\tau ^ { \\prime } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            347,
+            640,
+            385
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Therefore, to have our cake and eat it, in the Simplified Action Decoder (SAD) the acting agent is allowed to ‘take’ two actions at any given time step during training. The first action, $u ^ { a }$ , is the standard environment action, which gets executed as usual and is observed by all agents through the observation function at the next time step, as mentioned in Section 3. The second action, $u ^ { * }$ , is the greedy action of the active agent. This action does not get executed by the environment but instead is presented as an additional input to the other agents at the next time step, taking advantage of the centralized training regime during which information can be exchanged freely. ",
+        "bbox": [
+            173,
+            398,
+            825,
+            497
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Clearly we are not allowed to pass around extra information during decentralized control, but luckily this is not needed. Since we set $\\epsilon$ to 0 at test time we can simply use the, now greedy, environment action obtained from the observation function as our greedy-action input. ",
+        "bbox": [
+            176,
+            503,
+            821,
+            546
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While this is most straight forward in settings where the last action is observed by other agents directly, in principle SAD can also be extended to settings where it is indirectly observed by all agents through the environment dynamics. In these cases we can replace the greedy-action side-channel with a learned inverse model that recovers the action from the observation history during execution. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            608
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, to encourage the agent to meaningfully decode the information contained in the greedy action, we can optionally add an auxiliary task to the training process, such as predicting unobserved information from their observation history . ",
+        "bbox": [
+            176,
+            614,
+            823,
+            657
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While this idea is compatible with any deep RL algorithm with minimal modifications, we use a recurrent version of DQN with distributed training, dueling networks and prioritized replay. We also learn a joint Q-function using VDN in order to address the challenges of multi-agent off-policy learning, please see Section 3 for details on all of these standard methods. ",
+        "bbox": [
+            174,
+            664,
+            825,
+            720
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            742,
+            326,
+            758
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 MATRIX GAME ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            775,
+            321,
+            790
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first verify the effectiveness of SAD in the two step, two player matrix game from Foerster et al. (2019), which replicates the communication through action challenge of Hanabi in a highly simplified setting. In this fully cooperative game each player obtains a privately observed ‘card’, which is drawn iid from two options (1,2). ",
+        "bbox": [
+            173,
+            801,
+            825,
+            858
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "After observing her card, the first player takes one of three possible discrete actions (1, 2, 3). Crucially, the second player observes both her own private card and the team mate’s action before acting herself, which establishes the opportunity to communicate. The payout is a function of both the two private cards and the two actions taken by both agents, as shown in Figure 1. ",
+        "bbox": [
+            174,
+            864,
+            825,
+            921
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Importantly, there are some obvious strategies that do not “Tiny Hanabi”require any communication. For example, if both player learn to play the 2nd action, the payout is always 8 points, independent of the cards dealt. However, if the players do ● Each player knows their learn to communicate it is possible to achieve 10 points for every pair of cards dealt. ",
+        "bbox": [
+            174,
+            103,
+            549,
+            186
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 HANABI ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            204,
+            272,
+            218
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "● Player 2 observes Player Hanabi is a fully cooperative card game in which all play1’s action and acts ers work together to complete piles of cards referred to as second.fireworks. Each card has a rank, 1 to 5, and a color, G / B $/ \\textbf { W } / \\textbf { Y } / \\textbf { R }$ . Each firework (one per color) starts with a 1 and is finished once the 5 has been added. There are three 1s, one 5 and two of all other ranks for each of the colors, adding up to a total of 50 cards in the deck. The twist in Hanabi is that while players can observe the cards held by their team mates, they cannot observe their own cards and thus need to exchange information with each other in order to understand what cards can be played. There are two main means for doing so: First of all, players can take grounded hint actions, in which they reveal the subset of a team mate’s hand that matches a specific rank or color. An example hint is “Your third and fifth card are 1s”. These hint actions cost scarce information tokens, which can be replenished by discarding a card, an action that both removes the card from the game and makes it visible to all players. ",
+        "bbox": [
+            174,
+            231,
+            549,
+            354
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/25f404762b879bc27cf6c88933eae05b823c51b2b16509fef1e770d1b412b811.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of the matrix game from Foerster et al. (2019) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            563,
+            109,
+            818,
+            306
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            356,
+            825,
+            439
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally players can also choose to play a card. If this card is the next card for the firework of the corresponding color, it is added to the firework and the team scores one point. Otherwise the card is removed from the game, the identity is made public, and the team loses one of the 3 life tokens. If the team runs out of life tokens before the end of the game, all points collected so far are lost and the game finishes immediately. These rules result in a maximum score of $5 \\times 5 = 2 5$ points in any game, which corresponds to all five fireworks being completed with five cards per firework. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            529
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To ensure reproducibility and comparability of our results we use the Hanabi Learning Environment (HLE) (Bard et al., 2019) for all experimentation. For further details regarding Hanabi and the self-play part of the Hanabi challenge please see Bard et al. (2019). ",
+        "bbox": [
+            174,
+            536,
+            825,
+            578
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 ARCHITECTURE AND COMPUTATION REQUIREMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            595,
+            583,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We borrow some ideas and insights from prior distributed Q-learning methods while bring extensions to MARL as well as innovations to improve throughput and efficiency. Following Horgan et al. (2018) and Kapturowski et al. (2019), we use a distributed prioritized replay buffer shared by $N$ asynchronous actors and a centralized trainer that samples mini-batches from the replay buffer to update the model. In each actor thread, we run $K$ environments sequentially and batch their observations together. The observation batch is then fed into an actor that utilize a GPU to compute a batch of actions. All asynchronous actors share one GPU and the trainer uses another GPU for gradient computation and model updates. This is different from prior works which run single actor and single environment in each thread on a CPU. Our method enables us to run a very large number of simulations with moderate computation resources. In all Hanabi experiments, we run $N = 8 0$ actor threads with $K = 8 0$ environments in each thread on single machine with 40 CPU cores and 2 GPUs. Without this architectural improvement, it may require at least a few hundred CPU cores to run 6400 Hanabi environments, in which case neural network agents and simulations have to be distributed across multiple machines, greatly reducing the reproducibility and accessibility of such research. Please refer to Appendix A for implementation details and hyper-parameters. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            829
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            281,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.1 MATRIX GAME ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            320,
+            148
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As we can see in Figure 2, even in our simple matrix game the greedy action input makes a drastic difference. With an average reward of around 9.5 points, tabular IQL does well in this task, matching the $B A D$ results from Foerster et al. (2019). However, just by adding the greedy action as an additional input, we obtain an average performance of $9 . 9 7 \\pm 0 . 0 2$ . Results are averaged over 100 seeds, and shading is s.e.m. The code is available here: www.bit.ly/2mBJLyk. ",
+        "bbox": [
+            174,
+            161,
+            517,
+            300
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/5ad1d82f24e9ee7d32e4c518b21671940bf756b1552a474256a05432182b3238.jpg",
+        "image_caption": [
+            "Figure 2: Results for the matrix game. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            534,
+            103,
+            800,
+            303
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.2 HANABI ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            319,
+            272,
+            333
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 1, our findings from the matrix game are for the most part confirmed on the challenging Hanabi benchmark. To illustrate the contributions of the different components, we compare average scores and win rates across 13 independent training runs of SAD and three different options: IQL is simply the recurrent DQN agent with parameter sharing, VDN is the same agent but also learns a joint Q-function and finally SAD & AuxTask is the SAD agent with the auxiliary task. ",
+        "bbox": [
+            174,
+            345,
+            825,
+            415
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While we find that SAD significantly outperforms our baselines (IQL and VDN) for 2, 4 and 5 players in terms of average score and/or win rate, there is no significant difference for 3 players, where VDN matches the performance of SAD. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            464
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, the auxiliary task only significantly helps the 2-player performance, where it substantially boosts the average score and win rate. In contrast, it drastically hurts performance for 3-5 players, which opens an interesting avenue for future work. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            513
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For completeness we have included training curves showing average scores and s.e.m. across all training runs for all numbers of players for our methods and ablations in Appendix B. We find that for 5 players the auxiliary task drastically reduces the variance of SAD and intermittently leads to higher performance during training but ultimately results in lower final performance. We can also clearly see that despite 72 hours of training and billions of samples consumed, the performance has not plateaued for 3-5 players, pointing to an obvious avenue for further improvements. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            604
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The original numbers in the Hanabi challenge and BAD used population based training (Jaderberg et al., 2018), effectively reporting maximum performance across a large number of different runs. Therefore, for reproducibility purposes, we report evaluations of the best model from our various training runs for each method in Table 2. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            666
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As shown, under this reporting we establish a new SOTA for learning methods on the self-play part of the Hanabi challenge for 2-5 players, with the most drastic improvements being achieved for 3-5 players. In particular, we beat both the ACHA agent from Bard et al. (2019) and the BAD agent on average score, even though both of them used population based training and require more compute. We note that while we follow the counting convention proposed by the challenge paper, BAD was optimized for a different counting scheme, in which agents keep their scores when they run out of lives. This may explain the higher win rate $( 5 8 . 6 \\% )$ of BAD combined with a relatively low mean score, which is exceeded even by our baseline methods. Once again, only the performance for 2-player is significantly improved by the auxiliary task and the 3-player setting is an outlier in the sense that SAD does not improve the best performance compared to VDN. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            813
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            835,
+            495,
+            852
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper we presented the Simplified Action Decoder (SAD), a novel deep multi-agent RL algorithm that allows agents to learn communication protocols in settings where no cheap-talk channel is available. On the challenging benchmark Hanabi our work substantially improves the SOTA for an RL method for all numbers of players. For two players SAD establishes a new high-score across any method. Furthermore we accomplish all of this with a method that is both simpler and requires less compute than previous advances. While these are encouraging steps, there is clearly more work to do. In particular, there remains a large performance gap between the numbers achieved by SAD and the known performance of hat-coding strategies (Wu, 2018) for 3-5 players. One possible reason is that SAD does not undertake any explicit exploration in the space of possible conventions. Another promising route for future work is to integrate search with RL, since this has produced SOTA results in a number of different domains including Poker, Go and backgammon. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/06f1e8f230e055bf72fef14c157586d32d70dba51aea45b44487b3a4cfae18fc.jpg",
+        "table_caption": [
+            "Table 1: Mean performance of our methods and baselines on Hanabi. We take the final models of 13 independent runs, i.e. 13 models per algorithm per player setting. Each model is evaluated on 100K games. Mean and s.e.m over the mean scores of the 13 models are shown in the table. The second row of each section is the win rate. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Agent</td><td> 2 Players</td><td> 3 Players</td><td> 4 Players</td><td> 5 Players</td></tr><tr><td>IQL (Baseline)</td><td>23.77 ± 0.04 43.88 ± 1.21 %</td><td>23.02 ± 0.10 26.16 ± 2.01 %</td><td>21.99 ± 0.09 10.15 ± 0.86 %</td><td>20.60 ± 0.11 2.27 ± 0.32 %</td></tr><tr><td>VDN</td><td>23.83 ± 0.03</td><td>23.71 ± 0.06</td><td>23.03 ± 0.15</td><td>21.18 ± 0.12</td></tr><tr><td>(Baseline) SAD</td><td>44.97 ± 1.28 % 23.87 ± 0.03</td><td>41.16 ± 1.27 % 23.69 ± 0.05</td><td>23.57 ± 2.20 % 23.27 ± 0.16</td><td>2.26 ± 0.32 % 22.06 ± 0.23</td></tr><tr><td>SAD AuxTask</td><td>47.90 ± 1.10 % 24.02 ± 0.01</td><td>41.12 ± 1.10 % 23.56 ± 0.07</td><td>29.38 ± 2.63 % 22.78 ± 0.10</td><td>7.22 ± 1.29 % 21.47 ± 0.08</td></tr></table>",
+        "bbox": [
+            210,
+            103,
+            787,
+            262
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/20d58361e17764c14fcd32f70066f1ef6e07903eb74e90302ea7c9ff64241dd4.jpg",
+        "table_caption": [
+            "Table 2: Comparison between the previous SOTA learning methods and ours. We take the best model of 13 runs for each of our methods and baselines. Each model is evaluated on 100K games with different seeds. Mean and s.e.m over the 100K games are shown in the table. The s.e.m. is less than 0.01 for most models. Bold numbers are the best results achieved with learning algorithms. The second row of each section is the win rate. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Agent</td><td>2 Players</td><td> 3 Players</td><td> 4 Players</td><td> 5 Players</td></tr><tr><td>Rainbow (Bard et al., 2019)</td><td>20.64 ± 0.03 2.5%</td><td>18.71 ±0.01 0.2%</td><td>18.00 ± 0.17 0%</td><td>15.26 ± 0.18 0%</td></tr><tr><td>ACHA (Bard et al., 2019)</td><td>22.73 ± 0.12 15.1%</td><td>20.24 ± 0.15 1.1%</td><td>21.57 ± 0.12 2.4%</td><td>16.80 ± 0.13 0%</td></tr><tr><td>BAD (Foerster et al.,2019)</td><td>23.92 ± 0.01 58.56%</td><td>=</td><td>=</td><td>1</td></tr><tr><td>IQL (Baseline) 50.47%</td><td>23.97 ± 0.01 40.25%</td><td>23.69 ± 0.01 19.39%</td><td>22.76 ± 0.01 4.93%</td><td>21.29 ± 0.01</td></tr><tr><td>VDN (Baseline)</td><td>23.96 ± 0.01 50.27%</td><td>23.99 ± 0.01 50.37%</td><td>23.79 ± 0.00 38.86%</td><td>21.80 ± 0.01 4.98%</td></tr><tr><td>SAD</td><td>24.01 ± 0.01 52.39%</td><td>23.93 ± 0.01 48.05%</td><td>23.81 ± 0.01 41.45%</td><td>23.01 ± 0.01 13.93%</td></tr><tr><td>SAD&amp; AuxTask</td><td>24.08 ± 0.01 56.09%</td><td>23.81 ± 0.01 49.74%</td><td>23.47 ± 0.01 33.87%</td><td>22.25 ± 0.01 7.33%</td></tr></table>",
+        "bbox": [
+            205,
+            337,
+            792,
+            603
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            700,
+            825,
+            799
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chris L Baker, Julian Jara-Ettinger, Rebecca Saxe, and Joshua B Tenenbaum. Rational quantitative attribution of beliefs, desires and percepts in human mentalizing. Nature Human Behaviour, 1(4): 0064, 2017. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            167
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nolan Bard, Jakob N. Foerster, Sarath Chandar, Neil Burch, Marc Lanctot, H. Francis Song, Emilio Parisotto, Vincent Dumoulin, Subhodeep Moitra, Edward Hughes, Iain Dunning, Shibl Mourad, Hugo Larochelle, Marc G. Bellemare, and Michael Bowling. The Hanabi Challenge: A New Frontier for AI Research. arXiv:1902.00506 [cs, stat], February 2019. URL http://arxiv. org/abs/1902.00506. arXiv: 1902.00506. ",
+        "bbox": [
+            174,
+            175,
+            826,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Noam Brown and Tuomas Sandholm. Superhuman AI for heads-up no-limit poker: Libratus beats top professionals. Science, pp. eaao1733, 2017. ",
+        "bbox": [
+            173,
+            253,
+            825,
+            282
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Noam Brown and Tuomas Sandholm. Superhuman AI for multiplayer poker. Science, pp. eaay2400, 2019. ",
+        "bbox": [
+            173,
+            290,
+            825,
+            319
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Noam Brown, Tuomas Sandholm, and Brandon Amos. Depth-Limited Solving for ImperfectInformation Games. pp. 14. ",
+        "bbox": [
+            173,
+            327,
+            825,
+            356
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Murray Campbell, A Joseph Hoane Jr, and Feng-hsiung Hsu. Deep Blue. Artificial intelligence, 134 (1-2):57–83, 2002. ",
+        "bbox": [
+            173,
+            363,
+            825,
+            392
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rodrigo Canaan, Julian Togelius, Andy Nealen, and Stefan Menzel. Diverse agents for ad-hoc cooperation in hanabi. arXiv preprint arXiv:1907.03840, 2019. ",
+        "bbox": [
+            171,
+            400,
+            823,
+            429
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jakob Foerster, Ioannis Alexandros Assael, Nando de Freitas, and Shimon Whiteson. Learning to communicate with deep multi-agent reinforcement learning. In Advances in Neural Information Processing Systems, pp. 2137–2145, 2016. ",
+        "bbox": [
+            173,
+            435,
+            825,
+            479
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jakob Foerster, Francis Song, Edward Hughes, Neil Burch, Iain Dunning, Shimon Whiteson, Matthew Botvinick, and Michael Bowling. Bayesian action decoder for deep multi-agent reinforcement learning. In International Conference on Machine Learning, pp. 1942–1951, 2019. ",
+        "bbox": [
+            173,
+            487,
+            825,
+            530
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jakob N Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. Counterfactual multi-agent policy gradients. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018a. ",
+        "bbox": [
+            173,
+            537,
+            825,
+            580
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jakob N. Foerster, Francis Song, Edward Hughes, Neil Burch, Iain Dunning, Shimon Whiteson, Matthew Botvinick, and Michael Bowling. Bayesian Action Decoder for Deep Multi-Agent Reinforcement Learning. arXiv:1811.01458 [cs], November 2018b. URL http://arxiv. org/abs/1811.01458. arXiv: 1811.01458. ",
+        "bbox": [
+            173,
+            588,
+            826,
+            643
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James Goodman. Re-determinizing information set monte carlo tree search in hanabi. arXiv preprint arXiv:1902.06075, 2019. ",
+        "bbox": [
+            169,
+            651,
+            823,
+            680
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural Comput., 9(8):1735– 1780, November 1997. ISSN 0899-7667. doi: 10.1162/neco.1997.9.8.1735. URL http://dx. doi.org/10.1162/neco.1997.9.8.1735. ",
+        "bbox": [
+            173,
+            689,
+            826,
+            731
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado van Hasselt, and David Silver. Distributed prioritized experience replay. CoRR, abs/1803.00933, 2018. URL http://arxiv.org/abs/1803.00933. ",
+        "bbox": [
+            173,
+            738,
+            825,
+            781
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016. ",
+        "bbox": [
+            174,
+            789,
+            825,
+            832
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Wojciech M. Czarnecki, Iain Dunning, Luke Marris, Guy Lever, Antonio Garcia Castaneda, Charles Beattie, Neil C. Rabinowitz, Ari S. Morcos, Avraham Ruderman, Nicolas Sonnerat, Tim Green, Louise Deason, Joel Z. Leibo, David Silver, Demis Hassabis, Koray Kavukcuoglu, and Thore Graepel. Human-level performance in first-person multiplayer games with population-based deep reinforcement learning. arXiv:1807.01281 [cs, stat], July 2018. doi: 10.1126/science.aau6249. URL http://arxiv.org/abs/1807.01281. arXiv: 1807.01281. ",
+        "bbox": [
+            174,
+            840,
+            826,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Steven Kapturowski, Georg Ostrovski, John Quan, and Will Dabney. RECURRENT EXPERIENCE REPLAY IN DISTRIBUTED REINFORCEMENT LEARNING. pp. 1–19, 2019. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            171,
+            143,
+            823,
+            172
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Claire Liang, Julia Proft, Erik Andersen, and Ross A Knepper. Implicit communication of actionable information in human-ai teams. In Proceedings of the 2019 CHI Conference on Human Factors in Computing Systems, pp. 95. ACM, 2019. ",
+        "bbox": [
+            173,
+            185,
+            825,
+            227
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, OpenAI Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems, pp. 6379–6390, 2017. ",
+        "bbox": [
+            174,
+            239,
+            823,
+            282
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andrew J Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, et al. Learning to navigate in complex environments. arXiv preprint arXiv:1611.03673, 2016. ",
+        "bbox": [
+            174,
+            294,
+            825,
+            337
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 02 2015. URL http://dx.doi.org/10.1038/nature14236. ",
+        "bbox": [
+            174,
+            348,
+            826,
+            420
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matej Moravcík, Martin Schmid, Neil Burch, Viliam Lis ˇ y, Dustin Morrill, Nolan Bard, Trevor \\` Davis, Kevin Waugh, Michael Johanson, and Michael Bowling. Deepstack: Expert-level artificial intelligence in heads-up no-limit poker. Science, 356(6337):508–513, 2017. ",
+        "bbox": [
+            174,
+            431,
+            825,
+            473
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashutosh Nayyar, Aditya Mahajan, and Demosthenis Teneketzis. Decentralized stochastic control with partial history sharing: A common information approach. IEEE Transactions on Automatic Control, 58(7):1644–1658, 2013. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            529
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thanh Thi Nguyen, Ngoc Duy Nguyen, and Saeid Nahavandi. Deep reinforcement learning for multiagent systems: a review of challenges, solutions and applications. arXiv preprint arXiv:1812.11794, 2018. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            583
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arthur O’Dwyer. Hanabi. https://github.com/Quuxplusone/Hanabi, 2019. ",
+        "bbox": [
+            171,
+            595,
+            758,
+            611
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Frans A Oliehoek. Decentralized pomdps. In Reinforcement Learning, pp. 471–503. Springer, 2012. ",
+        "bbox": [
+            173,
+            622,
+            823,
+            637
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tabish Rashid, Mikayel Samvelyan, Christian Schröder de Witt, Gregory Farquhar, Jakob N. Foerster, and Shimon Whiteson. QMIX: monotonic value function factorisation for deep multi-agent reinforcement learning. CoRR, abs/1803.11485, 2018. URL http://arxiv.org/abs/ 1803.11485. ",
+        "bbox": [
+            174,
+            648,
+            826,
+            705
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, John Quan, Ioannis Antonoglou, and David Silver. Prioritized Experience Replay. arXiv e-prints, art. arXiv:1511.05952, Nov 2015. ",
+        "bbox": [
+            171,
+            717,
+            825,
+            746
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            801
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354, 2017. ",
+        "bbox": [
+            176,
+            813,
+            825,
+            856
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, et al. A general reinforcement learning algorithm that masters chess, shogi, and go through self-play. Science, 362(6419): 1140–1144, 2018. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, arthur szlam, and Rob Fergus. Learning Multiagent Communication with Backpropagation. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 2244–2252. Curran Associates, Inc., 2016. URL http://papers.nips.cc/paper/ 6398-learning-multiagent-communication-with-backpropagation.pdf. ",
+        "bbox": [
+            174,
+            103,
+            828,
+            174
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Peter Sunehag, Guy Lever, Audrunas Gruslys, Wojciech Marian Czarnecki, Vinícius Flores Zambaldi, Max Jaderberg, Marc Lanctot, Nicolas Sonnerat, Joel Z. Leibo, Karl Tuyls, and Thore Graepel. Value-decomposition networks for cooperative multi-agent learning. CoRR, abs/1706.05296, 2017. URL http://arxiv.org/abs/1706.05296. ",
+        "bbox": [
+            174,
+            183,
+            826,
+            238
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard S. Sutton. Learning to predict by the methods of temporal differences. Mach. Learn., 3(1):9–44, August 1988. ISSN 0885-6125. doi: 10.1023/A:1022633531479. URL https: //doi.org/10.1023/A:1022633531479. ",
+        "bbox": [
+            173,
+            247,
+            828,
+            290
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ming Tan. Multi-agent reinforcement learning: Independent vs. cooperative agents. In Proceedings of the tenth international conference on machine learning, pp. 330–337, 1993. ",
+        "bbox": [
+            173,
+            299,
+            823,
+            329
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hado van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. CoRR, abs/1509.06461, 2015. URL http://arxiv.org/abs/1509.06461. ",
+        "bbox": [
+            173,
+            337,
+            825,
+            366
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Nando de Freitas, and Marc Lanctot. Dueling network architectures for deep reinforcement learning. CoRR, abs/1511.06581, 2015. URL http://arxiv.org/abs/1511.06581. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            404
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jeff Wu. Hanabi simulation in rust. https://github.com/WuTheFWasThat/hanabi.rs, 2018. ",
+        "bbox": [
+            169,
+            414,
+            826,
+            441
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A NETWORK ARCHITECTURE AND HYPER-PAMAMETERS FOR HANABI ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            777,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Our Hanabi agent uses dueling network architecture (Wang et al., 2015). The main body of the network consists of 1 fully connected layer of 512 units and 2 LSTM (Hochreiter & Schmidhuber, 1997) layers of 512 units, followed by two output heads for value and advantages respectively. The same network configuration is used across all Hanabi experiments. We take the default featurization of HLE and replace the card knowledge section with the V0-Belief proposed by Foerster et al. (2019). The maximum length of an episode is capped at 80 steps and the entire episode is stored in the replay buffer as one training sample. This avoids the “slate hidden states” problem as described in Kapturowski et al. (2019) because we can simply initialize the hidden states of LSTM as zero during training. For exploration and experience prioritization, we follow the simple strategy as in Horgan et al. (2018) and Kapturowski et al. (2019). Each actor executes an $\\epsilon _ { i }$ -greedy policy where $\\epsilon _ { i } = \\bar { \\epsilon } ^ { 1 + \\frac { 1 } { N - 1 } \\alpha }$ for $i \\in \\{ 0 , . . . , N - 1 \\}$ but with a smaller $\\epsilon = 0 . 1$ and $\\alpha = 7$ . For simplicity, all players of a game use the same epsilon. The per time-step priority $\\delta _ { t }$ is the TD error and per episode priority is computed following $\\delta _ { e } = \\eta \\operatorname* { m a x } _ { t } \\delta _ { i } + ( 1 - \\eta ) \\hat { \\delta }$ where $\\eta = 0 . 9$ . Priority exponent is set to 0.9 and importance sampling exponent is set to 0.6. We use $n$ -step return (Sutton, 1988) and double Q-learning (van Hasselt et al., 2015) for target computation during training. The discount factor $\\gamma$ is set to 0.999. The network is updated using Adam optimizer (Kingma & Ba, 2014) with learning rate $l r = 6 . 2 5 \\times 1 0 ^ { - 5 }$ and $\\epsilon = \\dot { 1 . 5 } \\times 1 0 ^ { - 5 }$ . Trainer sends its network weights to all actors every 10 updates and target network is synchronized with online network every 2500 updates. These hyper-parameters are fixed across all experiments. ",
+        "bbox": [
+            173,
+            133,
+            826,
+            402
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In the baseline, we use Independent Q-Learning where each player estimates the Q value and selects action independently at each time-step. Note that all players need to operate on the observations in order to update their recurrent hidden states while only the current player has non-trivial legal moves and other players can only select ‘pass’. Each player then writes its own version of the episode into the prioritized replay buffer and they are sampled independently during training. The prioritized replay buffer contains $2 ^ { 1 7 } ( 1 3 1 0 7 2 )$ episodes. We warm up the replay buffer with 10,000 episodes before training starts. Batch size during training is 128 for games of different numbers of players. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            507
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As mentioned in Section 4, the SAD agent is built on top of joint Q-function where the Q value is the sum of the individual Q value of all players given their own actions. One episode produces only one training sample with an extra dimension for the number of players. The replay buffer size is reduced to $2 ^ { 1 6 }$ for 2-player and 3-player games and $2 ^ { 1 5 }$ for 4-player and 5-player games. The batch sizes for 2-, 3-, 4-, 5-players are 64, 43, 32, 26 respectively to account for the fact that each sample contains more data. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            597
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Auxiliary task can be added to the agent to help it decode the greedy action more effectively. In Hanabi, the natural choice is the predict the card of player’s own hand. In our experiments, the auxiliary task is to predict the status of a card, which can be playable, discardable, or unknown. The loss is the average cross entropy loss per card and is simply added to the TD-error of reinforcement learning during training. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            674
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B LEARNING CURVES FOR HANABI ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            483,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/ccf9077cc9f7d726e6a7f0ea3a2fa7941948d5e7bedb2d3bea373709b6945a93.jpg",
+        "image_caption": [
+            "Figure 3 shows learning curves of different algorithms averaged over 13 seeds per algorithm per player setting. Shading is error of the mean. ",
+            "Figure 3: Learning Curves "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            176,
+            812,
+            619
+        ],
+        "page_idx": 13
+    }
+]

parse/train/BkM27IxR-/BkM27IxR-.md

@@ -0,0 +1,274 @@
+# LEARNING TO OPTIMIZE NEURAL NETS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Learning to Optimize (Li & Malik, 2016) is a recently proposed framework for learning optimization algorithms using reinforcement learning. In this paper, we explore learning an optimization algorithm for training shallow neural nets. Such high-dimensional stochastic optimization problems present interesting challenges for existing reinforcement learning algorithms. We develop an extension that is suited to learning optimization algorithms in this setting and demonstrate that the learned optimization algorithm consistently outperforms other known optimization algorithms even on unseen tasks and is robust to changes in stochasticity of gradients and the neural net architecture. More specifically, we show that an optimization algorithm trained with the proposed method on the problem of training a neural net on MNIST generalizes to the problems of training neural nets on the Toronto Faces Dataset, CIFAR-10 and CIFAR-100.
+
+# 1 INTRODUCTION
+
+Machine learning is centred on the philosophy that learning patterns automatically from data is generally better than meticulously crafting rules by hand. This data-driven approach has delivered: today, machine learning techniques can be found in a wide range of application areas, both in AI and beyond. Yet, there is one domain that has conspicuously been left untouched by machine learning: the design of tools that power machine learning itself.
+
+One of the most widely used tools in machine learning is optimization algorithms. We have grown accustomed to seeing an optimization algorithm as a black box that takes in a model that we design and the data that we collect and outputs the optimal model parameters. The optimization algorithm itself largely stays static: its design is reserved for human experts, who must toil through many rounds of theoretical analysis and empirical validation to devise a better optimization algorithm. Given this state of affairs, perhaps it is time for us to start practicing what we preach and learn how to learn.
+
+Recently, Li & Malik (2016) and Andrychowicz et al. (2016) introduced two different frameworks for learning optimization algorithms. Whereas Andrychowicz et al. (2016) focuses on learning an optimization algorithm for training models on a particular task, Li & Malik (2016) sets a more ambitious objective of learning an optimization algorithm for training models that is task-independent. We study the latter paradigm in this paper and develop a method for learning an optimization algorithm for high-dimensional stochastic optimization problems, like the problem of training shallow neural nets.
+
+Under the “Learning to Optimize” framework proposed by Li & Malik (2016), the problem of learning an optimization algorithm is formulated as a reinforcement learning problem. We consider the general structure of an unconstrained continuous optimization algorithm, as shown in Algorithm 1. In each iteration, the algorithm takes a step $\Delta x$ and uses it to update the current iterate $\boldsymbol { x } ^ { ( i ) }$ . In hand-engineered optimization algorithms, $\Delta x$ is computed using some fixed formula $\phi$ that depends on the objective function, the current iterate and past iterates. Often, it is simply a function of the current and past gradients.
+
+Different choices of $\phi$ yield different optimization algorithms and so each optimization algorithm is essentially characterized by its update formula $\phi$ . Hence, by learning $\phi$ , we can learn an optimization algorithm. Li & Malik (2016) observed that an optimization algorithm can be viewed as a Markov decision process (MDP), where the state includes the current iterate, the action is the step vector $\Delta x$
+
+Require: Objective function $f$ $\bar { x ^ { ( 0 ) } } \gets$ random point in the domain of $f$ for $i = 1 , 2 , \dots { \bf d }$ o $\Delta x \gets \acute { \phi } ( f , \{ x ^ { ( 0 ) } , \ldots , x ^ { ( i - 1 ) } \} )$ if stopping condition is met then return x(i−1) end if $x ^ { ( i ) } \gets x ^ { ( i - 1 ) } + \Delta x$ end for
+
+and the policy is the update formula $\phi$ . Hence, the problem of learning $\phi$ simply reduces to a policy search problem.
+
+In this paper, we build on the method proposed in (Li & Malik, 2016) and develop an extension that is suited to learning optimization algorithms for high-dimensional stochastic problems. We use it to learn an optimization algorithm for training shallow neural nets and show that it outperforms popular hand-engineered optimization algorithms like ADAM (Kingma & Ba, 2014), AdaGrad (Duchi et al., 2011) and RMSprop (Tieleman & Hinton, 2012) and an optimization algorithm learned using the supervised learning method proposed in (Andrychowicz et al., 2016). Furthermore, we demonstrate that our optimization algorithm learned from the experience of training on MNIST generalizes to training on other datasets that have very dissimilar statistics, like the Toronto Faces Dataset, CIFAR10 and CIFAR-100.
+
+# 2 RELATED WORK
+
+The line of work on learning optimization algorithms is fairly recent. Li & Malik (2016) and Andrychowicz et al. (2016) were the first to propose learning general optimization algorithms. Li & Malik (2016) explored learning task-independent optimization algorithms and used reinforcement learning to learn the optimization algorithm, while Andrychowicz et al. (2016) investigated learning task-dependent optimization algorithms and used supervised learning.
+
+In the special case where objective functions that the optimization algorithm is trained on are loss functions for training other models, these methods can be used for “learning to learn” or “metalearning”. While these terms have appeared from time to time in the literature (Baxter et al., 1995; Vilalta & Drissi, 2002; Brazdil et al., 2008; Thrun & Pratt, 2012), they have been used by different authors to refer to disparate methods with different purposes. These methods all share the objective of learning some form of meta-knowledge about learning, but differ in the type of meta-knowledge they aim to learn. We can divide the various methods into the following three categories.
+
+# 2.1 LEARNING WHAT TO LEARN
+
+Methods in this category Thrun & Pratt (2012) aim to learn what parameter values of the base-level learner are useful across a family of related tasks. The meta-knowledge captures commonalities shared by tasks in the family, which enables learning on a new task from the family to be performed more quickly. Most early methods fall into this category; this line of work has blossomed into an area that has later become known as transfer learning and multi-task learning.
+
+# 2.2 LEARNING WHICH MODEL TO LEARN
+
+Methods in this category Brazdil et al. (2008) aim to learn which base-level learner achieves the best performance on a task. The meta-knowledge captures correlations between different tasks and the performance of different base-level learners on those tasks. One challenge under this setting is to decide on a parameterization of the space of base-level learners that is both rich enough to be capable of representing disparate base-level learners and compact enough to permit tractable search over this space. Brazdil et al. (2003) proposes a nonparametric representation and stores examples of different base-level learners in a database, whereas Schmidhuber (2004) proposes representing baselevel learners as general-purpose programs. The former has limited representation power, while the latter makes search and learning in the space of base-level learners intractable. Hochreiter et al. (2001) views the (online) training procedure of any base-learner as a black box function that maps a sequence of training examples to a sequence of predictions and models it as a recurrent neural net. Under this formulation, meta-training reduces to training the recurrent net, and the base-level learner is encoded in the memory state of the recurrent net.
+
+Hyperparameter optimization can be seen as another example of methods in this category. The space of base-level learners to search over is parameterized by a predefined set of hyperparameters. Unlike the methods above, multiple trials with different hyperparameter settings on the same task are permitted, and so generalization across tasks is not required. The discovered hyperparameters are generally specific to the task at hand and hyperparameter optimization must be rerun for new tasks. Various kinds of methods have been proposed, such those based on Bayesian optimization (Hutter et al., 2011; Bergstra et al., 2011; Snoek et al., 2012; Swersky et al., 2013; Feurer et al., 2015), random search (Bergstra & Bengio, 2012) and gradient-based optimization (Bengio, 2000; Domke, 2012; Maclaurin et al., 2015).
+
+# 2.3 LEARNING HOW TO LEARN
+
+Methods in this category aim to learn a good algorithm for training a base-level learner. Unlike methods in the previous categories, the goal is not to learn about the outcome of learning, but rather the process of learning. The meta-knowledge captures commonalities in the behaviours of learning algorithms that achieve good performance. The base-level learner and the task are given by the user, so the learned algorithm must generalize across base-level learners and tasks. Since learning in most cases is equivalent to optimizing some objective function, learning a learning algorithm often reduces to learning an optimization algorithm. This problem was explored in (Li & Malik, 2016) and (Andrychowicz et al., 2016). Closely related is (Bengio et al., 1991), which learns a Hebblike synaptic learning rule that does not depend on the objective function, which does not allow for generalization to different objective functions.
+
+Various work has explored learning how to adjust the hyperparameters of hand-engineered optimization algorithms, like the step size (Hansen, 2016; Daniel et al., 2016; Fu et al., 2016) or the damping factor in the Levenberg-Marquardt algorithm (Ruvolo et al., 2009). Related to this line of work is stochastic meta-descent (Bray et al., 2004), which derives a rule for adjusting the step size analytically. A different line of work (Gregor & LeCun, 2010; Sprechmann et al., 2013) parameterizes intermediate operands of special-purpose solvers for a class of optimization problems that arise in sparse coding and learns them using supervised learning.
+
+# 3 LEARNING TO OPTIMIZE
+
+# 3.1 SETTING
+
+In the “Learning to Optimize” framework, we are given a set of training objective functions $f _ { 1 } , \ldots , f _ { n }$ drawn from some distribution $\mathcal { F }$ . An optimization algorithm $\mathcal { P }$ takes an objective function $f$ and an initial iterate $x ^ { ( 0 ) }$ as input and produces a sequence of iterates $x ^ { ( 1 ) } , \ldots , x ^ { ( T ) }$ , where $x ^ { ( T ) }$ is the solution found by the optimizer. We are also given a distribution $\mathcal { D }$ that generates the initial iterate $x ^ { ( 0 ) }$ and a meta-loss $\mathcal { L }$ , which takes an objective function $f$ and a sequence of iterates $x ^ { ( 1 ) } , \ldots , x ^ { ( T ) }$ produced by an optimization algorithm as input and outputs a scalar that measures the quality of the iterates. The goal is to learn an optimization algorithm ${ \mathcal { P } } ^ { * }$ such that $\mathbb { E } _ { f \sim \mathcal { F } , x ^ { ( 0 ) } \sim \mathcal { D } } \left[ \mathcal { L } ( f , \mathcal { P } ^ { * } ( f , x ^ { ( 0 ) } ) ) \right]$ is minimized. The meta-loss is chosen to penalize optimization algorithms that exhibit behaviours we find undesirable, like slow convergence or excessive oscillations. Assuming we would like to learn an algoritha good choice of meta-loss would then simply be regret and can be interpreted as the area under the $\textstyle \sum _ { i = 1 } ^ { T } f ( x ^ { ( i ) } )$ zes the objective function it is given,, which is equivalent to cumulativective values over time.
+
+The objective functions $f _ { 1 } , \ldots , f _ { n }$ may correspond to loss functions for training base-level learners, in which case the algorithm that learns the optimization algorithm can be viewed as a meta-learner. In this setting, each objective function is the loss function for training a particular base-learner on a particular task, and so the set of training objective functions can be loss functions for training a base-learner or a family of base-learners on different tasks. At test time, the learned optimization algorithm is evaluated on unseen objective functions, which correspond to loss functions for training base-learners on new tasks, which may be completely unrelated to tasks used for training the optimization algorithm. Therefore, the learned optimization algorithm must not learn anything about the tasks used for training. Instead, the goal is to learn an optimization algorithm that can exploit the geometric structure of the error surface induced by the base-learners. For example, if the base-level model is a neural net with ReLU activation units, the optimization algorithm should hopefully learn to leverage the piecewise linearity of the model. Hence, there is a clear division of responsibilities between the meta-learner and base-learners. The knowledge learned at the meta-level should be pertinent for all tasks, whereas the knowledge learned at the base-level should be task-specific. The meta-learner should therefore generalize across tasks, whereas the base-learner should generalize across instances.
+
+# 3.2 RL PRELIMINARIES
+
+The goal of reinforcement learning is to learn to interact with an environment in a way that minimizes cumulative costs that are expected to be incurred over time. The environment is formalized as a partially observable Markov decision process $( \mathrm { P O M D P } ) ^ { 1 }$ , which is defined by the tuple $( S , \mathcal { O } , \mathcal { A } , p _ { i } , p , p _ { o } , c , T )$ , where $\mathcal { S } \subseteq \mathbb { R } ^ { D }$ is the set of states, $\mathcal { O } \subseteq \mathbb { R } ^ { D ^ { \prime } }$ is the set of observations, $\mathcal { A } \subseteq \mathbb { R } ^ { d }$ is the set of actions, $p _ { i } \left( s _ { 0 } \right)$ is the probability density over initial states $s _ { 0 }$ , $p \left( { { s } _ { t + 1 } } \left| { { s } _ { t } } , { { a } _ { t } } \right. \right)$ is the probability density over the subsequent state $s _ { t + 1 }$ given the current state $s _ { t }$ and action $a _ { t }$ , $p _ { o } \left( o _ { t } \bar { | } _ { s _ { t } } \right)$ is the probability density over the current observation $o _ { t }$ given the current state $s _ { t }$ , $c : { \mathcal { S } }  \mathbb { R }$ is a function that assigns a cost to each state and $T$ is the time horizon. Often, the probability densities $p$ and $p _ { o }$ are unknown and not given to the learning algorithm.
+
+A policy $\pi \left( \boldsymbol { a } _ { t } | \boldsymbol { o } _ { t } , t \right)$ is a conditional probability density over actions $a _ { t }$ given the current observation $o _ { t }$ and time step $t$ . When a policy is independent of $t$ , it is known as a stationary policy. The goal of the reinforcement learning algorithm is to learn a policy $\pi ^ { * }$ that minimizes the total expected cost over time. More precisely,
+
+$$
+\pi ^ { * } = \arg \operatorname* { m i n } _ { \pi } \mathbb { E } _ { s _ { 0 } , a _ { 0 } , s _ { 1 } , \dots , s _ { T } } \left[ \sum _ { t = 0 } ^ { T } c ( s _ { t } ) \right] ,
+$$
+
+where the expectation is taken with respect to the joint distribution over the sequence of states and actions, often referred to as a trajectory, which has the density
+
+$$
+\begin{array} { c } { { \displaystyle q \big ( s _ { 0 } , a _ { 0 } , s _ { 1 } , \ldots , s _ { T } \big ) = \int _ { o _ { 0 } , \ldots , o _ { T } } p _ { i } \left( s _ { 0 } \right) p _ { o } \left( o _ { 0 } \big | s _ { 0 } \right) } } \\ { { { \displaystyle \prod _ { t = 0 } ^ { T - 1 } \pi \left( \left. a _ { t } \right| o _ { t } , t \right) p \left( \left. s _ { t + 1 } \right| s _ { t } , a _ { t } \right) p _ { o } \left( \left. o _ { t + 1 } \right| s _ { t + 1 } \right) . } } } \end{array}
+$$
+
+To make learning tractable, $\pi$ is often constrained to lie in a parameterized family. A common assumption is that $\pi \left( \left. a _ { t } \right| o _ { t } , t \right) = \mathcal { N } \left( \mu ^ { \pi } ( o _ { t } ) , \Sigma ^ { \pi } ( o _ { t } ) \right)$ , where $\textstyle { \mathcal { N } } ( { \boldsymbol { \mu } } , { \boldsymbol { \Sigma } } )$ denotes the density of a Gaussian with mean $\mu$ and covariance $\Sigma$ . The functions $\mu ^ { \pi } ( \cdot )$ and possibly $\Sigma ^ { \pi } ( \cdot )$ are modelled using function approximators, whose parameters are learned.
+
+# 3.3 FORMULATION
+
+In our setting, the state $s _ { t }$ consists of the current iterate $x ^ { ( t ) }$ and features $\Phi ( \cdot )$ that depend on the history of iterates $x ^ { ( 1 ) } , \ldots , x ^ { ( t ) }$ , (noisy) gradients $\nabla \hat { f } ( x ^ { ( 1 ) } ) , \ldots , \nabla \hat { f } ( x ^ { ( t ) } )$ and (noisy) objective values ${ \hat { f } } ( x ^ { ( 1 ) } ) , \ldots , { \hat { f } } ( x ^ { ( t ) } )$ . The action $a _ { t }$ is the step $\Delta x$ that will be used to update the iterate. The observation $o _ { t }$ excludes $x ^ { ( t ) }$ and consists of features $\Psi ( \cdot )$ that depend on the iterates, gradient and objective values from recent iterations, and the previous memory state of the learned optimization algorithm, which takes the form of a recurrent neural net. This memory state can be viewed as a statistic of the previous observations that is learned jointly with the policy.
+
+Under this formulation, the initial probability density $p _ { i }$ captures how the initial iterate, gradient and objective value tend to be distributed. The transition probability density $p$ captures the how the gradient and objective value are likely to change given the step that is taken currently; in other words, it encodes the local geometry of the training objective functions. Assuming the goal is to learn an optimization algorithm that minimizes the objective function, the cost $c$ of a state $\boldsymbol { s } _ { t } = \left( \boldsymbol { x } ^ { ( t ) } , \Phi \left( \cdot \right) \right) ^ { T }$ is simply the true objective value $f ( \boldsymbol { x } ^ { ( t ) } )$ .
+
+Any particular policy $\pi \left( \boldsymbol { a } _ { t } \left| \boldsymbol { o } _ { t } , t \right. \right)$ , which generates $a _ { t } ~ = ~ \Delta x$ at every time step, corresponds to a particular (noisy) update formula $\phi$ , and therefore a particular (noisy) optimization algorithm. Therefore, learning an optimization algorithm simply reduces to searching for the optimal policy.
+
+The mean of the policy is modelled as a recurrent neural net fragment that corresponds to a single time step, which takes the observation features $\Psi ( \cdot )$ and the previous memory state as input and outputs the step to take.
+
+# 3.4 GUIDED POLICY SEARCH
+
+The reinforcement learning method we use is guided policy search (GPS) (Levine et al., 2015), which is a policy search method designed for searching over large classes of expressive non-linear policies in continuous state and action spaces. It maintains two policies, $\psi$ and $\pi$ , where the former lies in a time-varying linear policy class in which the optimal policy can found in closed form, and the latter lies in a stationary non-linear policy class in which policy optimization is challenging. In each iteration, it performs policy optimization on $\psi$ , and uses the resulting policy as supervision to train $\pi$ .
+
+More precisely, GPS solves the following constrained optimization problem:
+
+$$
+\operatorname* { m i n } _ { \theta , \eta } \mathbb { E } _ { \psi } \left[ \sum _ { t = 0 } ^ { T } c ( s _ { t } ) \right] \mathrm { ~ s . t . ~ } \psi \left( \left. a _ { t } \right| s _ { t } , t ; \eta \right) = \pi \left( \left. a _ { t } \right| s _ { t } ; \theta \right) \forall a _ { t } , s _ { t } , t
+$$
+
+where $\eta$ and $\theta$ denote the parameters of $\psi$ and $\pi$ respectively, $\mathbb { E } _ { \rho } \left[ \cdot \right]$ denotes the expectation taken with respect to the trajectory induced by a policy $\rho$ and $\begin{array} { r } { \pi \left( \left. a _ { t } \right| s _ { t } ; \theta \right) : = \int _ { o _ { t } } \pi \left( \left. a _ { t } \right| o _ { t } ; \theta \right) p _ { o } \left( \left. o _ { t } \right| s _ { t } \right) ^ { 2 } } \end{array}$ .
+
+Since there are an infinite number of equality constraints, the problem is relaxed by enforcing equality on the mean actions taken by $\psi$ and $\pi$ at every time step3. So, the problem becomes:
+
+$$
+\operatorname* { m i n } _ { \theta , \eta } \mathbb { E } _ { \psi } [ \sum _ { t = 0 } ^ { T } c ( s _ { t } ) ] \mathrm { ~ s . t . ~ } \mathbb { E } _ { \psi } [ a _ { t } ] = \mathbb { E } _ { \psi } [ \mathbb { E } _ { \pi } [ a _ { t } | s _ { t } ] ] \forall t
+$$
+
+This problem is solved using Bregman ADMM (Wang & Banerjee, 2014), which performs the following updates in each iteration:
+
+$$
+\begin{array} { r l } & { \eta \gets \arg \underset { \eta } { \operatorname* { m i n } } \sum _ { t = 0 } ^ { T } \mathbb { E } _ { \psi } [ c ( s _ { t } ) - \lambda _ { t } ^ { T } a _ { t } ] + \nu _ { t } D _ { t } ( \eta , \theta ) } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \theta \gets \arg \underset { \theta } { \operatorname* { m i n } } \sum _ { t = 0 } ^ { T } \lambda _ { t } ^ { T } \mathbb { E } _ { \psi } [ \mathbb { E } _ { \pi } [ a _ { t } | s _ { t } ] ] + \nu _ { t } D _ { t } ( \theta , \eta ) } \\ & { \quad \quad \quad \quad \quad \quad \quad \lambda _ { t } \gets \lambda _ { t } + \alpha \nu _ { t } ( \mathbb { E } _ { \psi } [ \mathbb { E } _ { \pi } [ a _ { t } | s _ { t } ] ] - \mathbb { E } _ { \psi } [ a _ { t } ] ) \ \forall t , } \\ & { \mathrm { ~ } \mathrm { ~ } : \mathrm { r e } \quad D _ { t } ( \theta , \eta ) \quad : = \quad \mathbb { E } _ { \psi } [ D _ { K L } ( \pi ( a _ { t } | s _ { t } ; \theta ) ) ] \ \psi ( a _ { t } | s _ { t } , t ; \eta ) ) ] \quad \mathrm { ~ a n d ~ } \quad D _ { t } ( \eta , \theta ) } \\ & { [ D _ { K L } ( \psi ( a _ { t } | s _ { t } , t ; \eta ) ] ) | \ \pi ( a _ { t } | s _ { t } ; \theta ) ) | . } \end{array}
+$$
+
+The algorithm assumes that $\psi \left( \left. a _ { t } \right| s _ { t } , t ; \eta \right) = \mathcal { N } \left( K _ { t } s _ { t } + k _ { t } , G _ { t } \right)$ , where $\boldsymbol { \eta } : = \left( K _ { t } , k _ { t } , G _ { t } \right) _ { t = 1 } ^ { T }$ and $\pi \left( a _ { t } | o _ { t } ; \theta \right) = \mathcal { N } \left( \mu _ { \omega } ^ { \pi } ( o _ { t } ) , \Sigma ^ { \pi } \right)$ , where $\boldsymbol { \theta } : = ( \omega , \Sigma ^ { \pi } )$ and $\mu _ { \omega } ^ { \pi } ( \cdot )$ can be an arbitrary function that is typically modelled using a nonlinear function approximator like a neural net.
+
+At the start of each iteration, the algorithm constructs a model of the transition probability density $\tilde { p } \left( \left. s _ { t + 1 } \right| s _ { t } , a _ { t } , t ; \zeta \right) = \mathcal { N } ( A _ { t } s _ { t } + B _ { t } a _ { t } + c _ { t } , F _ { t } )$ , where $\boldsymbol { \zeta } : = \left( A _ { t } , B _ { t } , c _ { t } , F _ { t } \right) _ { t = 1 } ^ { T }$ is fitted to samples of $s _ { t }$ drawn from the trajectory induced by $\psi$ , which essentially amounts to a local linearization of the true transition probability $p \left( \left. s _ { t + 1 } \right| s _ { t } , a _ { t } , t \right)$ . We will use $\mathbb { E } _ { \widetilde { \psi } } \left[ \cdot \right]$ to denote expectation taken with respect to the trajectory induced by $\psi$ under the modelled transition probability $\tilde { p }$ . Additionally, the algorithm fits local quadratic approximations to $c ( s _ { t } )$ around samples of $s _ { t }$ drawn from the trajectory induced by $\psi$ so that $\begin{array} { r } { c ( s _ { t } ) \approx \dot { \tilde { c } } \dot { ( s _ { t } ) } : = \frac { 1 } { 2 } s _ { t } ^ { T } C _ { t } s _ { t } + \dot { d _ { t } ^ { T } } s _ { t } + h _ { t } } \end{array}$ for $s _ { t }$ ’s that are near the samples.
+
+With these assumptions, the subproblem that needs to be solved to update $\eta ~ = ~ ( K _ { t } , k _ { t } , G _ { t } ) _ { t = 1 } ^ { T }$ becomes:
+
+$$
+\begin{array} { r l r } & { \underset { \eta } { \operatorname* { m i n } } \displaystyle \sum _ { t = 0 } ^ { T } \mathbb { E } _ { \boldsymbol { \tilde { \psi } } } [ \boldsymbol { \tilde { c } } ( s _ { t } ) - \lambda _ { t } ^ { T } \boldsymbol { a } _ { t } ] + \nu _ { t } D _ { t } ( \eta , \theta ) } & \\ & { \mathrm { s . t . } \displaystyle \sum _ { t = 0 } ^ { T } \mathbb { E } _ { \boldsymbol { \tilde { \psi } } } [ D _ { K L } ( \boldsymbol { \psi } ( \boldsymbol { a } _ { t } | \boldsymbol { s } _ { t } , t ; \eta ) | \Big | \psi ( \boldsymbol { a } _ { t } | \boldsymbol { s } _ { t } , t ; \eta ^ { \prime } ) ) ] \leq \epsilon , } \end{array}
+$$
+
+where $\eta ^ { \prime }$ denotes the old $\eta$ from the previous iteration. Because $\tilde { p }$ and $\tilde { c }$ are only valid locally around the trajectory induced by $\psi$ , the constraint is added to limit the amount by which $\eta$ is updated. It turns out that the unconstrained problem can be solved in closed form using a dynamic programming algorithm known as linear-quadratic-Gaussian (LQG) regulator in time linear in the time horizon $T$ and cubic in the dimensionality of the state space $D$ . The constrained problem is solved using dual gradient descent, which uses LQG as a subroutine to solve for the primal variables in each iteration and increments the dual variable on the constraint until it is satisfied.
+
+Updating $\theta$ is straightforward, since expectations taken with respect to the trajectory induced by $\pi$ are always conditioned on $s _ { t }$ and all outer expectations over $s _ { t }$ are taken with respect to the trajectory induced by $\psi$ . Therefore, $\pi$ is essentially decoupled from the transition probability $p \left( \left. s _ { t + 1 } \right| s _ { t } , a _ { t } , t \right)$ and so its parameters can be updated without affecting the distribution of $s _ { t }$ ’s. The subproblem that needs to be solved to update $\theta$ therefore amounts to a standard supervised learning problem.
+
+Since $\psi \left( \boldsymbol { a } _ { t } | \boldsymbol { s } _ { t } , t ; \boldsymbol { \eta } \right)$ and $\pi \left( \boldsymbol { a } _ { t } | \boldsymbol { s } _ { t } ; \boldsymbol { \theta } \right)$ are Gaussian, $D _ { t } \left( { \theta , \eta } \right)$ can be computed analytically. More concretely, if we assume $\Sigma ^ { \pi }$ to be fixed for simplicity, the subproblem that is solved for updating $\theta = \left( \omega , \Sigma ^ { \pi } \right)$ is:
+
+$$
+\begin{array} { l } { \displaystyle \operatorname* { m i n } _ { \theta } \mathbb { E } _ { \psi } [ \sum _ { t = 0 } ^ { T } \lambda _ { t } ^ { T } \mu _ { \omega } ^ { \pi } ( o _ { t } ) + \frac { \nu _ { t } } { 2 } ( \operatorname { t r } ( G _ { t } ^ { - 1 } \Sigma ^ { \pi } ) - \log | \Sigma ^ { \pi } | )  } \\ { \displaystyle  + \frac { \nu _ { t } } { 2 } ( \mu _ { \omega } ^ { \pi } ( o _ { t } ) - \mathbb { E } _ { \psi } [ a _ { t } | s _ { t } , t ] ) ^ { T } G _ { t } ^ { - 1 } ( \mu _ { \omega } ^ { \pi } ( o _ { t } ) - \mathbb { E } _ { \psi } [ a _ { t } | s _ { t } , t ] ) ] } \end{array}
+$$
+
+Note that the last term is the squared Mahalanobis distance between the mean actions of $\psi$ and $\pi$ at time step $t$ , which is intuitive as we would like to encourage $\pi$ to match $\psi$ .
+
+# 3.5 CONVOLUTIONAL GPS
+
+The problem of learning high-dimensional optimization algorithms presents challenges for reinforcement learning algorithms due to high dimensionality of the state and action spaces. For example, in the case of GPS, because the running time of LQG is cubic in dimensionality of the state space, performing policy search even in the simple class of linear-Gaussian policies would be prohibitively expensive when the dimensionality of the optimization problem is high.
+
+Fortunately, many high-dimensional optimization problems have underlying structure that can be exploited. For example, the parameters of neural nets are equivalent up to permutation among certain coordinates. More concretely, for fully connected neural nets, the dimensions of a hidden layer and the corresponding weights can be permuted arbitrarily without changing the function they compute. Because permuting the dimensions of two adjacent layers can permute the weight matrix arbitrarily, an optimization algorithm should be invariant to permutations of the rows and columns of a weight matrix. A reasonable prior to impose is that the algorithm should behave in the same manner on all coordinates that correspond to entries in the same matrix. That is, if the values of two coordinates in all current and past gradients and iterates are identical, then the step vector produced by the algorithm should have identical values in these two coordinates. We will refer to the set of coordinates on which permutation invariance is enforced as a coordinate group. For the purposes of learning an optimization algorithm for neural nets, a natural choice would be to make each coordinate group correspond to a weight matrix or a bias vector. Hence, the total number of coordinate groups is twice the number of layers, which is usually fairly small.
+
+![](images/c32356121b006ac72da2adddd464187f503567b08623692799a8cd7bffe7f36e.jpg)  
+Figure 1: Comparison of the various hand-engineered and learned algorithms on training neural nets with 48 input and hidden units on (a) TFD, (b) CIFAR-10 and (c) CIFAR-100 with mini-batches of size 64. The vertical axis is the true objective value and the horizontal axis represents the iteration. Best viewed in colour.
+
+In the case of GPS, we impose this prior on both $\psi$ and $\pi$ . For the purposes of updating $\eta$ , we first impose a block-diagonal structure on the parameters $A _ { t } , B _ { t }$ and $F _ { t }$ of the fitted transition probability density $\tilde { p } \left( \left. s _ { t + 1 } \right| s _ { t } , a _ { t } , t ; \zeta \right) = \mathcal { N } ( A _ { t } s _ { t } + B _ { t } a _ { t } + c _ { t } , F _ { t } )$ , so that for each coordinate in the optimization problem, the dimensions of $s _ { t + 1 }$ that correspond to the coordinate only depend on the dimensions of $s _ { t }$ and $a _ { t }$ that correspond to the same coordinate. As a result, $\tilde { p } \big ( s _ { t + 1 } \big | s _ { t } , a _ { t } , t ; \zeta \big )$ decomposes into multiple independent probability densities $\tilde { p } ^ { j } \left( s _ { t + 1 } ^ { j } \Big | s _ { t } ^ { j } , a _ { t } ^ { j } , t ; \zeta ^ { j } \right)$ , one for each coordinate $j$ . Similarly, we also impose a block-diagonal structure on $C _ { t }$ for fitting $\tilde { c } ( s _ { t } )$ and on the parameter matrix of the fitted model for $\pi \left( a _ { t } | \boldsymbol s _ { t } \bar { ; \boldsymbol \theta } \right)$ . Under these assumptions, $K _ { t }$ and $G _ { t }$ are guaranteed to be block-diagonal as well. Hence, the Bregman divergence penalty term, $D \left( \eta , \theta \right)$ decomposes into a sum of Bregman divergence terms, one for each coordinate.
+
+We then further constrain dual variables $\lambda _ { t }$ , sub-vectors of parameter vectors and sub-matrices of parameter matrices corresponding to each coordinate group to be identical across the group. Additionally, we replace the weight $\nu _ { t }$ on $D \left( \eta , \theta \right)$ with an individual weight on each Bregman divergence term for each coordinate group. The problem then decomposes into multiple independent subproblems, one for each coordinate group. Because the dimensionality of the state subspace corresponding to each coordinate is constant, LQG can be executed on each subproblem much more efficiently.
+
+Similarly, for $\pi$ , we choose a $\mu _ { \omega } ^ { \pi } ( \cdot )$ that shares parameters across different coordinates in the same group. We also impose a block-diagonal structure on $\Sigma ^ { \pi }$ and constrain the appropriate sub-matrices to share their entries.
+
+# 3.6 FEATURES
+
+We describe the features $\Phi ( \cdot )$ and $\Psi ( \cdot )$ at time step $t$ , which define the state $s _ { t }$ and observation $o _ { t }$ respectively.
+
+Because of the stochasticity of gradients and objective values, the state features $\Phi ( \cdot )$ are defined in terms of summary statistics of the history of iterates $\left\{ x ^ { ( i ) } \right\} _ { i = 0 } ^ { t }$ , gradients $\left\{ \nabla \hat { f } ( x ^ { ( i ) } ) \right\} _ { i = 0 } ^ { t }$ and objective values $\left\{ \hat { f } ( \boldsymbol x ^ { ( i ) } ) \right\} _ { i = 0 } ^ { t }$ We define the following statistics, which we will refer to as the average recent iterate, gradient and objective value respectively:
+
+$$
+\begin{array} { r } { \overline { { \boldsymbol { x } ^ { ( i ) } } } : = \frac { 1 } { \operatorname* { m i n } ( i + 1 , 3 ) } \sum _ { j = \operatorname* { m a x } ( i - 2 , 0 ) } ^ { i } \boldsymbol { x } ^ { ( j ) } } \end{array}
+$$
+
+![](images/3fea8480e1dc0f7dbc3c3a6dc8993cac0f6ffab3eae77436f1e3e961bbffec59.jpg)  
+Figure 2: Comparison of the various hand-engineered and learned algorithms on training neural nets with 100 input units and 200 hidden units on (a) TFD, (b) CIFAR-10 and (c) CIFAR-100 with minibatches of size 64. The vertical axis is the true objective value and the horizontal axis represents the iteration. Best viewed in colour.
+
+$$
+\begin{array} { r l } & { \bullet \ \overline { { \nabla \hat { f } ( x ^ { ( i ) } ) } } : = \frac { 1 } { \operatorname* { m i n } ( i + 1 , 3 ) } \sum _ { j = \operatorname* { m a x } ( i - 2 , 0 ) } ^ { i } { \nabla \hat { f } ( x ^ { ( j ) } ) } } \\ & { \bullet \ \overline { { \hat { f } ( x ^ { ( i ) } ) } } : = \frac { 1 } { \operatorname* { m i n } ( i + 1 , 3 ) } \sum _ { j = \operatorname* { m a x } ( i - 2 , 0 ) } ^ { i } \hat { f } ( x ^ { ( j ) } ) } \end{array}
+$$
+
+The state features $\Phi ( \cdot )$ consist of the relative change in the average recent objective value, the average recent gradient normalized by the magnitude of the a previous average recent gradient and a previous change in average recent iterate relative to the current change in average recent iterate:
+
+$$
+\begin{array} { r l } & { \bullet \{ ( \hat { f } ( x ^ { ( t - 5 i ) } ) - \widehat { f } ( x ^ { ( t - 5 ( i + 1 ) ) } ) ) /  \widehat { f } ( x ^ { ( t - 5 ( i + 1 ) ) } ) \} _ { i = 0 } ^ { 2 4 } } \\ & { \bullet  \{ \overline { { \nabla \hat { f } ( x ^ { ( t - 5 i ) } ) } } / ( | \overline { { \nabla \hat { f } ( x ^ { ( m a x ( t - 5 ( i + 1 ) , t \mathrm { m o d } 5 ) ) } ) } } | + 1 ) \} _ { i = 0 } ^ { 2 5 } } \\ &  \bullet  \{ \frac { | \frac { \overline { { x ^ { ( \mathrm { m a x } ( t - 5 ( i + 1 ) , t \mathrm { m o d } 5 + 5 ) ) } } } - \overline { { x ^ { ( \mathrm { m a x } ( t - 5 ( i + 2 ) , t \mathrm { m o d } 5 ) ) } } } } { | \overline { { x ^ { ( t - 5 i ) } } } - \overline { { x ^ { ( t - 5 ( i + 1 ) ) } } } | + 0 . 1 } \} _ { i = 0 } ^ { 2 4 } \} _ { i = 0 } ^ { 2 } } \end{array}
+$$
+
+Note that all operations are applied element-wise. Also, whenever a feature becomes undefined (i.e.: when the time step index becomes negative), it is replaced with the all-zeros vector.
+
+Unlike state features, which are only used when training the optimization algorithm, observation features $\Psi ( \cdot )$ are used both during training and at test time. Consequently, we use noisier observation features that can be computed more efficiently and require less memory overhead. The observation features consist of the following:
+
+$$
+\begin{array} { r l } { \bullet } & { \left( \hat { f } ( x ^ { ( t ) } ) - \hat { f } ( x ^ { ( t - 1 ) } ) \right) / \hat { f } ( x ^ { ( t - 1 ) } ) } \\ & { \bullet \ \nabla \hat { f } ( x ^ { ( t ) } ) / \left( \left| \nabla \hat { f } ( x ^ { ( \operatorname* { m a x } ( t - 1 , 0 ) ) } ) \right| + 1 \right) } \\ & { \bullet \ \frac { \left| x ^ { ( \operatorname* { m a x } ( t - 1 , 1 ) ) } - x ^ { ( \operatorname* { m a x } ( t - 2 , 0 ) ) } \right| } { \left| x ^ { ( t ) } - x ^ { ( t - 1 ) } \right| + 0 . 1 } } \end{array}
+$$
+
+# 4 EXPERIMENTS
+
+For clarity, we will refer to training of the optimization algorithm as “meta-training” to differentiate it from base-level training, which will simply be referred to as “training”.
+
+We meta-trained an optimization algorithm on a single objective function, which corresponds to the problem of training a two-layer neural net with 48 input units, 48 hidden units and 10 output units on a randomly projected and normalized version of the MNIST training set with dimensionality 48 and unit variance in each dimension. We modelled the optimization algorithm using an recurrent neural net with a single layer of 128 LSTM (Hochreiter & Schmidhuber, 1997) cells. We used a time horizon of 400 iterations and a mini-batch size of 64 for computing stochastic gradients and objective values. We evaluate the optimization algorithm on its ability to generalize to unseen objective functions, which correspond to the problems of training neural nets on different tasks/datasets.
+
+![](images/dba70d81f44e9b66aeedbf35fb705247b4161ee34db83bed3b4ba0993a37fd89.jpg)  
+Figure 3: Comparison of the various hand-engineered and learned algorithms on training neural nets with 48 input and hidden units on (a) TFD, (b) CIFAR-10 and (c) CIFAR-100 with mini-batches of size 10. The vertical axis is the true objective value and the horizontal axis represents the iteration. Best viewed in colour.
+
+![](images/afba0d91683764d4cd4161719336a9f48fc43fabd99a2b8440e62626e6cabcb3.jpg)  
+Figure 4: Comparison of the various hand-engineered and learned algorithms on training neural nets with 100 input units and 200 hidden units on (a) TFD, (b) CIFAR-10 and (c) CIFAR-100 with minibatches of size 10. The vertical axis is the true objective value and the horizontal axis represents the iteration. Best viewed in colour.
+
+We evaluate the learned optimization algorithm on three datasets, the Toronto Faces Dataset (TFD), CIFAR-10 and CIFAR-100. These datasets are chosen for their very different characteristics from MNIST and each other: TFD contains 3300 grayscale images that have relatively little variation and has seven different categories, whereas CIFAR-100 contains 50,000 colour images that have varied appearance and has 100 different categories.
+
+All algorithms are tuned on the training objective function. For hand-engineered algorithms, this entails choosing the best hyperparameters; for learned algorithms, this entails meta-training on the objective function. We compare to the seven hand-engineered algorithms: stochastic gradient descent, momentum, conjugate gradient, L-BFGS, ADAM, AdaGrad and RMSprop. In addition, we compare to an optimization algorithm meta-trained using the method described in (Andrychowicz et al., 2016) on the same training objective function (training two-layer neural net on randomly projected and normalized MNIST) under the same setting (a time horizon of 400 iterations and a mini-batch size of 64).
+
+First, we examine the performance of various optimization algorithms on similar objective functions. The optimization problems under consideration are those for training neural nets that have the same number of input and hidden units (48 and 48) as those used during meta-training. The number of output units varies with the number of categories in each dataset. We use the same mini-batch size as that used during meta-training. As shown in Figure 1, the optimization algorithm meta-trained using our method (which we will refer to as Predicted Step Descent) consistently descends to the optimum the fastest across all datasets. On the other hand, other algorithms are not as consistent and the relative ranking of other algorithms varies by dataset. This suggests that Predicted Step Descent has learned to be robust to variations in the data distributions, despite being trained on only one objective function, which is associated with a very specific data distribution that characterizes MNIST. It is also interesting to note that while the algorithm meta-trained using (Andrychowicz et al., 2016) (which we will refer to as L2LBGDBGD) performs well on CIFAR, it is unable to reach the optimum on TFD.
+
+![](images/2226d92233c78e2cc8398fe5882a7f24065a5392b547b417b88d986cc9309d20.jpg)  
+Figure 5: Comparison of the various hand-engineered and learned algorithms on training neural nets with 100 input units and 200 hidden units on (a) TFD, (b) CIFAR-10 and (c) CIFAR-100 for 800 iterations with mini-batches of size 64. The vertical axis is the true objective value and the horizontal axis represents the iteration. Best viewed in colour.
+
+Next, we change the architecture of the neural nets and see if Predicted Step Descent generalizes to the new architecture. We increase the number of input units to 100 and the number of hidden units to 200, so that the number of parameters is roughly increased by a factor of 8. As shown in Figure 2, Predicted Step Descent consistently outperforms other algorithms on each dataset, despite having not been trained to optimize neural nets of this architecture. Interestingly, while it exhibited a bit of oscillation initially on TFD and CIFAR-10, it quickly recovered and overtook other algorithms, which is reminiscent of the phenomenon reported in (Li & Malik, 2016) for low-dimensional optimization problems. This suggests that it has learned to detect when it is performing poorly and knows how to change tack accordingly. L2LBGDBGD experienced difficulties on TFD and CIFAR10 as well, but slowly diverged.
+
+We now investigate how robust Predicted Step Descent is to stochasticity of the gradients. To this end, we take a look at its performance when we reduce the mini-batch size from 64 to 10 on both the original architecture with 48 input and hidden units and the enlarged architecture with 100 input units and 200 hidden units. As shown in Figure 3, on the original architecture, Predicted Step Descent still outperforms all other algorithms and is able to handle the increased stochasticity fairly well. In contrast, conjugate gradient and L2LBGDBGD had some difficulty handling the increased stochasticity on TFD and to a lesser extent, on CIFAR-10. In the former case, both diverged; in the latter case, both were progressing slowly towards the optimum.
+
+On the enlarged architecture, Predicted Step Descent experienced some significant oscillations on TFD and CIFAR-10, but still managed to achieve a much better objective value than all the other algorithms. Many hand-engineered algorithms also experienced much greater oscillations than previously, suggesting that the optimization problems are inherently harder. L2LBGDBGD diverged fairly quickly on these two datasets.
+
+Finally, we try doubling the number of iterations. As shown in Figure 5, despite being trained over a time horizon of 400 iterations, Predicted Step Descent behaves reasonably beyond the number of iterations it is trained for.
+
+# 5 CONCLUSION
+
+In this paper, we presented a new method for learning optimization algorithms for high-dimensional stochastic problems. We applied the method to learning an optimization algorithm for training shallow neural nets. We showed that the algorithm learned using our method on the problem of training a neural net on MNIST generalizes to the problems of training neural nets on unrelated tasks/datasets like the Toronto Faces Dataset, CIFAR-10 and CIFAR-100. We also demonstrated that the learned optimization algorithm is robust to changes in the stochasticity of gradients and the neural net architecture.
+
+# REFERENCES
+
+Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, and Nando de Freitas. Learning to learn by gradient descent by gradient descent. arXiv preprint arXiv:1606.04474, 2016.
+
+Jonathan Baxter, Rich Caruana, Tom Mitchell, Lorien Y Pratt, Daniel L Silver, and Sebastian Thrun. NIPS 1995 workshop on learning to learn: Knowledge consolidation and transfer in inductive systems. https://web.archive.org/web/20000618135816/http://www. cs.cmu.edu/afs/cs.cmu.edu/user/caruana/pub/transfer.html, 1995. Accessed: 2015-12-05.
+
+Y Bengio, S Bengio, and J Cloutier. Learning a synaptic learning rule. In Neural Networks, 1991., IJCNN-91-Seattle International Joint Conference on, volume 2, pp. 969–vol. IEEE, 1991.
+
+Yoshua Bengio. Gradient-based optimization of hyperparameters. Neural computation, 12(8):1889– 1900, 2000.
+
+James Bergstra and Yoshua Bengio. Random search for hyper-parameter optimization. The Journal of Machine Learning Research, 13(1):281–305, 2012.
+
+James S Bergstra, Remi Bardenet, Yoshua Bengio, and Bal ´ azs K ´ egl. Algorithms for hyper-parameter ´ optimization. In Advances in Neural Information Processing Systems, pp. 2546–2554, 2011.
+
+M Bray, E Koller-Meier, P Muller, L Van Gool, and NN Schraudolph. 3D hand tracking by rapid stochastic gradient descent using a skinning model. In Visual Media Production, 2004.(CVMP). 1st European Conference on, pp. 59–68. IET, 2004.
+
+Pavel Brazdil, Christophe Giraud Carrier, Carlos Soares, and Ricardo Vilalta. Metalearning: applications to data mining. Springer Science & Business Media, 2008.
+
+Pavel B Brazdil, Carlos Soares, and Joaquim Pinto Da Costa. Ranking learning algorithms: Using ibl and meta-learning on accuracy and time results. Machine Learning, 50(3):251–277, 2003.
+
+Christian Daniel, Jonathan Taylor, and Sebastian Nowozin. Learning step size controllers for robust neural network training. In Thirtieth AAAI Conference on Artificial Intelligence, 2016.
+
+Justin Domke. Generic methods for optimization-based modeling. In AISTATS, volume 22, pp. 318–326, 2012.
+
+John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12(Jul):2121–2159, 2011.
+
+Matthias Feurer, Jost Tobias Springenberg, and Frank Hutter. Initializing bayesian hyperparameter optimization via meta-learning. In AAAI, pp. 1128–1135, 2015.
+
+Jie Fu, Zichuan Lin, Miao Liu, Nicholas Leonard, Jiashi Feng, and Tat-Seng Chua. Deep q-networks for accelerating the training of deep neural networks. arXiv preprint arXiv:1606.01467, 2016.
+
+Karol Gregor and Yann LeCun. Learning fast approximations of sparse coding. In Proceedings of the 27th International Conference on Machine Learning (ICML-10), pp. 399–406, 2010.
+
+Samantha Hansen. Using deep q-learning to control optimization hyperparameters. arXiv preprint arXiv:1602.04062, 2016.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Sepp Hochreiter, A Steven Younger, and Peter R Conwell. Learning to learn using gradient descent. In International Conference on Artificial Neural Networks, pp. 87–94. Springer, 2001.
+
+Frank Hutter, Holger H Hoos, and Kevin Leyton-Brown. Sequential model-based optimization for general algorithm configuration. In Learning and Intelligent Optimization, pp. 507–523. Springer, 2011.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. arXiv preprint arXiv:1504.00702, 2015.
+
+Ke Li and Jitendra Malik. Learning to optimize. CoRR, abs/1606.01885, 2016.
+
+Dougal Maclaurin, David Duvenaud, and Ryan P Adams. Gradient-based hyperparameter optimization through reversible learning. arXiv preprint arXiv:1502.03492, 2015.
+
+Paul L Ruvolo, Ian Fasel, and Javier R Movellan. Optimization on a budget: A reinforcement learning approach. In Advances in Neural Information Processing Systems, pp. 1385–1392, 2009.
+
+Jurgen Schmidhuber. Optimal ordered problem solver. ¨ Machine Learning, 54(3):211–254, 2004.
+
+Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical bayesian optimization of machine learning algorithms. In Advances in neural information processing systems, pp. 2951–2959, 2012.
+
+Pablo Sprechmann, Roee Litman, Tal Ben Yakar, Alexander M Bronstein, and Guillermo Sapiro. Supervised sparse analysis and synthesis operators. In Advances in Neural Information Processing Systems, pp. 908–916, 2013.
+
+Kevin Swersky, Jasper Snoek, and Ryan P Adams. Multi-task bayesian optimization. In Advances in neural information processing systems, pp. 2004–2012, 2013.
+
+Sebastian Thrun and Lorien Pratt. Learning to learn. Springer Science & Business Media, 2012.
+
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2), 2012.
+
+Ricardo Vilalta and Youssef Drissi. A perspective view and survey of meta-learning. Artificial Intelligence Review, 18(2):77–95, 2002.
+
+Huahua Wang and Arindam Banerjee. Bregman alternating direction method of multipliers. CoRR, abs/1306.3203, 2014.

parse/train/BkM27IxR-/BkM27IxR-_content_list.json

@@ -0,0 +1,1469 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING TO OPTIMIZE NEURAL NETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            655,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            398,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning to Optimize (Li & Malik, 2016) is a recently proposed framework for learning optimization algorithms using reinforcement learning. In this paper, we explore learning an optimization algorithm for training shallow neural nets. Such high-dimensional stochastic optimization problems present interesting challenges for existing reinforcement learning algorithms. We develop an extension that is suited to learning optimization algorithms in this setting and demonstrate that the learned optimization algorithm consistently outperforms other known optimization algorithms even on unseen tasks and is robust to changes in stochasticity of gradients and the neural net architecture. More specifically, we show that an optimization algorithm trained with the proposed method on the problem of training a neural net on MNIST generalizes to the problems of training neural nets on the Toronto Faces Dataset, CIFAR-10 and CIFAR-100. ",
+        "bbox": [
+            233,
+            243,
+            764,
+            410
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            443,
+            336,
+            458
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Machine learning is centred on the philosophy that learning patterns automatically from data is generally better than meticulously crafting rules by hand. This data-driven approach has delivered: today, machine learning techniques can be found in a wide range of application areas, both in AI and beyond. Yet, there is one domain that has conspicuously been left untouched by machine learning: the design of tools that power machine learning itself. ",
+        "bbox": [
+            174,
+            476,
+            823,
+            546
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One of the most widely used tools in machine learning is optimization algorithms. We have grown accustomed to seeing an optimization algorithm as a black box that takes in a model that we design and the data that we collect and outputs the optimal model parameters. The optimization algorithm itself largely stays static: its design is reserved for human experts, who must toil through many rounds of theoretical analysis and empirical validation to devise a better optimization algorithm. Given this state of affairs, perhaps it is time for us to start practicing what we preach and learn how to learn. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            650
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, Li & Malik (2016) and Andrychowicz et al. (2016) introduced two different frameworks for learning optimization algorithms. Whereas Andrychowicz et al. (2016) focuses on learning an optimization algorithm for training models on a particular task, Li & Malik (2016) sets a more ambitious objective of learning an optimization algorithm for training models that is task-independent. We study the latter paradigm in this paper and develop a method for learning an optimization algorithm for high-dimensional stochastic optimization problems, like the problem of training shallow neural nets. ",
+        "bbox": [
+            174,
+            657,
+            825,
+            755
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Under the “Learning to Optimize” framework proposed by Li & Malik (2016), the problem of learning an optimization algorithm is formulated as a reinforcement learning problem. We consider the general structure of an unconstrained continuous optimization algorithm, as shown in Algorithm 1. In each iteration, the algorithm takes a step $\\Delta x$ and uses it to update the current iterate $\\boldsymbol { x } ^ { ( i ) }$ . In hand-engineered optimization algorithms, $\\Delta x$ is computed using some fixed formula $\\phi$ that depends on the objective function, the current iterate and past iterates. Often, it is simply a function of the current and past gradients. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Different choices of $\\phi$ yield different optimization algorithms and so each optimization algorithm is essentially characterized by its update formula $\\phi$ . Hence, by learning $\\phi$ , we can learn an optimization algorithm. Li & Malik (2016) observed that an optimization algorithm can be viewed as a Markov decision process (MDP), where the state includes the current iterate, the action is the step vector $\\Delta x$ ",
+        "bbox": [
+            176,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Require: Objective function $f$ $\\bar { x ^ { ( 0 ) } } \\gets$ random point in the domain of $f$ for $i = 1 , 2 , \\dots { \\bf d }$ o $\\Delta x \\gets \\acute { \\phi } ( f , \\{ x ^ { ( 0 ) } , \\ldots , x ^ { ( i - 1 ) } \\} )$ if stopping condition is met then return x(i−1) end if $x ^ { ( i ) } \\gets x ^ { ( i - 1 ) } + \\Delta x$ end for ",
+        "bbox": [
+            174,
+            122,
+            457,
+            252
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "and the policy is the update formula $\\phi$ . Hence, the problem of learning $\\phi$ simply reduces to a policy search problem. ",
+        "bbox": [
+            173,
+            280,
+            823,
+            308
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we build on the method proposed in (Li & Malik, 2016) and develop an extension that is suited to learning optimization algorithms for high-dimensional stochastic problems. We use it to learn an optimization algorithm for training shallow neural nets and show that it outperforms popular hand-engineered optimization algorithms like ADAM (Kingma & Ba, 2014), AdaGrad (Duchi et al., 2011) and RMSprop (Tieleman & Hinton, 2012) and an optimization algorithm learned using the supervised learning method proposed in (Andrychowicz et al., 2016). Furthermore, we demonstrate that our optimization algorithm learned from the experience of training on MNIST generalizes to training on other datasets that have very dissimilar statistics, like the Toronto Faces Dataset, CIFAR10 and CIFAR-100. ",
+        "bbox": [
+            173,
+            315,
+            825,
+            440
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            462,
+            344,
+            478
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The line of work on learning optimization algorithms is fairly recent. Li & Malik (2016) and Andrychowicz et al. (2016) were the first to propose learning general optimization algorithms. Li & Malik (2016) explored learning task-independent optimization algorithms and used reinforcement learning to learn the optimization algorithm, while Andrychowicz et al. (2016) investigated learning task-dependent optimization algorithms and used supervised learning. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            563
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the special case where objective functions that the optimization algorithm is trained on are loss functions for training other models, these methods can be used for “learning to learn” or “metalearning”. While these terms have appeared from time to time in the literature (Baxter et al., 1995; Vilalta & Drissi, 2002; Brazdil et al., 2008; Thrun & Pratt, 2012), they have been used by different authors to refer to disparate methods with different purposes. These methods all share the objective of learning some form of meta-knowledge about learning, but differ in the type of meta-knowledge they aim to learn. We can divide the various methods into the following three categories. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            667
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 LEARNING WHAT TO LEARN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            685,
+            413,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Methods in this category Thrun & Pratt (2012) aim to learn what parameter values of the base-level learner are useful across a family of related tasks. The meta-knowledge captures commonalities shared by tasks in the family, which enables learning on a new task from the family to be performed more quickly. Most early methods fall into this category; this line of work has blossomed into an area that has later become known as transfer learning and multi-task learning. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            782
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 LEARNING WHICH MODEL TO LEARN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            799,
+            478,
+            814
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Methods in this category Brazdil et al. (2008) aim to learn which base-level learner achieves the best performance on a task. The meta-knowledge captures correlations between different tasks and the performance of different base-level learners on those tasks. One challenge under this setting is to decide on a parameterization of the space of base-level learners that is both rich enough to be capable of representing disparate base-level learners and compact enough to permit tractable search over this space. Brazdil et al. (2003) proposes a nonparametric representation and stores examples of different base-level learners in a database, whereas Schmidhuber (2004) proposes representing baselevel learners as general-purpose programs. The former has limited representation power, while the latter makes search and learning in the space of base-level learners intractable. Hochreiter et al. (2001) views the (online) training procedure of any base-learner as a black box function that maps a sequence of training examples to a sequence of predictions and models it as a recurrent neural net. Under this formulation, meta-training reduces to training the recurrent net, and the base-level learner is encoded in the memory state of the recurrent net. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            186
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameter optimization can be seen as another example of methods in this category. The space of base-level learners to search over is parameterized by a predefined set of hyperparameters. Unlike the methods above, multiple trials with different hyperparameter settings on the same task are permitted, and so generalization across tasks is not required. The discovered hyperparameters are generally specific to the task at hand and hyperparameter optimization must be rerun for new tasks. Various kinds of methods have been proposed, such those based on Bayesian optimization (Hutter et al., 2011; Bergstra et al., 2011; Snoek et al., 2012; Swersky et al., 2013; Feurer et al., 2015), random search (Bergstra & Bengio, 2012) and gradient-based optimization (Bengio, 2000; Domke, 2012; Maclaurin et al., 2015). ",
+        "bbox": [
+            174,
+            194,
+            825,
+            319
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 LEARNING HOW TO LEARN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            337,
+            405,
+            351
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Methods in this category aim to learn a good algorithm for training a base-level learner. Unlike methods in the previous categories, the goal is not to learn about the outcome of learning, but rather the process of learning. The meta-knowledge captures commonalities in the behaviours of learning algorithms that achieve good performance. The base-level learner and the task are given by the user, so the learned algorithm must generalize across base-level learners and tasks. Since learning in most cases is equivalent to optimizing some objective function, learning a learning algorithm often reduces to learning an optimization algorithm. This problem was explored in (Li & Malik, 2016) and (Andrychowicz et al., 2016). Closely related is (Bengio et al., 1991), which learns a Hebblike synaptic learning rule that does not depend on the objective function, which does not allow for generalization to different objective functions. ",
+        "bbox": [
+            173,
+            363,
+            825,
+            502
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Various work has explored learning how to adjust the hyperparameters of hand-engineered optimization algorithms, like the step size (Hansen, 2016; Daniel et al., 2016; Fu et al., 2016) or the damping factor in the Levenberg-Marquardt algorithm (Ruvolo et al., 2009). Related to this line of work is stochastic meta-descent (Bray et al., 2004), which derives a rule for adjusting the step size analytically. A different line of work (Gregor & LeCun, 2010; Sprechmann et al., 2013) parameterizes intermediate operands of special-purpose solvers for a class of optimization problems that arise in sparse coding and learns them using supervised learning. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            606
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 LEARNING TO OPTIMIZE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            627,
+            411,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 SETTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            659,
+            276,
+            672
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the “Learning to Optimize” framework, we are given a set of training objective functions $f _ { 1 } , \\ldots , f _ { n }$ drawn from some distribution $\\mathcal { F }$ . An optimization algorithm $\\mathcal { P }$ takes an objective function $f$ and an initial iterate $x ^ { ( 0 ) }$ as input and produces a sequence of iterates $x ^ { ( 1 ) } , \\ldots , x ^ { ( T ) }$ , where $x ^ { ( T ) }$ is the solution found by the optimizer. We are also given a distribution $\\mathcal { D }$ that generates the initial iterate $x ^ { ( 0 ) }$ and a meta-loss $\\mathcal { L }$ , which takes an objective function $f$ and a sequence of iterates $x ^ { ( 1 ) } , \\ldots , x ^ { ( T ) }$ produced by an optimization algorithm as input and outputs a scalar that measures the quality of the iterates. The goal is to learn an optimization algorithm ${ \\mathcal { P } } ^ { * }$ such that $\\mathbb { E } _ { f \\sim \\mathcal { F } , x ^ { ( 0 ) } \\sim \\mathcal { D } } \\left[ \\mathcal { L } ( f , \\mathcal { P } ^ { * } ( f , x ^ { ( 0 ) } ) ) \\right]$ is minimized. The meta-loss is chosen to penalize optimization algorithms that exhibit behaviours we find undesirable, like slow convergence or excessive oscillations. Assuming we would like to learn an algoritha good choice of meta-loss would then simply be regret and can be interpreted as the area under the $\\textstyle \\sum _ { i = 1 } ^ { T } f ( x ^ { ( i ) } )$ zes the objective function it is given,, which is equivalent to cumulativective values over time. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The objective functions $f _ { 1 } , \\ldots , f _ { n }$ may correspond to loss functions for training base-level learners, in which case the algorithm that learns the optimization algorithm can be viewed as a meta-learner. In this setting, each objective function is the loss function for training a particular base-learner on a particular task, and so the set of training objective functions can be loss functions for training a base-learner or a family of base-learners on different tasks. At test time, the learned optimization algorithm is evaluated on unseen objective functions, which correspond to loss functions for training base-learners on new tasks, which may be completely unrelated to tasks used for training the optimization algorithm. Therefore, the learned optimization algorithm must not learn anything about the tasks used for training. Instead, the goal is to learn an optimization algorithm that can exploit the geometric structure of the error surface induced by the base-learners. For example, if the base-level model is a neural net with ReLU activation units, the optimization algorithm should hopefully learn to leverage the piecewise linearity of the model. Hence, there is a clear division of responsibilities between the meta-learner and base-learners. The knowledge learned at the meta-level should be pertinent for all tasks, whereas the knowledge learned at the base-level should be task-specific. The meta-learner should therefore generalize across tasks, whereas the base-learner should generalize across instances. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 RL PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            286,
+            352,
+            301
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The goal of reinforcement learning is to learn to interact with an environment in a way that minimizes cumulative costs that are expected to be incurred over time. The environment is formalized as a partially observable Markov decision process $( \\mathrm { P O M D P } ) ^ { 1 }$ , which is defined by the tuple $( S , \\mathcal { O } , \\mathcal { A } , p _ { i } , p , p _ { o } , c , T )$ , where $\\mathcal { S } \\subseteq \\mathbb { R } ^ { D }$ is the set of states, $\\mathcal { O } \\subseteq \\mathbb { R } ^ { D ^ { \\prime } }$ is the set of observations, $\\mathcal { A } \\subseteq \\mathbb { R } ^ { d }$ is the set of actions, $p _ { i } \\left( s _ { 0 } \\right)$ is the probability density over initial states $s _ { 0 }$ , $p \\left( { { s } _ { t + 1 } } \\left| { { s } _ { t } } , { { a } _ { t } } \\right. \\right)$ is the probability density over the subsequent state $s _ { t + 1 }$ given the current state $s _ { t }$ and action $a _ { t }$ , $p _ { o } \\left( o _ { t } \\bar { | } _ { s _ { t } } \\right)$ is the probability density over the current observation $o _ { t }$ given the current state $s _ { t }$ , $c : { \\mathcal { S } }  \\mathbb { R }$ is a function that assigns a cost to each state and $T$ is the time horizon. Often, the probability densities $p$ and $p _ { o }$ are unknown and not given to the learning algorithm. ",
+        "bbox": [
+            173,
+            313,
+            825,
+            441
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A policy $\\pi \\left( \\boldsymbol { a } _ { t } | \\boldsymbol { o } _ { t } , t \\right)$ is a conditional probability density over actions $a _ { t }$ given the current observation $o _ { t }$ and time step $t$ . When a policy is independent of $t$ , it is known as a stationary policy. The goal of the reinforcement learning algorithm is to learn a policy $\\pi ^ { * }$ that minimizes the total expected cost over time. More precisely, ",
+        "bbox": [
+            174,
+            446,
+            825,
+            503
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b919d595be0d1a432a00d2fbbfe2eab638d4374ebd57fafd68cfd8d40797150b.jpg",
+        "text": "$$\n\\pi ^ { * } = \\arg \\operatorname* { m i n } _ { \\pi } \\mathbb { E } _ { s _ { 0 } , a _ { 0 } , s _ { 1 } , \\dots , s _ { T } } \\left[ \\sum _ { t = 0 } ^ { T } c ( s _ { t } ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            510,
+            637,
+            554
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the expectation is taken with respect to the joint distribution over the sequence of states and actions, often referred to as a trajectory, which has the density ",
+        "bbox": [
+            173,
+            558,
+            821,
+            587
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/51df13704307a3794a4cd1301cf4a3226c41c612fa6a34d8eca973a93a49d9ae.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\displaystyle q \\big ( s _ { 0 } , a _ { 0 } , s _ { 1 } , \\ldots , s _ { T } \\big ) = \\int _ { o _ { 0 } , \\ldots , o _ { T } } p _ { i } \\left( s _ { 0 } \\right) p _ { o } \\left( o _ { 0 } \\big | s _ { 0 } \\right) } } \\\\ { { { \\displaystyle \\prod _ { t = 0 } ^ { T - 1 } \\pi \\left( \\left. a _ { t } \\right| o _ { t } , t \\right) p \\left( \\left. s _ { t + 1 } \\right| s _ { t } , a _ { t } \\right) p _ { o } \\left( \\left. o _ { t + 1 } \\right| s _ { t + 1 } \\right) . } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            592,
+            689,
+            672
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To make learning tractable, $\\pi$ is often constrained to lie in a parameterized family. A common assumption is that $\\pi \\left( \\left. a _ { t } \\right| o _ { t } , t \\right) = \\mathcal { N } \\left( \\mu ^ { \\pi } ( o _ { t } ) , \\Sigma ^ { \\pi } ( o _ { t } ) \\right)$ , where $\\textstyle { \\mathcal { N } } ( { \\boldsymbol { \\mu } } , { \\boldsymbol { \\Sigma } } )$ denotes the density of a Gaussian with mean $\\mu$ and covariance $\\Sigma$ . The functions $\\mu ^ { \\pi } ( \\cdot )$ and possibly $\\Sigma ^ { \\pi } ( \\cdot )$ are modelled using function approximators, whose parameters are learned. ",
+        "bbox": [
+            176,
+            684,
+            821,
+            741
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            756,
+            318,
+            771
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In our setting, the state $s _ { t }$ consists of the current iterate $x ^ { ( t ) }$ and features $\\Phi ( \\cdot )$ that depend on the history of iterates $x ^ { ( 1 ) } , \\ldots , x ^ { ( t ) }$ , (noisy) gradients $\\nabla \\hat { f } ( x ^ { ( 1 ) } ) , \\ldots , \\nabla \\hat { f } ( x ^ { ( t ) } )$ and (noisy) objective values ${ \\hat { f } } ( x ^ { ( 1 ) } ) , \\ldots , { \\hat { f } } ( x ^ { ( t ) } )$ . The action $a _ { t }$ is the step $\\Delta x$ that will be used to update the iterate. The observation $o _ { t }$ excludes $x ^ { ( t ) }$ and consists of features $\\Psi ( \\cdot )$ that depend on the iterates, gradient and objective values from recent iterations, and the previous memory state of the learned optimization algorithm, which takes the form of a recurrent neural net. This memory state can be viewed as a statistic of the previous observations that is learned jointly with the policy. ",
+        "bbox": [
+            173,
+            781,
+            825,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Under this formulation, the initial probability density $p _ { i }$ captures how the initial iterate, gradient and objective value tend to be distributed. The transition probability density $p$ captures the how the gradient and objective value are likely to change given the step that is taken currently; in other words, it encodes the local geometry of the training objective functions. Assuming the goal is to learn an optimization algorithm that minimizes the objective function, the cost $c$ of a state $\\boldsymbol { s } _ { t } = \\left( \\boldsymbol { x } ^ { ( t ) } , \\Phi \\left( \\cdot \\right) \\right) ^ { T }$ is simply the true objective value $f ( \\boldsymbol { x } ^ { ( t ) } )$ . ",
+        "bbox": [
+            173,
+            103,
+            825,
+            195
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Any particular policy $\\pi \\left( \\boldsymbol { a } _ { t } \\left| \\boldsymbol { o } _ { t } , t \\right. \\right)$ , which generates $a _ { t } ~ = ~ \\Delta x$ at every time step, corresponds to a particular (noisy) update formula $\\phi$ , and therefore a particular (noisy) optimization algorithm. Therefore, learning an optimization algorithm simply reduces to searching for the optimal policy. ",
+        "bbox": [
+            174,
+            200,
+            821,
+            244
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The mean of the policy is modelled as a recurrent neural net fragment that corresponds to a single time step, which takes the observation features $\\Psi ( \\cdot )$ and the previous memory state as input and outputs the step to take. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            292
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 GUIDED POLICY SEARCH ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            310,
+            392,
+            325
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The reinforcement learning method we use is guided policy search (GPS) (Levine et al., 2015), which is a policy search method designed for searching over large classes of expressive non-linear policies in continuous state and action spaces. It maintains two policies, $\\psi$ and $\\pi$ , where the former lies in a time-varying linear policy class in which the optimal policy can found in closed form, and the latter lies in a stationary non-linear policy class in which policy optimization is challenging. In each iteration, it performs policy optimization on $\\psi$ , and uses the resulting policy as supervision to train $\\pi$ . ",
+        "bbox": [
+            173,
+            337,
+            826,
+            435
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "More precisely, GPS solves the following constrained optimization problem: ",
+        "bbox": [
+            173,
+            439,
+            676,
+            455
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f5be126419b4a29a54757648e664beaddb30c079479aa1e9291425a258d92b7d.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta , \\eta } \\mathbb { E } _ { \\psi } \\left[ \\sum _ { t = 0 } ^ { T } c ( s _ { t } ) \\right] \\mathrm { ~ s . t . ~ } \\psi \\left( \\left. a _ { t } \\right| s _ { t } , t ; \\eta \\right) = \\pi \\left( \\left. a _ { t } \\right| s _ { t } ; \\theta \\right) \\forall a _ { t } , s _ { t } , t\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            462,
+            696,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\eta$ and $\\theta$ denote the parameters of $\\psi$ and $\\pi$ respectively, $\\mathbb { E } _ { \\rho } \\left[ \\cdot \\right]$ denotes the expectation taken with respect to the trajectory induced by a policy $\\rho$ and $\\begin{array} { r } { \\pi \\left( \\left. a _ { t } \\right| s _ { t } ; \\theta \\right) : = \\int _ { o _ { t } } \\pi \\left( \\left. a _ { t } \\right| o _ { t } ; \\theta \\right) p _ { o } \\left( \\left. o _ { t } \\right| s _ { t } \\right) ^ { 2 } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            510,
+            823,
+            541
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since there are an infinite number of equality constraints, the problem is relaxed by enforcing equality on the mean actions taken by $\\psi$ and $\\pi$ at every time step3. So, the problem becomes: ",
+        "bbox": [
+            173,
+            547,
+            823,
+            578
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/407d95c56a995ddd518677a9f9c837a0fe2a62d6a02d1ebce4c22c60b61b0cfe.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta , \\eta } \\mathbb { E } _ { \\psi } [ \\sum _ { t = 0 } ^ { T } c ( s _ { t } ) ] \\mathrm { ~ s . t . ~ } \\mathbb { E } _ { \\psi } [ a _ { t } ] = \\mathbb { E } _ { \\psi } [ \\mathbb { E } _ { \\pi } [ a _ { t } | s _ { t } ] ] \\forall t\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            585,
+            665,
+            626
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This problem is solved using Bregman ADMM (Wang & Banerjee, 2014), which performs the following updates in each iteration: ",
+        "bbox": [
+            173,
+            638,
+            823,
+            666
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/98b4e8aee640645dca59af14914cf556ee40ccd35b91af03094a1e5f58cc3027.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\eta \\gets \\arg \\underset { \\eta } { \\operatorname* { m i n } } \\sum _ { t = 0 } ^ { T } \\mathbb { E } _ { \\psi } [ c ( s _ { t } ) - \\lambda _ { t } ^ { T } a _ { t } ] + \\nu _ { t } D _ { t } ( \\eta , \\theta ) } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\quad } \\\\ & { \\theta \\gets \\arg \\underset { \\theta } { \\operatorname* { m i n } } \\sum _ { t = 0 } ^ { T } \\lambda _ { t } ^ { T } \\mathbb { E } _ { \\psi } [ \\mathbb { E } _ { \\pi } [ a _ { t } | s _ { t } ] ] + \\nu _ { t } D _ { t } ( \\theta , \\eta ) } \\\\ & { \\quad \\quad \\quad \\quad \\quad \\quad \\quad \\lambda _ { t } \\gets \\lambda _ { t } + \\alpha \\nu _ { t } ( \\mathbb { E } _ { \\psi } [ \\mathbb { E } _ { \\pi } [ a _ { t } | s _ { t } ] ] - \\mathbb { E } _ { \\psi } [ a _ { t } ] ) \\ \\forall t , } \\\\ & { \\mathrm { ~ } \\mathrm { ~ } : \\mathrm { r e } \\quad D _ { t } ( \\theta , \\eta ) \\quad : = \\quad \\mathbb { E } _ { \\psi } [ D _ { K L } ( \\pi ( a _ { t } | s _ { t } ; \\theta ) ) ] \\ \\psi ( a _ { t } | s _ { t } , t ; \\eta ) ) ] \\quad \\mathrm { ~ a n d ~ } \\quad D _ { t } ( \\eta , \\theta ) } \\\\ & { [ D _ { K L } ( \\psi ( a _ { t } | s _ { t } , t ; \\eta ) ] ) | \\ \\pi ( a _ { t } | s _ { t } ; \\theta ) ) | . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            169,
+            672,
+            825,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The algorithm assumes that $\\psi \\left( \\left. a _ { t } \\right| s _ { t } , t ; \\eta \\right) = \\mathcal { N } \\left( K _ { t } s _ { t } + k _ { t } , G _ { t } \\right)$ , where $\\boldsymbol { \\eta } : = \\left( K _ { t } , k _ { t } , G _ { t } \\right) _ { t = 1 } ^ { T }$ and $\\pi \\left( a _ { t } | o _ { t } ; \\theta \\right) = \\mathcal { N } \\left( \\mu _ { \\omega } ^ { \\pi } ( o _ { t } ) , \\Sigma ^ { \\pi } \\right)$ , where $\\boldsymbol { \\theta } : = ( \\omega , \\Sigma ^ { \\pi } )$ and $\\mu _ { \\omega } ^ { \\pi } ( \\cdot )$ can be an arbitrary function that is typically modelled using a nonlinear function approximator like a neural net. ",
+        "bbox": [
+            173,
+            815,
+            825,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "At the start of each iteration, the algorithm constructs a model of the transition probability density $\\tilde { p } \\left( \\left. s _ { t + 1 } \\right| s _ { t } , a _ { t } , t ; \\zeta \\right) = \\mathcal { N } ( A _ { t } s _ { t } + B _ { t } a _ { t } + c _ { t } , F _ { t } )$ , where $\\boldsymbol { \\zeta } : = \\left( A _ { t } , B _ { t } , c _ { t } , F _ { t } \\right) _ { t = 1 } ^ { T }$ is fitted to samples of $s _ { t }$ drawn from the trajectory induced by $\\psi$ , which essentially amounts to a local linearization of the true transition probability $p \\left( \\left. s _ { t + 1 } \\right| s _ { t } , a _ { t } , t \\right)$ . We will use $\\mathbb { E } _ { \\widetilde { \\psi } } \\left[ \\cdot \\right]$ to denote expectation taken with respect to the trajectory induced by $\\psi$ under the modelled transition probability $\\tilde { p }$ . Additionally, the algorithm fits local quadratic approximations to $c ( s _ { t } )$ around samples of $s _ { t }$ drawn from the trajectory induced by $\\psi$ so that $\\begin{array} { r } { c ( s _ { t } ) \\approx \\dot { \\tilde { c } } \\dot { ( s _ { t } ) } : = \\frac { 1 } { 2 } s _ { t } ^ { T } C _ { t } s _ { t } + \\dot { d _ { t } ^ { T } } s _ { t } + h _ { t } } \\end{array}$ for $s _ { t }$ ’s that are near the samples. ",
+        "bbox": [
+            173,
+            102,
+            825,
+            208
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With these assumptions, the subproblem that needs to be solved to update $\\eta ~ = ~ ( K _ { t } , k _ { t } , G _ { t } ) _ { t = 1 } ^ { T }$ becomes: ",
+        "bbox": [
+            173,
+            215,
+            820,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/da17dbd224435326b9983c40ce40ffd1486ed56e1c09a13c8b435c27ba5a8491.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { \\underset { \\eta } { \\operatorname* { m i n } } \\displaystyle \\sum _ { t = 0 } ^ { T } \\mathbb { E } _ { \\boldsymbol { \\tilde { \\psi } } } [ \\boldsymbol { \\tilde { c } } ( s _ { t } ) - \\lambda _ { t } ^ { T } \\boldsymbol { a } _ { t } ] + \\nu _ { t } D _ { t } ( \\eta , \\theta ) } & \\\\ & { \\mathrm { s . t . } \\displaystyle \\sum _ { t = 0 } ^ { T } \\mathbb { E } _ { \\boldsymbol { \\tilde { \\psi } } } [ D _ { K L } ( \\boldsymbol { \\psi } ( \\boldsymbol { a } _ { t } | \\boldsymbol { s } _ { t } , t ; \\eta ) | \\Big | \\psi ( \\boldsymbol { a } _ { t } | \\boldsymbol { s } _ { t } , t ; \\eta ^ { \\prime } ) ) ] \\leq \\epsilon , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            248,
+            676,
+            329
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\eta ^ { \\prime }$ denotes the old $\\eta$ from the previous iteration. Because $\\tilde { p }$ and $\\tilde { c }$ are only valid locally around the trajectory induced by $\\psi$ , the constraint is added to limit the amount by which $\\eta$ is updated. It turns out that the unconstrained problem can be solved in closed form using a dynamic programming algorithm known as linear-quadratic-Gaussian (LQG) regulator in time linear in the time horizon $T$ and cubic in the dimensionality of the state space $D$ . The constrained problem is solved using dual gradient descent, which uses LQG as a subroutine to solve for the primal variables in each iteration and increments the dual variable on the constraint until it is satisfied. ",
+        "bbox": [
+            173,
+            334,
+            826,
+            433
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Updating $\\theta$ is straightforward, since expectations taken with respect to the trajectory induced by $\\pi$ are always conditioned on $s _ { t }$ and all outer expectations over $s _ { t }$ are taken with respect to the trajectory induced by $\\psi$ . Therefore, $\\pi$ is essentially decoupled from the transition probability $p \\left( \\left. s _ { t + 1 } \\right| s _ { t } , a _ { t } , t \\right)$ and so its parameters can be updated without affecting the distribution of $s _ { t }$ ’s. The subproblem that needs to be solved to update $\\theta$ therefore amounts to a standard supervised learning problem. ",
+        "bbox": [
+            174,
+            439,
+            825,
+            510
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since $\\psi \\left( \\boldsymbol { a } _ { t } | \\boldsymbol { s } _ { t } , t ; \\boldsymbol { \\eta } \\right)$ and $\\pi \\left( \\boldsymbol { a } _ { t } | \\boldsymbol { s } _ { t } ; \\boldsymbol { \\theta } \\right)$ are Gaussian, $D _ { t } \\left( { \\theta , \\eta } \\right)$ can be computed analytically. More concretely, if we assume $\\Sigma ^ { \\pi }$ to be fixed for simplicity, the subproblem that is solved for updating $\\theta = \\left( \\omega , \\Sigma ^ { \\pi } \\right)$ is: ",
+        "bbox": [
+            174,
+            515,
+            825,
+            559
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ec360d7a6f7432925bf8f970733b046a6e04fac406cb257daeefeab826336ea9.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\operatorname* { m i n } _ { \\theta } \\mathbb { E } _ { \\psi } [ \\sum _ { t = 0 } ^ { T } \\lambda _ { t } ^ { T } \\mu _ { \\omega } ^ { \\pi } ( o _ { t } ) + \\frac { \\nu _ { t } } { 2 } ( \\operatorname { t r } ( G _ { t } ^ { - 1 } \\Sigma ^ { \\pi } ) - \\log | \\Sigma ^ { \\pi } | )  } \\\\ { \\displaystyle  + \\frac { \\nu _ { t } } { 2 } ( \\mu _ { \\omega } ^ { \\pi } ( o _ { t } ) - \\mathbb { E } _ { \\psi } [ a _ { t } | s _ { t } , t ] ) ^ { T } G _ { t } ^ { - 1 } ( \\mu _ { \\omega } ^ { \\pi } ( o _ { t } ) - \\mathbb { E } _ { \\psi } [ a _ { t } | s _ { t } , t ] ) ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            583,
+            736,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that the last term is the squared Mahalanobis distance between the mean actions of $\\psi$ and $\\pi$ at time step $t$ , which is intuitive as we would like to encourage $\\pi$ to match $\\psi$ . ",
+        "bbox": [
+            173,
+            676,
+            823,
+            705
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.5 CONVOLUTIONAL GPS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            375,
+            738
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The problem of learning high-dimensional optimization algorithms presents challenges for reinforcement learning algorithms due to high dimensionality of the state and action spaces. For example, in the case of GPS, because the running time of LQG is cubic in dimensionality of the state space, performing policy search even in the simple class of linear-Gaussian policies would be prohibitively expensive when the dimensionality of the optimization problem is high. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            820
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Fortunately, many high-dimensional optimization problems have underlying structure that can be exploited. For example, the parameters of neural nets are equivalent up to permutation among certain coordinates. More concretely, for fully connected neural nets, the dimensions of a hidden layer and the corresponding weights can be permuted arbitrarily without changing the function they compute. Because permuting the dimensions of two adjacent layers can permute the weight matrix arbitrarily, an optimization algorithm should be invariant to permutations of the rows and columns of a weight matrix. A reasonable prior to impose is that the algorithm should behave in the same manner on all coordinates that correspond to entries in the same matrix. That is, if the values of two coordinates in all current and past gradients and iterates are identical, then the step vector produced by the algorithm should have identical values in these two coordinates. We will refer to the set of coordinates on which permutation invariance is enforced as a coordinate group. For the purposes of learning an optimization algorithm for neural nets, a natural choice would be to make each coordinate group correspond to a weight matrix or a bias vector. Hence, the total number of coordinate groups is twice the number of layers, which is usually fairly small. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/c32356121b006ac72da2adddd464187f503567b08623692799a8cd7bffe7f36e.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of the various hand-engineered and learned algorithms on training neural nets with 48 input and hidden units on (a) TFD, (b) CIFAR-10 and (c) CIFAR-100 with mini-batches of size 64. The vertical axis is the true objective value and the horizontal axis represents the iteration. Best viewed in colour. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            122,
+            782,
+            237
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            334,
+            825,
+            433
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the case of GPS, we impose this prior on both $\\psi$ and $\\pi$ . For the purposes of updating $\\eta$ , we first impose a block-diagonal structure on the parameters $A _ { t } , B _ { t }$ and $F _ { t }$ of the fitted transition probability density $\\tilde { p } \\left( \\left. s _ { t + 1 } \\right| s _ { t } , a _ { t } , t ; \\zeta \\right) = \\mathcal { N } ( A _ { t } s _ { t } + B _ { t } a _ { t } + c _ { t } , F _ { t } )$ , so that for each coordinate in the optimization problem, the dimensions of $s _ { t + 1 }$ that correspond to the coordinate only depend on the dimensions of $s _ { t }$ and $a _ { t }$ that correspond to the same coordinate. As a result, $\\tilde { p } \\big ( s _ { t + 1 } \\big | s _ { t } , a _ { t } , t ; \\zeta \\big )$ decomposes into multiple independent probability densities $\\tilde { p } ^ { j } \\left( s _ { t + 1 } ^ { j } \\Big | s _ { t } ^ { j } , a _ { t } ^ { j } , t ; \\zeta ^ { j } \\right)$ , one for each coordinate $j$ . Similarly, we also impose a block-diagonal structure on $C _ { t }$ for fitting $\\tilde { c } ( s _ { t } )$ and on the parameter matrix of the fitted model for $\\pi \\left( a _ { t } | \\boldsymbol s _ { t } \\bar { ; \\boldsymbol \\theta } \\right)$ . Under these assumptions, $K _ { t }$ and $G _ { t }$ are guaranteed to be block-diagonal as well. Hence, the Bregman divergence penalty term, $D \\left( \\eta , \\theta \\right)$ decomposes into a sum of Bregman divergence terms, one for each coordinate. ",
+        "bbox": [
+            173,
+            439,
+            825,
+            588
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We then further constrain dual variables $\\lambda _ { t }$ , sub-vectors of parameter vectors and sub-matrices of parameter matrices corresponding to each coordinate group to be identical across the group. Additionally, we replace the weight $\\nu _ { t }$ on $D \\left( \\eta , \\theta \\right)$ with an individual weight on each Bregman divergence term for each coordinate group. The problem then decomposes into multiple independent subproblems, one for each coordinate group. Because the dimensionality of the state subspace corresponding to each coordinate is constant, LQG can be executed on each subproblem much more efficiently. ",
+        "bbox": [
+            173,
+            595,
+            825,
+            679
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Similarly, for $\\pi$ , we choose a $\\mu _ { \\omega } ^ { \\pi } ( \\cdot )$ that shares parameters across different coordinates in the same group. We also impose a block-diagonal structure on $\\Sigma ^ { \\pi }$ and constrain the appropriate sub-matrices to share their entries. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            728
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.6 FEATURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            748,
+            287,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We describe the features $\\Phi ( \\cdot )$ and $\\Psi ( \\cdot )$ at time step $t$ , which define the state $s _ { t }$ and observation $o _ { t }$ respectively. ",
+        "bbox": [
+            174,
+            775,
+            825,
+            805
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Because of the stochasticity of gradients and objective values, the state features $\\Phi ( \\cdot )$ are defined in terms of summary statistics of the history of iterates $\\left\\{ x ^ { ( i ) } \\right\\} _ { i = 0 } ^ { t }$ , gradients $\\left\\{ \\nabla \\hat { f } ( x ^ { ( i ) } ) \\right\\} _ { i = 0 } ^ { t }$ and objective values $\\left\\{ \\hat { f } ( \\boldsymbol x ^ { ( i ) } ) \\right\\} _ { i = 0 } ^ { t }$ We define the following statistics, which we will refer to as the average recent iterate, gradient and objective value respectively: ",
+        "bbox": [
+            173,
+            810,
+            826,
+            893
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/127a52a319bf4db3aba86fdbf80c5271cf7ab40491a1981f2627a709932c8dc8.jpg",
+        "text": "$$\n\\begin{array} { r } { \\overline { { \\boldsymbol { x } ^ { ( i ) } } } : = \\frac { 1 } { \\operatorname* { m i n } ( i + 1 , 3 ) } \\sum _ { j = \\operatorname* { m a x } ( i - 2 , 0 ) } ^ { i } \\boldsymbol { x } ^ { ( j ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            907,
+            465,
+            928
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3fea8480e1dc0f7dbc3c3a6dc8993cac0f6ffab3eae77436f1e3e961bbffec59.jpg",
+        "image_caption": [
+            "Figure 2: Comparison of the various hand-engineered and learned algorithms on training neural nets with 100 input units and 200 hidden units on (a) TFD, (b) CIFAR-10 and (c) CIFAR-100 with minibatches of size 64. The vertical axis is the true objective value and the horizontal axis represents the iteration. Best viewed in colour. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            121,
+            782,
+            237
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7a6761589b90ee0c7200cf58fa051acd5f2b63ec2d32a67a2f1eb5d8569dab37.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\bullet \\ \\overline { { \\nabla \\hat { f } ( x ^ { ( i ) } ) } } : = \\frac { 1 } { \\operatorname* { m i n } ( i + 1 , 3 ) } \\sum _ { j = \\operatorname* { m a x } ( i - 2 , 0 ) } ^ { i } { \\nabla \\hat { f } ( x ^ { ( j ) } ) } } \\\\ & { \\bullet \\ \\overline { { \\hat { f } ( x ^ { ( i ) } ) } } : = \\frac { 1 } { \\operatorname* { m i n } ( i + 1 , 3 ) } \\sum _ { j = \\operatorname* { m a x } ( i - 2 , 0 ) } ^ { i } \\hat { f } ( x ^ { ( j ) } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            328,
+            532,
+            377
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The state features $\\Phi ( \\cdot )$ consist of the relative change in the average recent objective value, the average recent gradient normalized by the magnitude of the a previous average recent gradient and a previous change in average recent iterate relative to the current change in average recent iterate: ",
+        "bbox": [
+            174,
+            387,
+            823,
+            430
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1c2af21e865a7d14970ed22ee4629d67c1f8d6b7a64a8e247bf2ff52147bdb2e.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\bullet \\{ ( \\hat { f } ( x ^ { ( t - 5 i ) } ) - \\widehat { f } ( x ^ { ( t - 5 ( i + 1 ) ) } ) ) /  \\widehat { f } ( x ^ { ( t - 5 ( i + 1 ) ) } ) \\} _ { i = 0 } ^ { 2 4 } } \\\\ & { \\bullet  \\{ \\overline { { \\nabla \\hat { f } ( x ^ { ( t - 5 i ) } ) } } / ( | \\overline { { \\nabla \\hat { f } ( x ^ { ( m a x ( t - 5 ( i + 1 ) , t \\mathrm { m o d } 5 ) ) } ) } } | + 1 ) \\} _ { i = 0 } ^ { 2 5 } } \\\\ &  \\bullet  \\{ \\frac { | \\frac { \\overline { { x ^ { ( \\mathrm { m a x } ( t - 5 ( i + 1 ) , t \\mathrm { m o d } 5 + 5 ) ) } } } - \\overline { { x ^ { ( \\mathrm { m a x } ( t - 5 ( i + 2 ) , t \\mathrm { m o d } 5 ) ) } } } } { | \\overline { { x ^ { ( t - 5 i ) } } } - \\overline { { x ^ { ( t - 5 ( i + 1 ) ) } } } | + 0 . 1 } \\} _ { i = 0 } ^ { 2 4 } \\} _ { i = 0 } ^ { 2 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            440,
+            584,
+            537
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Note that all operations are applied element-wise. Also, whenever a feature becomes undefined (i.e.: when the time step index becomes negative), it is replaced with the all-zeros vector. ",
+        "bbox": [
+            176,
+            545,
+            821,
+            574
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Unlike state features, which are only used when training the optimization algorithm, observation features $\\Psi ( \\cdot )$ are used both during training and at test time. Consequently, we use noisier observation features that can be computed more efficiently and require less memory overhead. The observation features consist of the following: ",
+        "bbox": [
+            174,
+            580,
+            825,
+            637
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1f917eed8b0253b0c9e42f56b3a726b04c793a3b7caf3b66cb9ae38147b4b29a.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\bullet } & { \\left( \\hat { f } ( x ^ { ( t ) } ) - \\hat { f } ( x ^ { ( t - 1 ) } ) \\right) / \\hat { f } ( x ^ { ( t - 1 ) } ) } \\\\ & { \\bullet \\ \\nabla \\hat { f } ( x ^ { ( t ) } ) / \\left( \\left| \\nabla \\hat { f } ( x ^ { ( \\operatorname* { m a x } ( t - 1 , 0 ) ) } ) \\right| + 1 \\right) } \\\\ & { \\bullet \\ \\frac { \\left| x ^ { ( \\operatorname* { m a x } ( t - 1 , 1 ) ) } - x ^ { ( \\operatorname* { m a x } ( t - 2 , 0 ) ) } \\right| } { \\left| x ^ { ( t ) } - x ^ { ( t - 1 ) } \\right| + 0 . 1 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            647,
+            470,
+            731
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            746,
+            328,
+            761
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For clarity, we will refer to training of the optimization algorithm as “meta-training” to differentiate it from base-level training, which will simply be referred to as “training”. ",
+        "bbox": [
+            173,
+            776,
+            821,
+            806
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We meta-trained an optimization algorithm on a single objective function, which corresponds to the problem of training a two-layer neural net with 48 input units, 48 hidden units and 10 output units on a randomly projected and normalized version of the MNIST training set with dimensionality 48 and unit variance in each dimension. We modelled the optimization algorithm using an recurrent neural net with a single layer of 128 LSTM (Hochreiter & Schmidhuber, 1997) cells. We used a time horizon of 400 iterations and a mini-batch size of 64 for computing stochastic gradients and objective values. We evaluate the optimization algorithm on its ability to generalize to unseen objective functions, which correspond to the problems of training neural nets on different tasks/datasets. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/dba70d81f44e9b66aeedbf35fb705247b4161ee34db83bed3b4ba0993a37fd89.jpg",
+        "image_caption": [
+            "Figure 3: Comparison of the various hand-engineered and learned algorithms on training neural nets with 48 input and hidden units on (a) TFD, (b) CIFAR-10 and (c) CIFAR-100 with mini-batches of size 10. The vertical axis is the true objective value and the horizontal axis represents the iteration. Best viewed in colour. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            122,
+            782,
+            237
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/afba0d91683764d4cd4161719336a9f48fc43fabd99a2b8440e62626e6cabcb3.jpg",
+        "image_caption": [
+            "Figure 4: Comparison of the various hand-engineered and learned algorithms on training neural nets with 100 input units and 200 hidden units on (a) TFD, (b) CIFAR-10 and (c) CIFAR-100 with minibatches of size 10. The vertical axis is the true objective value and the horizontal axis represents the iteration. Best viewed in colour. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            352,
+            782,
+            468
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the learned optimization algorithm on three datasets, the Toronto Faces Dataset (TFD), CIFAR-10 and CIFAR-100. These datasets are chosen for their very different characteristics from MNIST and each other: TFD contains 3300 grayscale images that have relatively little variation and has seven different categories, whereas CIFAR-100 contains 50,000 colour images that have varied appearance and has 100 different categories. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            646
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "All algorithms are tuned on the training objective function. For hand-engineered algorithms, this entails choosing the best hyperparameters; for learned algorithms, this entails meta-training on the objective function. We compare to the seven hand-engineered algorithms: stochastic gradient descent, momentum, conjugate gradient, L-BFGS, ADAM, AdaGrad and RMSprop. In addition, we compare to an optimization algorithm meta-trained using the method described in (Andrychowicz et al., 2016) on the same training objective function (training two-layer neural net on randomly projected and normalized MNIST) under the same setting (a time horizon of 400 iterations and a mini-batch size of 64). ",
+        "bbox": [
+            174,
+            652,
+            825,
+            763
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "First, we examine the performance of various optimization algorithms on similar objective functions. The optimization problems under consideration are those for training neural nets that have the same number of input and hidden units (48 and 48) as those used during meta-training. The number of output units varies with the number of categories in each dataset. We use the same mini-batch size as that used during meta-training. As shown in Figure 1, the optimization algorithm meta-trained using our method (which we will refer to as Predicted Step Descent) consistently descends to the optimum the fastest across all datasets. On the other hand, other algorithms are not as consistent and the relative ranking of other algorithms varies by dataset. This suggests that Predicted Step Descent has learned to be robust to variations in the data distributions, despite being trained on only one objective function, which is associated with a very specific data distribution that characterizes MNIST. It is also interesting to note that while the algorithm meta-trained using (Andrychowicz et al., 2016) (which we will refer to as L2LBGDBGD) performs well on CIFAR, it is unable to reach the optimum on TFD. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/2226d92233c78e2cc8398fe5882a7f24065a5392b547b417b88d986cc9309d20.jpg",
+        "image_caption": [
+            "Figure 5: Comparison of the various hand-engineered and learned algorithms on training neural nets with 100 input units and 200 hidden units on (a) TFD, (b) CIFAR-10 and (c) CIFAR-100 for 800 iterations with mini-batches of size 64. The vertical axis is the true objective value and the horizontal axis represents the iteration. Best viewed in colour. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            122,
+            781,
+            237
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            340,
+            823,
+            368
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Next, we change the architecture of the neural nets and see if Predicted Step Descent generalizes to the new architecture. We increase the number of input units to 100 and the number of hidden units to 200, so that the number of parameters is roughly increased by a factor of 8. As shown in Figure 2, Predicted Step Descent consistently outperforms other algorithms on each dataset, despite having not been trained to optimize neural nets of this architecture. Interestingly, while it exhibited a bit of oscillation initially on TFD and CIFAR-10, it quickly recovered and overtook other algorithms, which is reminiscent of the phenomenon reported in (Li & Malik, 2016) for low-dimensional optimization problems. This suggests that it has learned to detect when it is performing poorly and knows how to change tack accordingly. L2LBGDBGD experienced difficulties on TFD and CIFAR10 as well, but slowly diverged. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            515
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We now investigate how robust Predicted Step Descent is to stochasticity of the gradients. To this end, we take a look at its performance when we reduce the mini-batch size from 64 to 10 on both the original architecture with 48 input and hidden units and the enlarged architecture with 100 input units and 200 hidden units. As shown in Figure 3, on the original architecture, Predicted Step Descent still outperforms all other algorithms and is able to handle the increased stochasticity fairly well. In contrast, conjugate gradient and L2LBGDBGD had some difficulty handling the increased stochasticity on TFD and to a lesser extent, on CIFAR-10. In the former case, both diverged; in the latter case, both were progressing slowly towards the optimum. ",
+        "bbox": [
+            174,
+            521,
+            825,
+            633
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "On the enlarged architecture, Predicted Step Descent experienced some significant oscillations on TFD and CIFAR-10, but still managed to achieve a much better objective value than all the other algorithms. Many hand-engineered algorithms also experienced much greater oscillations than previously, suggesting that the optimization problems are inherently harder. L2LBGDBGD diverged fairly quickly on these two datasets. ",
+        "bbox": [
+            174,
+            640,
+            823,
+            709
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Finally, we try doubling the number of iterations. As shown in Figure 5, despite being trained over a time horizon of 400 iterations, Predicted Step Descent behaves reasonably beyond the number of iterations it is trained for. ",
+        "bbox": [
+            176,
+            717,
+            821,
+            758
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            789,
+            318,
+            804
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we presented a new method for learning optimization algorithms for high-dimensional stochastic problems. We applied the method to learning an optimization algorithm for training shallow neural nets. We showed that the algorithm learned using our method on the problem of training a neural net on MNIST generalizes to the problems of training neural nets on unrelated tasks/datasets like the Toronto Faces Dataset, CIFAR-10 and CIFAR-100. We also demonstrated that the learned optimization algorithm is robust to changes in the stochasticity of gradients and the neural net architecture. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, and Nando de Freitas. Learning to learn by gradient descent by gradient descent. arXiv preprint arXiv:1606.04474, 2016. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            167
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Baxter, Rich Caruana, Tom Mitchell, Lorien Y Pratt, Daniel L Silver, and Sebastian Thrun. NIPS 1995 workshop on learning to learn: Knowledge consolidation and transfer in inductive systems. https://web.archive.org/web/20000618135816/http://www. cs.cmu.edu/afs/cs.cmu.edu/user/caruana/pub/transfer.html, 1995. Accessed: 2015-12-05. ",
+        "bbox": [
+            173,
+            178,
+            825,
+            247
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Y Bengio, S Bengio, and J Cloutier. Learning a synaptic learning rule. In Neural Networks, 1991., IJCNN-91-Seattle International Joint Conference on, volume 2, pp. 969–vol. IEEE, 1991. ",
+        "bbox": [
+            176,
+            257,
+            820,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio. Gradient-based optimization of hyperparameters. Neural computation, 12(8):1889– 1900, 2000. ",
+        "bbox": [
+            173,
+            295,
+            821,
+            324
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "James Bergstra and Yoshua Bengio. Random search for hyper-parameter optimization. The Journal of Machine Learning Research, 13(1):281–305, 2012. ",
+        "bbox": [
+            173,
+            333,
+            821,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "James S Bergstra, Remi Bardenet, Yoshua Bengio, and Bal ´ azs K ´ egl. Algorithms for hyper-parameter ´ optimization. In Advances in Neural Information Processing Systems, pp. 2546–2554, 2011. ",
+        "bbox": [
+            171,
+            371,
+            821,
+            401
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "M Bray, E Koller-Meier, P Muller, L Van Gool, and NN Schraudolph. 3D hand tracking by rapid stochastic gradient descent using a skinning model. In Visual Media Production, 2004.(CVMP). 1st European Conference on, pp. 59–68. IET, 2004. ",
+        "bbox": [
+            173,
+            410,
+            823,
+            453
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pavel Brazdil, Christophe Giraud Carrier, Carlos Soares, and Ricardo Vilalta. Metalearning: applications to data mining. Springer Science & Business Media, 2008. ",
+        "bbox": [
+            174,
+            462,
+            821,
+            491
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pavel B Brazdil, Carlos Soares, and Joaquim Pinto Da Costa. Ranking learning algorithms: Using ibl and meta-learning on accuracy and time results. Machine Learning, 50(3):251–277, 2003. ",
+        "bbox": [
+            173,
+            500,
+            823,
+            530
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Daniel, Jonathan Taylor, and Sebastian Nowozin. Learning step size controllers for robust neural network training. In Thirtieth AAAI Conference on Artificial Intelligence, 2016. ",
+        "bbox": [
+            174,
+            537,
+            823,
+            568
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Domke. Generic methods for optimization-based modeling. In AISTATS, volume 22, pp. 318–326, 2012. ",
+        "bbox": [
+            173,
+            575,
+            823,
+            604
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12(Jul):2121–2159, 2011. ",
+        "bbox": [
+            173,
+            613,
+            823,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthias Feurer, Jost Tobias Springenberg, and Frank Hutter. Initializing bayesian hyperparameter optimization via meta-learning. In AAAI, pp. 1128–1135, 2015. ",
+        "bbox": [
+            173,
+            651,
+            823,
+            683
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jie Fu, Zichuan Lin, Miao Liu, Nicholas Leonard, Jiashi Feng, and Tat-Seng Chua. Deep q-networks for accelerating the training of deep neural networks. arXiv preprint arXiv:1606.01467, 2016. ",
+        "bbox": [
+            171,
+            690,
+            823,
+            720
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karol Gregor and Yann LeCun. Learning fast approximations of sparse coding. In Proceedings of the 27th International Conference on Machine Learning (ICML-10), pp. 399–406, 2010. ",
+        "bbox": [
+            173,
+            728,
+            825,
+            758
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Samantha Hansen. Using deep q-learning to control optimization hyperparameters. arXiv preprint arXiv:1602.04062, 2016. ",
+        "bbox": [
+            173,
+            767,
+            823,
+            795
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            805,
+            823,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter, A Steven Younger, and Peter R Conwell. Learning to learn using gradient descent. In International Conference on Artificial Neural Networks, pp. 87–94. Springer, 2001. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Frank Hutter, Holger H Hoos, and Kevin Leyton-Brown. Sequential model-based optimization for general algorithm configuration. In Learning and Intelligent Optimization, pp. 507–523. Springer, 2011. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. arXiv preprint arXiv:1504.00702, 2015. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ke Li and Jitendra Malik. Learning to optimize. CoRR, abs/1606.01885, 2016. ",
+        "bbox": [
+            174,
+            178,
+            694,
+            194
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dougal Maclaurin, David Duvenaud, and Ryan P Adams. Gradient-based hyperparameter optimization through reversible learning. arXiv preprint arXiv:1502.03492, 2015. ",
+        "bbox": [
+            174,
+            202,
+            821,
+            232
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Paul L Ruvolo, Ian Fasel, and Javier R Movellan. Optimization on a budget: A reinforcement learning approach. In Advances in Neural Information Processing Systems, pp. 1385–1392, 2009. ",
+        "bbox": [
+            173,
+            239,
+            823,
+            270
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jurgen Schmidhuber. Optimal ordered problem solver. ¨ Machine Learning, 54(3):211–254, 2004. ",
+        "bbox": [
+            173,
+            277,
+            813,
+            295
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical bayesian optimization of machine learning algorithms. In Advances in neural information processing systems, pp. 2951–2959, 2012. ",
+        "bbox": [
+            169,
+            301,
+            823,
+            332
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pablo Sprechmann, Roee Litman, Tal Ben Yakar, Alexander M Bronstein, and Guillermo Sapiro. Supervised sparse analysis and synthesis operators. In Advances in Neural Information Processing Systems, pp. 908–916, 2013. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            382
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kevin Swersky, Jasper Snoek, and Ryan P Adams. Multi-task bayesian optimization. In Advances in neural information processing systems, pp. 2004–2012, 2013. ",
+        "bbox": [
+            171,
+            391,
+            823,
+            421
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Thrun and Lorien Pratt. Learning to learn. Springer Science & Business Media, 2012. ",
+        "bbox": [
+            171,
+            429,
+            808,
+            445
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2), 2012. ",
+        "bbox": [
+            171,
+            453,
+            823,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ricardo Vilalta and Youssef Drissi. A perspective view and survey of meta-learning. Artificial Intelligence Review, 18(2):77–95, 2002. ",
+        "bbox": [
+            169,
+            491,
+            823,
+            520
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Huahua Wang and Arindam Banerjee. Bregman alternating direction method of multipliers. CoRR, abs/1306.3203, 2014. ",
+        "bbox": [
+            169,
+            529,
+            825,
+            558
+        ],
+        "page_idx": 11
+    }
+]

parse/train/ByGq7hRqKX/ByGq7hRqKX.md

@@ -0,0 +1,308 @@
+# CROSS-TASK KNOWLEDGE TRANSFER FOR VISUALLY-GROUNDED NAVIGATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Recent efforts on training visual navigation agents conditioned on language using deep reinforcement learning have been successful in learning policies for two different tasks: learning to follow navigational instructions and embodied question answering. In this paper, we aim to learn a multitask model capable of jointly learning both tasks, and transferring knowledge of words and their grounding in visual objects across tasks. The proposed model uses a novel Dual-Attention unit to disentangle the knowledge of words in the textual representations and visual objects in the visual representations, and align them with each other. This disentangled task-invariant alignment of representations facilitates grounding and knowledge transfer across both tasks. We show that the proposed model outperforms a range of baselines on both tasks in simulated 3D environments. We also show that this disentanglement of representations makes our model modular, interpretable, and allows for transfer to instructions containing new words by leveraging object detectors.
+
+# 1 INTRODUCTION
+
+Deep reinforcement learning has been shown to be capable of achieving super-human performance in playing games such as Atari 2600 (Mnih et al., 2013) and Go (Silver et al., 2016). Following the success of deep reinforcement learning in 3D Games such as Doom (Lample & Chaplot, 2017; Dosovitskiy & Koltun, 2017) and DeepmindLab (Mnih et al., 2016), there has been increased interest in using deep reinforcement learning for training embodied agents, which interact with a 3D environment by receiving first-person views of the environment and taking navigational actions. The simplest navigational agents learn a particular behaviour such as collecting or avoiding particular objects (Kempka et al., 2016; Jaderberg et al., 2016; Mirowski et al., 2016) or playing deathmatches (Lample & Chaplot, 2017; Dosovitskiy & Koltun, 2017). Subsequently, there have been efforts on training navigational agents whose behaviour is conditioned on a target specified using images (Zhu et al., 2017) or coordinates (Gupta et al., 2017a; Savva et al., 2017). More recently, there has been much interest in training agents conditioned on language as it offers several advantages over using images or coordinates.
+
+Firstly, the compositionality of language allows generalization to new tasks without additional learning. Prior work (Oh et al., 2017; Hermann et al., 2017; Chaplot et al., 2017) has trained navigational agents to follow instructions and shown zero-shot generalization to new instructions which contain unseen composition of words seen in the training instructions. Secondly, language is also a convenient means for humans to communicate with autonomous agents. Language not only allows instruction but also interaction. Gordon et al. (2018) and Das et al. (2017) train agents to answer questions by navigating in the environment to gather the required information.
+
+These multimodal tasks involve several challenges, such as perception from raw pixels, grounding of words in the instruction or question to visual objects and attributes, reasoning to perform relational tasks, fine-grained navigation in 3D environments with continuous state space, and learning to answer questions. Training a multi-task model can also facilitate knowledge transfer between the tasks and allow the model to generalize to scenarios which were not possible with single tasks. For example, if an agent learns to follow the instruction ‘Go to the red pillar’ and answer the question ‘What color is the torch?’, then it should also be able to follow the instruction ‘Go to the red torch’ and answer the question ‘What color is the pillar?’ without any additional training.
+
+In this paper, we aim to train a multi-task navigation model to follow instructions and answer questions. To test the generalization of multi-task models, we define cross-task knowledge transfer as an evaluation criteria, evaluating zero-shot learning on instructions and questions consisting of unseen composition of words in both tasks. In order to achieve cross-task knowledge transfer, words in the input space of both tasks need to be aligned with each other and with the answer space while they are being grounded to visual objects and attributes. Prior models fail to achieve this as they are designed for a single task. We propose a novel dual-attention model involving sequential Gated- and Spatial-Attention operations to perform explicit task-invariant alignment between the image representation channels and the words in the input and answer space. We create datasets and simulation scenarios for testing cross-task knowledge transfer in the Doom environment (Kempka et al., 2016) and show that the proposed model outperforms a range of baselines on both tasks. Additionally, we demonstrate that the modularity of our model allows easy addition of new objects and attributes to a trained model. We plan to open-source the implementation of our proposed model as well as the datasets and simulation environments.
+
+![](images/c73220668e2566d5356bf6cee3722954a8f4847bd33438358c45fbb39f48d227.jpg)  
+Figure 1: An example of first-person view in the 3D Doom environment with sample instructions and questions. The test set consists of unseen instructions and questions. The dataset evaluates a model for cross-task knowledge transfer between Semantic Goal Navigation (SGN) and Embodied Question Answering (EQA).
+
+# 2 RELATED WORK
+
+This paper is motivated by a series of works on learning to follow navigation instructions (Oh et al., 2017; Hermann et al., 2017; Chaplot et al., 2017; Wu et al., 2018; Yu et al., 2018a) and learning to answer questions by navigating around the environment (Das et al., 2017; Gordon et al., 2018). Among methods learning from instructions in 3D environments, Oh et al. (2017) introduced a hierarchical RL model for learning sequences of instructions by learning skills to solve subtasks. Chaplot et al. (2017) introduced a gated-attention model for multimodal fusion of textual and visual representations using multiplicative interactions, whereas Hermann et al. (2017) introduced auxiliary tasks such as temporal autoencoding and language prediction to improve sample efficiency for this task. Yu et al. (2018a) proposed guided feature transformation which involves transformation of visual representations using latent sentence embeddings computed from the language input.
+
+Among models for embodied question answering, Das et al. (2017) introduced a hierarchical model consisting of 4 modules, each for processing images, encoding questions, navigation, and questionanswering, each of which is pretrained with supervised or imitation learning, followed by fine-tuning of the navigation model using reinforcement learning. Gordon et al. (2018) introduced the task of Interactive Question Answering which involves interacting with objects in the environment with non-navigational actions for answering questions. They proposed Hierarchical Interactive Memory Network (HIMN), which allows temporal abstraction using a factorized set of controllers.
+
+All of the above methods are designed for a single task, following navigational instructions or answering questions, whereas we aim to train a single model for both tasks. Yu et al. (2018b) introduced a model for interactive language acquisition by training on both Visual Question Answering and following instructions in a 2D grid world environment. We aim to tackle multimodal multitask learning in challenging 3D environments. Partial observability results in the requirement of learning to navigate for answering the questions, turning visual question answering to embodied question answering. 3D environments also allow us to test on interesting and more challenging instructions based on relative size of the objects, in addition to colors and types.
+
+In addition to the above, there is a huge body of work on multimodal learning in static settings which do not involve navigation or reinforcement learning. Some relevant works which use attention mechanisms similar to the ones used in our proposed model include Perez et al. (2017); Fukui et al. (2016); Xu & Saenko (2016); Hudson & Manning (2018); Gupta et al. (2017b) for Visual Question Answering and Zhao et al. (2018) for grounding audio to vision.
+
+![](images/a49406c1969d1fd52bfa11b26df5a13669079ff90e34764405f0a9c3943df268.jpg)  
+Figure 2: Overview of our proposed architecture, described in detail in Section 4.
+
+# 3 PROBLEM FORMULATION
+
+Consider an autonomous agent interacting with an episodic environment as shown in Figure 1. In the beginning of each episode, the agent receives a textual input $T$ specifying the task that it needs to achieve. For example, $T$ could be an instruction describing the target object or a question querying about some visual detail of objects in the environment. At each time step $t$ , the agent observes a state $s _ { t } = ( I _ { t } , T )$ where $I _ { t }$ is the first-person (egocentric) view of the environment, and takes an action $a _ { t }$ , which could be a navigational action or an answer action. The agent’s objective is to learn a policy $\pi ( a _ { t } | s _ { t } )$ which leads to successful completion of the task specified by the textual input $T$ .
+
+Tasks. We focus on the multi-task learning of two visually-grounded language navigation tasks: In Embodied Question Answering $( E Q A )$ , the agent is given a question (“What color is the torch?”), and it must navigate around the 3D environment to explore the environment and gather information to answer the question (“red”). In Semantic Goal Navigation (SGN), the agent is given a language instruction ( $^ { 6 6 } \mathrm { G o }$ to the red torch”) to navigate to a goal location.
+
+Environments. We adapt the ViZDoom (Kempka et al., 2016)-based language grounding environment proposed by Chaplot et al. (2017) for visually-grounded multitask learning. It consists of a single room with 5 objects. The objects are randomized in each episode based on the textual input. We use two difficulty settings for the Doom domain: Easy: The agent is spawned at a fixed location. The candidate objects are spawned at five fixed locations along a single horizontal line in the field of view of the agent. Hard: The candidate objects and the agent are spawned at random locations and the objects may or may not be in the agents field of view in the initial configuration. The agent must explore the map to view all objects.
+
+Datasets. We use the set of instructions from Chaplot et al. (2017) and create a dataset for questions using the same set of objects and attributes. We define cross-task knowledge transfer as an evaluation criteria for testing generalization of multi-task models. We create train-test splits for both instructions and questions datasets to explicitly test a multitask model’s ability to transfer the knowledge of words across different tasks. Each instruction in the test set contains a word that is never seen in any instruction in the training set but is seen in some questions in the training set. Similarly, each question in the test set contains a word never seen in any training set question. Figure 1 illustrates the train-test split of instructions and questions used in our experiments in the Doom domain. Note that for the EQA trainset, unseen words can be present in the answer.
+
+The agent can take 4 actions: 3 navigational actions (forward, left, right) and 1 answer action. When the agent takes the answer action, the answer with the maximum probability in the output answer distribution is used. Other details such as the train-test splits are deferred to the Appendix. We also report results on an additional environment based on House3D (Wu et al., 2018) in the Appendix.
+
+# 4 PROPOSED METHOD
+
+In this section, we detail our proposed architecture (illustrated in Figure 2). At the start of each episode, the agent receives a textual input $T$ (an instruction or a question) specifying the task that it needs to achieve. At each time step, the agent observes an egocentric image $I _ { t }$ which is passed through a convolutional neural network (LeCun et al., 1995) with ReLU activations (Glorot et al., 2011) to produce the image representation $x _ { I } = f ( I _ { t } ; \theta _ { \mathrm { c o n v } } ) \in \mathbb { R } ^ { V \times H \times W }$ , where $\theta _ { \mathrm { c o n v } }$ denotes the parameters of the convolutional network, $V$ is the number of feature maps in the convolutional network output which is equal to the vocabulary size, and $H$ and $W$ are the height and width of each feature map. We use two representations for the textual input $T$ : (1) the bag-of-words representation denoted by $x _ { \mathrm { B o W } } ~ \in ~ \mathbb { R } ^ { V }$ and (2) a sentence representation $x _ { \mathrm { s e n t } } = f ( \breve { T } ; \theta _ { \mathrm { s e n t } } ) \in \mathbb { R } ^ { \breve { V } }$ , which is computed by passing the words in $T$ through a Gated Recurrent Unit (GRU) (Cho et al., 2014) network followed by a linear layer. Here, $\theta _ { \mathrm { s e n t } }$ denotes the parameters of the GRU network and the linear layer with ReLU activations. Next, the Dual-Attention unit $f _ { \mathrm { D A } }$ combines the image representation with the text representations to get the complete state representation $x _ { S }$ and answer prediction $x _ { \mathrm { A n s } }$ :
+
+$$
+x _ { \mathrm { S } } , x _ { \mathrm { A n s } } = f _ { \mathrm { D A } } ( x _ { I } , x _ { \mathrm { B o W } } , x _ { \mathrm { s e n t } } )
+$$
+
+Finally, $x _ { S }$ and $x _ { \mathrm { A n s } }$ , along with a time step embedding and a task indicator variable (for whether the task is SGN or EQA), are passed to the policy module to produce an action.
+
+# 4.1 DUAL-ATTENTION UNIT
+
+The Dual-Attention unit uses two types of attention mechanisms, Gated-Attention $f _ { \mathrm { G A } }$ and SpatialAttention $f _ { \mathrm { S A } }$ , to align representations in different modalities and tasks.
+
+Gated-Attention. The Gated-Attention unit (Figure 3) was proposed in (Chaplot et al., 2017) for multimodal fusion. Intuitively, a GA unit attends to the different channels in the image representation based on the text representation. For example, if the textual input is the instruction ‘Go to the red pillar’, then the GA unit can learn to attend to channels which detect red things and pillars. More specifically, the GA unit takes as input a 3-dimensional tensor image representation $y _ { I } \in \mathring { \mathbb { R } } ^ { d \times H \times W }$ and a text representation $\bar { y _ { T } } \in \mathbb { R } ^ { d }$ , and outputs a 3-dimensional tensor ${ \boldsymbol { z } } \in \mathbb { R } ^ { d \times H \times W }$ . Note that the dimension of $y _ { T }$ is equal to the number of feature maps and the size of the first dimension of $y _ { I }$ . In the Gated-Attention unit, each element of $y _ { T }$ is expanded to a $H \times W$ matrix, resulting in a 3-dimensional tensor $M _ { y _ { T } } \in \mathbb { R } ^ { d \times H \times W }$ , whose $( i , j , k ) ^ { t \bar { h } }$ element is given by $M _ { y _ { T } } [ i , j , k ] = \bar { y } _ { T } [ i ]$ . This matrix is multiplied element-wise with the image representation: $z = f _ { \mathrm { G A } } ( y _ { I } , y _ { T } ) = M _ { y _ { T } } \odot y _ { I }$ , where $\odot$ denotes the Hadamard product (Horn, 1990).
+
+![](images/888f192624493aa788242aabe8918602f25c59af6c7afb47da6321d3f27acf6d.jpg)  
+Figure 3: Gated-Attention unit $f _ { \mathrm { G A } }$
+
+Spatial-Attention. We propose a Spatial-Attention unit (Figure 4) which is analogous to the Gated-Attention unit except that it attends to different pixels in the image representation rather than the channels. For example, if the textual input is the question ‘Which object is blue in color?’, then we would like to spatially attend to the parts of the image which contain a blue object in order recognize the type of the blue object. The Spatial-Attention unit takes as input a 3-dimensional tensor image representation $y _ { I } \in \dot { \mathbb { R } ^ { d \times H \times W } }$ and a 2-dimensional spatial attention map $\mathit { y } _ { S } \in \mathbb { R } ^ { H \times W }$ , and outputs a tensor $\mathit { \check { z } } \in \mathbb { R } ^ { d \times H \times W }$ . Note that the height and width of the spatial attention map is equal to the height and width of the image representation. In the spatialattention unit, each element of the spatial attention map is expanded to a $d$ dimensional vector. This again results in a 3-dimensional tensor $M _ { y _ { S } } \in \mathbb { R } ^ { d \times \hat { H } \times W }$ , whose $( i , j , k ) ^ { t h }$ element is given by: $\bar { M } _ { y s } [ i , j , k ] = y _ { S } [ j , k ]$ . Just like in the Gated-Attention unit, this matrix is multiplied element-wise with the image representation: $z = f _ { \mathrm { S A } } ( y _ { I } , y _ { S } ) = M _ { y _ { S } } \odot y _ { I }$ . Similar spatial attention mechanisms have been used for Visual Question Answering (Fukui et al., 2016; Xu & Saenko, 2016; Hudson & Manning, 2018; Gupta et al., 2017b) and grounding audio in vision (Zhao et al., 2018).
+
+![](images/e7a785f4ad73bbe78d600384b1b5f88adcfc6098742f7d2bb686856c9e974c72.jpg)  
+Figure 4: Spatial-Attention unit $f _ { \mathrm { S A } }$
+
+Dual-Attention. We now describe the operations in the Dual-Attention unit shown in Figure 5, as well as motivate the intuitions behind each operation. Given $x _ { I }$ , $x _ { \mathrm { B o W } }$ , and $x _ { \mathrm { s e n t } }$ , the Dual-Attention unit first computes a Gated-Attention over $x _ { I }$ using $x _ { \mathrm { B o W } }$ :
+
+$$
+x _ { \mathrm { G A l } } = f _ { \mathrm { G A } } ( x _ { I } , x _ { \mathrm { B o W } } ) \in \mathbb { R } ^ { V \times H \times W } .
+$$
+
+Intuitively, this first Gated-Attention unit associates each word in the vocabulary with a feature map in the image representation. A particular feature map is activated if and only if the corresponding word occurs in the textual input. In other words, the feature maps in the convolutional output learns to detect different objects and attributes, and words in the textual input specify which objects and attributes are relevant to the current task. The Gated-Attention using BoW representation attends to feature maps detecting corresponding objects and attributes, and masks all other feature maps. We use bag-of-words representation for the first GA unit as it explicitly aligns the words in textual input irrespective of whether it is a question or an instruction. Note that bag-of-words representation has been used previously in models trained for learning to follow instructions (Hermann et al., 2017).
+
+![](images/a7e5f5b2f4bacd0b9ce717a508e7d79925d868fa21a8c187b4d6a12dd64fc350.jpg)  
+Figure 5: Architecture of the Dual-Attention unit with example intermediate representations and operations.
+
+Next, the output of the Gated-Attention unit $x _ { \mathrm { G A 1 } }$ is converted to a spatial attention map by summing over all channels followed by a softmax over $H \times W$ elements:
+
+$$
+x _ { \mathrm { s p a t } } = \sigma \left( \sum _ { i } ^ { V } { x _ { \mathrm { G A l } } [ i , : , : ] } \right) \in \mathbb { R } ^ { H \times W }
+$$
+
+where the softmax $\sigma ( z ) _ { j } = \exp ( z _ { j } ) / \sum _ { j } \exp ( z _ { j } )$ ensures that the attention map is normalized. Summation of $x _ { \mathrm { G A l } }$ along the depth dimension gives a spatial attention map which has high activations at spatial locations where relevant objects or attributes are detected. ReLU activations in the convolutional feature maps makes all elements positive, ensuring that the summation aggregates the activations of relevant feature maps.
+
+$x _ { \mathrm { s p a t } }$ and $x _ { I }$ are then passed through a Spatial-Attention unit:
+
+$$
+x _ { \mathrm { S A } } = f _ { \mathrm { S A } } ( x _ { I } , x _ { \mathrm { s p a t } } ) \in \mathbb { R } ^ { V \times H \times W }
+$$
+
+The Spatial-Attention unit outputs all attributes present at the locations where relevant objects and attributes are detected. This is especially helpful for question answering, where a single GatedAttention may not be sufficient. For example, if the textual input is ‘Which color is the pillar?’, then the model needs to attend not only to feature maps detecting pillars (done by the Gated-Attention), but also to other attributes at the spatial locations where pillars are seen in order to predict their color. Note that a single Gated-Attention is sufficient for instruction following, as shown in (Chaplot et al., 2017). For example, if the textual input is ‘Go to the green pillar’, the first Gated-Attention unit can learn to attend to feature maps detecting green objects and pillar, and learn a navigation policy based on the spatial locations of the feature map activations.
+
+$x _ { \mathrm { S A } }$ is then passed through another Gated-Attention unit with the sentence-level text representation:
+
+$$
+x _ { \mathrm { G A 2 } } = f _ { \mathrm { G A } } ( x _ { \mathrm { S A } } , x _ { \mathrm { s e n t } } ) \in \mathbb { R } ^ { V \times H \times W }
+$$
+
+This second Gated-Attention unit enables the model to attend to different types of attributes based on the question. For instance, if the question is asking about the color (‘Which color is the pillar?’), then the model needs to attend to the feature maps corresponding to colors; or if the question is asking about the object type (‘Which object is green in color?’), then the model needs to attend to the feature maps corresponding to object types. The sentence embedding $x _ { \mathrm { s e n t } }$ can learn to attend to multiple channels based on the textual input and mask the rest.
+
+Next, the output is transformed to answer prediction by again doing a summation and softmax but this time summing over the height and width instead of the channels:
+
+$$
+x _ { \mathrm { A n s } } = \sigma \left( \sum _ { j , k } ^ { H , W } x _ { \mathrm { G A 2 } } [ : , j , k ] \right) \in \mathbb { R } ^ { V }
+$$
+
+Summation of $x _ { \mathrm { G A } 2 }$ along each feature map aggregates the activations for relevant attributes spatially. Again, ReLU activations for sentence embedding ensure aggregation of activations for each attribute or word. The answer space is identical to the textual input space $\mathbb { R } ^ { V }$ .
+
+Finally, the Dual-Attention unit $f _ { \mathrm { D A } }$ outputs the answer prediction $x _ { \mathrm { A n s } }$ and the flattened spatial attention map $x _ { \mathrm { S } } = \mathrm { v e c } ( x _ { \mathrm { s p a t } } )$ , where $\mathrm { v e c } \bar { ( . ) }$ denotes the flattening operation.
+
+Policy Module. The policy module takes as input the state representation $x _ { S }$ from the DualAttention unit, a time step embedding $t$ , and a task indicator variable $I$ (for whether the task is SGN or EQA). The inputs are concatenated then passed through a linear layer, then a recurrent GRU layer, then linear layers to estimate the policy function $\pi ( a _ { t } \mid I _ { t } , T )$ and the value function $V ( I _ { t } , T )$ .
+
+All above operations are differentiable, making the entire architecture trainable end-to-end. Note that all attention mechanisms in the Dual-Attention unit only modulate the input image representation, i.e., mask or amplify specific feature maps or pixels. This ensures that there is an explicit alignment between the words in the textual input, the feature maps in the image representation, and the words in answer space. This forces the convolutional network to encode all the information required with respect to a certain word in the corresponding output channel. This explicit taskinvariant alignment between convolutional feature maps and words in the input and answer space facilitates grounding and allows for cross-task knowledge transfer. As shown in the results later, this also makes our model modular and allows easy addition of objects and attributes to a trained model.
+
+# 4.2 OPTIMIZATION
+
+The entire model is trained to predict both navigational actions and answers jointly. The policy is trained using Proximal Policy Optimization (PPO) (Schulman et al., 2017). For training the answer predictions, we use a supervised cross-entropy loss. Both types of losses have common parameters as the answer prediction is essentially an intermediate representation for the policy.
+
+Auxiliary Task. As mentioned earlier, the feature maps in the convolutional output are expected to detect different objects and attributes. Consequently, we add a spatial auxiliary task to detect the object or attribute in the convolutional output channels corresponding to the word in the bag-of-words representation. A prior work (Gupta et al., 2017b) also explored the use of attribute and object recognition as an auxiliary task for Visual Question Answering. Rather than doing fine-grained object detection, we keep the size of the auxiliary predictions the same as the convolutional output to avoid increase in number of parameters, and maintain the explicit alignment on the convolutional feature maps with the words. Consequently, auxiliary labels are $( V \times H \times W )$ -dimensional tensors, where each of the $V$ channels correspond to a word in the vocabulary, and each element in a channel is 1 if the corresponding object or attribute is present in the current frame spatially. Figure 6 shows examples of auxiliary task labels for the channel corresponding to the word ‘red’. The auxiliary tasks are also trained with cross-entropy loss.
+
+![](images/fa7a1639c57b9e7bccb73053f54f5d1fe41e28c1028ec51acbe83fd8097150c0.jpg)  
+Figure 6: Example auxiliary task labels for the red channel.
+
+# 5 EXPERIMENTS & RESULTS
+
+Jointly learning semantic goal navigation and embodied question answering essentially involves a fusion of verbal and visual modalities. While prior methods are designed for a single task, we adapt several baselines for our environment and tasks by using their multimodal fusion techniques. We use two naive baselines, Image only and Text only; two baselines based on prior semantic goal navigation models, Concat (used by Hermann et al. (2017); Misra et al. (2017)) and Gated-Attention (GA) (Chaplot et al., 2017); and two baselines based on Question Answering models, FiLM (Perez et al., 2017) and PACMAN (Das et al., 2017). For fair comparison, we replace the proposed DualAttention unit with multimodal fusion techniques in the baselines and keep everything else identical to the proposed model. We provide more implementation details of all baselines in the Appendix.
+
+# 5.1 RESULTS
+
+We train all models for 10 million frames in the Easy setting and 50 million frames in the Hard setting. We use a $+ 1$ reward for reaching the correct object in SGN episodes and predicting the correct answer in EQA episodes. We use a small negative reward of -0.001 per time step to encourage shorter paths to target and answering questions as soon as possible. We also use distance-based reward shaping for SGN episodes, where the agent receives a small reward proportional to decrease in distance to the target. In the next subsection we evaluate the performance of the proposed model without the reward shaping. SGN episodes end when the agent reaches any object, and EQA episodes when the agent predicts any answer. All episodes have a maximum length of 210 time steps. We train all models with and without the auxiliary tasks using identical reward functions.
+
+![](images/0f763d40f3cf3cc304935d3ef380ea01fe08bd89fadf0f7ce22ecb962077a7f5.jpg)  
+Figure 7: Training accuracy of all models trained with auxiliary tasks for Easy (left) and Hard (right).
+
+Table 1: Accuracy of all models on SGN & EQA test sets for both Easy & Hard difficulties.   
+
+<table><tr><td></td><td colspan="4">Easy</td><td colspan="4">Hard</td></tr><tr><td></td><td colspan="2">No Aux</td><td colspan="2">Aux</td><td colspan="2">No Aux</td><td colspan="2">Aux</td></tr><tr><td>Model</td><td>SGN</td><td>EQA</td><td>SGN</td><td>EQA</td><td>SGN</td><td>EQA</td><td>SGN</td><td>EQA</td></tr><tr><td>Text only</td><td>0.2</td><td>0.33</td><td>0.2</td><td>0.33</td><td>0.2</td><td>0.33</td><td>0.2</td><td>0.33</td></tr><tr><td>Image only</td><td>0.20</td><td>0.09</td><td>0.21</td><td>0.08</td><td>0.16</td><td>0.08</td><td>0.15</td><td>0.08</td></tr><tr><td>Concat</td><td>0.33</td><td>0.21</td><td>0.31</td><td>0.19</td><td>0.2</td><td>0.26</td><td>0.39</td><td>0.22</td></tr><tr><td>GA</td><td>0.27</td><td>0.18</td><td>0.35</td><td>0.24</td><td>0.18</td><td>0.11</td><td>0.22</td><td>0.24</td></tr><tr><td>FiLM</td><td>0.24</td><td>0.11</td><td>0.34</td><td>0.12</td><td>0.12</td><td>0.03</td><td>0.25</td><td>0.15</td></tr><tr><td>PACMAN</td><td>0.26</td><td>0.12</td><td>0.33</td><td>0.10</td><td>0.29</td><td>0.33</td><td>0.11</td><td>0.27</td></tr><tr><td>Dual-Attention</td><td>0.86</td><td>0.53</td><td>0.96</td><td>0.58</td><td>0.86</td><td>0.38</td><td>0.82</td><td>0.59</td></tr></table>
+
+All models are trained jointly for both the tasks and tested on each task separately. In Figure 7, we show the training performance curves for all models trained with Auxiliary tasks in both Easy and Hard settings. In Table 1, we report the test performance of all models on both SGN and EQA for both Easy and Hard settings. During training, the Dual-Attention model learns faster as compared to the baselines in the Easy setting while achieving higher final performance in the Hard setting (see Figure 7). More interestingly, as shown in Table 1, the Dual-Attention model achieves considerably higher accuracy on the test set for SGN and EQA in both the difficulty settings when trained with or without auxiliary tasks. These results confirm the hypothesis that prior models, which are designed for a single task, lack the ability align the words in both the tasks and transfer knowledge across tasks. Lower accuracy on EQA for most models (see Table 1) indicates that EQA is more challenging than SGN as it involves alignment between not only input textual and visual representations but also with the answer space. As expected, using spatial auxiliary tasks lead to better performance for all models Visualization of the attention maps and intermediate representations in the model indicate that the textual and visual representations are aligned as expected (see Appendix for visualizations)1.
+
+# 5.2 ABLATION TESTS
+
+We perform a series of ablation tests in order to analyze the contribution of each component in the Dual-Attention unit: without Spatial-Attention (w/o SA), without the first Gated-Attention with $x _ { B o W }$ (w/o GA1), and without the second Gated-Attention with $x _ { \mathrm { s e n t } }$ (w/o GA2). We also try removing the task indicator variable (w/o Indicator Variable), removing reward shaping (w/o Reward Shaping), and training the proposed model on a single task, SGN or EQA (DA Single-Task).
+
+Figure 8 shows the training performance curves for the Dual-Attention model along with all ablation models in the Easy Setting. In Table 2, we report the test set performance of all ablation models. The results indicate that SA and GA1 contribute the most to the performance of the Dual-Attention model. GA2 is critical for performance on EQA but not SGN (see Table 2). This is expected as GA2 is designed to attend to different objects and attributes based on the question and is used mainly for answer prediction. It is not critical for SGN as the spatial attention map consists of locations of relevant objects, which is sufficient for navigating to the correct object. Reward shaping and indicator variable help with learning speed (see Figure 8), but have little effect on the final performance (see Table 2). Dual-Attention models trained only on single tasks work well on SGN especially with auxiliary tasks. This is because the auxiliary task for single task models includes object detection labels corresponding to the words in the test set. This highlights a key advantage of the proposed model. Due to its modular and interpretable design, the model can used for transferring the policy to new objects and attributes without fine-tuning as discussed in the following subsection.
+
+![](images/69a4073a5b891f27a0c6d0e7e4b8f3eb9a94e900eda6ec575b749ee8e403a1d8.jpg)  
+Figure 8: Training accuracy of proposed Dual-Attention model with all ablation models trained without (left) and with (right) auxiliary tasks for the Easy environment.
+
+Table 2: Accuracy of all the ablation models trained with and without Auxiliary tasks on SGN and EQA test sets for the Doom Easy environment.   
+
+<table><tr><td>Model</td><td>No Aux SGN EQA</td><td>Aux SGN</td></tr><tr><td>w/o SA</td><td></td><td>EQA</td></tr><tr><td>w/o GA1</td><td>0.20 0.16 0.25</td><td>0.20 0.15 0.16 0.38</td></tr><tr><td>w/o GA2</td><td>0.14 0.80 0.33</td><td>0.97 0.15</td></tr><tr><td>w/o Task Indicator</td><td>0.79 0.47</td><td>0.96 0.56</td></tr><tr><td>w/o Reward Shaping</td><td>0.82 0.49</td><td>0.93 0.51</td></tr><tr><td>DA Single-Task</td><td>0.63 0.31</td><td>0.91 0.34</td></tr><tr><td></td><td></td><td></td></tr><tr><td>DA Multi-Task</td><td>0.86 0.53</td><td>0.96 0.58</td></tr></table>
+
+Table 3: The performance of a trained policy appended with object detectors on instructions containing unseen words (‘red’ and ‘pillar’).   
+
+<table><tr><td>Instruction</td><td>Easy</td><td>Hard</td></tr><tr><td>Go to the pillar</td><td>1.00</td><td>0.71</td></tr><tr><td>Go to the red object</td><td>0.99</td><td>0.89</td></tr><tr><td>Go to the tall/short pillar</td><td>0.99</td><td>0.68</td></tr><tr><td>Go to the &lt;known_color&gt;pillar.</td><td>1.00</td><td>0.79</td></tr><tr><td>Go to the red &lt;known_object&gt;</td><td>1.00</td><td>0.93</td></tr><tr><td>Go to the largest/smallest red object</td><td>0.95</td><td>0.69</td></tr><tr><td>Go to the tall/short red pillar</td><td>0.99</td><td>0.88</td></tr><tr><td>Go to the red pillar</td><td>0.99</td><td>0.82</td></tr></table>
+
+# 5.3 EXTENSION: TRANSFER TO NEW WORDS
+
+Consider a scenario of SGN where the agent is trained to follow instructions of certain objects and attributes. Suppose that the user wants the agent to follow instructions about a new object such as ‘pillar’ or a new attribute such the color ‘red’ which are never seen in any training instruction. Prior SGN models are shown to perform well to unseen combination of object-attribute pairs (Chaplot et al., 2017), but they do not generalize well to instructions containing a new word. The model retrained only on new instructions will lead to catastrophic forgetting of previous instructions.
+
+In contrast, our model can be used for transfer to new words by training an object detector for each new word and appending it to the image representation $x _ { I }$ . In order to test this, we train a single-task SGN model using the proposed architecture on the training set for instructions. We use auxiliary tasks but only for words in the vocabulary of the instructions training set. After training the policy, we would like the agent to follow instructions containing test words ‘red’ and ‘pillar’, which the agent has never seen or received any supervision about how this attribute or object looks visually. For transferring the policy, we assume access to two object detectors which would give object detections for ‘red’ and ‘pillar’ separately. We resize the object detections to the size of a feature map in the image representation $( H \times W )$ and append them as channels to the image representation. We also append the words ‘red’ and ‘pillar’ to the bag-of-words representations in the same order such that they are aligned with the appended feature maps. We randomly initialize the embeddings of the new words for computing the sentence embedding. The results in Table 3 show that this policy generalizes well to different types of instructions with unseen words. This suggests that a trained policy can be scaled to more objects provided the complexity of navigation remains consistent.
+
+# 6 CONCLUSION
+
+We proposed a Dual-Attention model for visually-grounded multitask learning which uses Gatedand Spatial-Attention to disentangle attributes in feature representations and align them with the answer space. We show that the proposed model is able to transfer the knowledge of words across tasks and outperforms the baselines on both Semantic Goal Navigation and Embodied Question Answering by a considerable margin. We showed that disentangled and interpretable representations make our model modular and allows for easy addition of new objects or attributes to a trained model. In future, the model can potentially be extended to transferring knowledge across different domains by using modular interpretable representations of objects which are domain-invariant.
+
+# REFERENCES
+
+Devendra Singh Chaplot, Kanthashree Mysore Sathyendra, Rama Kumar Pasumarthi, Dheeraj Rajagopal, and Ruslan Salakhutdinov. Gated-attention architectures for task-oriented language grounding. arXiv preprint arXiv:1706.07230, 2017.
+
+Kyunghyun Cho, Bart Van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties ¨ of neural machine translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014.
+
+Abhishek Das, Samyak Datta, Georgia Gkioxari, Stefan Lee, Devi Parikh, and Dhruv Batra. Embodied question answering. arXiv preprint arXiv:1711.11543, 2017.
+
+Alexey Dosovitskiy and Vladlen Koltun. Learning to act by predicting the future. In ICLR, 2017.
+
+Akira Fukui, Dong Huk Park, Daylen Yang, Anna Rohrbach, Trevor Darrell, and Marcus Rohrbach. Multimodal compact bilinear pooling for visual question answering and visual grounding. arXiv preprint arXiv:1606.01847, 2016.
+
+Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 315–323, 2011.
+
+Daniel Gordon, Aniruddha Kembhavi, Mohammad Rastegari, Joseph Redmon, Dieter Fox, and Ali Farhadi. Iqa: Visual question answering in interactive environments. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4089–4098, 2018.
+
+Saurabh Gupta, James Davidson, Sergey Levine, Rahul Sukthankar, and Jitendra Malik. Cognitive mapping and planning for visual navigation. arXiv preprint arXiv:1702.03920, 3, 2017a.
+
+Tanmay Gupta, Kevin J Shih, Saurabh Singh, Derek Hoiem, Kevin J Shih, Arun Mallya, Wei Di, Vignesh Jagadeesh, Robinson Piramuthu, K Shih, et al. Aligned image-word representations improve inductive transfer across vision-language tasks. In ICCV, pp. 4223–4232, 2017b.
+
+Karl Moritz Hermann, Felix Hill, Simon Green, Fumin Wang, Ryan Faulkner, Hubert Soyer, David Szepesvari, Wojtek Czarnecki, Max Jaderberg, Denis Teplyashin, et al. Grounded language learning in a simulated 3d world. arXiv preprint arXiv:1706.06551, 2017.
+
+Roger A Horn. The hadamard product. In Proc. Symp. Appl. Math, volume 40, pp. 87–169, 1990.
+
+Drew A Hudson and Christopher D Manning. Compositional attention networks for machine reasoning. arXiv preprint arXiv:1803.03067, 2018.
+
+Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016.
+
+Michał Kempka, Marek Wydmuch, Grzegorz Runc, Jakub Toczek, and Wojciech Jaskowski. Viz- ´ doom: A doom-based ai research platform for visual reinforcement learning. arXiv preprint arXiv:1605.02097, 2016.
+
+Guillaume Lample and Devendra Singh Chaplot. Playing FPS games with deep reinforcement learning. In Thirty-First AAAI Conference on Artificial Intelligence, 2017.
+
+Yann LeCun, Yoshua Bengio, et al. Convolutional networks for images, speech, and time series. The handbook of brain theory and neural networks, 3361(10):1995, 1995.
+
+Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andrew J Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, et al. Learning to navigate in complex environments. arXiv preprint arXiv:1611.03673, 2016.
+
+Dipendra K Misra, John Langford, and Yoav Artzi. Mapping instructions and visual observations to actions with reinforcement learning. arXiv preprint arXiv:1704.08795, 2017.
+
+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, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In ICML, 2016.
+
+Junhyuk Oh, Satinder Singh, Honglak Lee, and Pushmeet Kohli. Zero-shot task generalization with multi-task deep reinforcement learning. arXiv preprint arXiv:1706.05064, 2017.
+
+Ethan Perez, Florian Strub, Harm De Vries, Vincent Dumoulin, and Aaron Courville. Film: Visual reasoning with a general conditioning layer. arXiv preprint arXiv:1709.07871, 2017.
+
+Manolis Savva, Angel X. Chang, Alexey Dosovitskiy, Thomas Funkhouser, and Vladlen Koltun. MINOS: Multimodal indoor simulator for navigation in complex environments. arXiv:1712.03931, 2017.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
+
+Yi Wu, Yuxin Wu, Georgia Gkioxari, and Yuandong Tian. Building generalizable agents with a realistic and rich 3d environment. arXiv preprint arXiv:1801.02209, 2018.
+
+Huijuan Xu and Kate Saenko. Ask, attend and answer: Exploring question-guided spatial attention for visual question answering. In European Conference on Computer Vision, pp. 451–466. Springer, 2016.
+
+Haonan Yu, Xiaochen Lian, Haichao Zhang, and Wei Xu. Guided feature transformation (gft): A neural language grounding module for embodied agents. arXiv preprint arXiv:1805.08329, 2018a.
+
+Haonan Yu, Haichao Zhang, and Wei Xu. Interactive grounded language acquisition and generalization in a 2d world. arXiv preprint arXiv:1802.01433, 2018b.
+
+Hang Zhao, Chuang Gan, Andrew Rouditchenko, Carl Vondrick, Josh McDermott, and Antonio Torralba. The sound of pixels. arXiv preprint arXiv:1804.03160, 2018.
+
+Yuke Zhu, Roozbeh Mottaghi, Eric Kolve, Joseph J Lim, Abhinav Gupta, Li Fei-Fei, and Ali Farhadi. Target-driven visual navigation in indoor scenes using deep reinforcement learning. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pp. 3357–3364. IEEE, 2017.
+
+# A VISUALIZATIONS
+
+![](images/eb82cf3d410040af24e674376db93bf154e95616c9f3df8c13dcc8542653e7ae.jpg)  
+Figure 9: Visualizations of convolutional output channels. We visualize the convolutional channels corresponding to 7 words (one in each row) for the same frame (shown in the rightmost column). The first column shows the auxiliary task labels for reference. The second column and third column show the output of the corresponding channel for the proposed Dual-Attention model trained without and with auxiliary tasks, respectively. As expected, the Aux model outputs are very close to the auxiliary task labels. The convolutional outputs of the No Aux model show that words and objects/properties in the images have been properly aligned even when the model is not trained with any auxiliary task labels. We do not provide any auxiliary label for words ‘smallest’ and ‘largest’ as they are not properties of an object and require relative comparison of objects. The visualizations in row 5 (corresponding to ‘smallest’) indicate that both models are able to compare the sizes of objects and detect the smallest object in the corresponding output channel even without any aux labels for the smallest object.
+
+![](images/c09df43f375517b1e7308882219ccaabee4d2f03fc7563c5a1c2705c93dc07be.jpg)  
+Figure 10: Spatial Attention and Answer Prediction Visualizations. An example EQA episode with the question “Which is the smallest blue object?”. The sentence embedding of the question is shown on the top $( x _ { s e n t } )$ . As expected, the embedding attends to object type words (’torch’, ’pillar’, ’skullkey’, etc.) as the question is asking about an object type (’Which object’). The rows show increasing time steps and columns show the input frame, the input frame overlaid with the spatial attention map, the predicted answer distribution, and the action at each time step. As the agent is turning, the spatial attention attends to small and blue objects. Time steps 1, 2: The model is attending to the yellow skullkey but the probability of the answer is not sufficiently high, likely because the skullkey is not blue. Time step 3: The model cannot see the skullkey anymore so it attends to the armor which is next smallest object. Consequently, the answer prediction also predicts armor, but the policy decides not to answer due to low probability. Time step 4: As the agent turns more, it observes and attends to the blue skullkey. The answer prediction has high probability for skullkey as it’s small and blue and the policy decides to answer the question.
+
+![](images/6acfbbc3bc1a92d1814e01f282a9c869e31804d2fe115c6a5a2a0783ad26bf0f.jpg)  
+Figure 11: Architecture of the policy module.
+
+# B ADDITIONAL EXPERIMENTAL DETAILS
+
+# B.1 HYPERPARAMETERS AND NETWORK DETAILS
+
+The input image is rescaled to size $3 \times 1 6 8 \times 3 0 0$ . The convolutional network for processing the image consisted of 3 convolutional layers: conv1 containing $3 2 ~ 8 \mathrm { x } 8$ filters with stride 4, conv2 containing $6 4 ~ 4 \mathrm { x } 4$ filters with stride 2, and conv3 containing $V$ 3x3 filters with stride 2. We use ReLU activations for conv1 and conv2 and sigmoid for conv3, as its output is used as auxiliary task predictions directly. We use word embeddings and GRU of size 32 followed by linear layer of size $V$ to get the sentence-level representation. The policy module uses hidden dimension 128 for the linear and GRU layers (see Figure 11).
+
+For reinforcement learning, we use Proximal Policy Optimization (PPO) with 8 actors and a time horizon of 128 steps. We use a single batch with 4 PPO epochs. The clipping parameter for PPO is set to 0.2. The discount factor $( \gamma )$ is 0.99. We used Adam optimizer with learning rate $2 . 5 \mathrm { e } { \cdot } 4$ for all experiments.
+
+# B.2 BASELINE DETAILS
+
+Image only: Naive baseline of just using the image representation: $x _ { \mathrm { S } } = \sec ( x _ { I } )$ where vec(.) denotes the flattening operation.
+
+Text only: Naive baseline of just using the textual representations: $x _ { \mathrm { S } } = [ x _ { \mathrm { B o W } } , x _ { \mathrm { s e n t } } ]$
+
+Concat: The image and textual representations are concatenated: $x _ { \mathrm { S } } = [ \mathrm { v e c } ( x _ { I } ) , x _ { \mathrm { B o W } } , x _ { \mathrm { s e n t } } ]$ . Note that concatenation is the most common method of combining representations. Hermann et al. (2017) concatenate convolutional image and bag-of-words textual representations for SGN, whereas Misra et al. (2017) use concatenation with sentence-level textual representations.
+
+Gated-Attention: Adapted from Chaplot et al. (2017), who used Gated-Attention with sentencelevel textual representations for SGN: $x _ { \mathrm { S } } = f _ { \mathrm { G A } } ( x _ { I } , x _ { \mathrm { s e n t } } )$ .
+
+FiLM: Perez et al. (2017) introduced a general-purpose conditioning method called Feature-wise Linear Modulation (FiLM) for Visual Question Answering. Using FiLM, $x _ { \mathrm { S } } = \gamma ( x _ { \mathrm { s e n t } } ) \odot x _ { I } +$ $\beta ( x _ { \mathrm { s e n t } } )$ where $\gamma ( x _ { \mathrm { s e n t } } )$ and $\beta ( x _ { \mathrm { s e n t } } )$ are learnable projections of the sentence representation.
+
+PACMAN: Das et al. (2017) presented a hierarchical RL model for EQA. We adapt their method by using the attention mechanism in their QA module, which takes the last 5 frames and the text as input, and computes the similarity of the text with each frame using dot products between image and sentence-level text representations. These similarities are converted into attention weights using softmax, and the attention-weighted image features are concatenated with question embedding and passed through a softmax classifier to predict the answer distribution. For this particular baseline, we use the last 5 frames as input at each time step, unlike the proposed model and all other baselines which use a single frame as input. The attention-weighted image features are used as the state representation. The PACMAN model used a pretrained QA module, but we train this module jointly with the Navigation model for fair comparison with the proposed model.
+
+For each of the above method except PACMAN, we use a linear layer $f$ with ReLU activations followed by softmax $\sigma$ to get a $V$ -dimensional answer prediction from the state representations: $x _ { \mathrm { A n s } } = \sigma ( \bar { f } ( x _ { \mathrm { S } } ; \theta _ { L i n } ) )$ . $x _ { \mathrm { { S } } }$ and $x _ { A n s }$ are concatenated and passed to the policy module along with the time step and task indicator variable just as in the proposed model.
+
+![](images/a6315480bb9a073f24a9632c6856b7874a62864e259308fb0863e2161017b386.jpg)  
+Figure 12: Plot showing the training accuracy of all the models without auxiliary tasks for Doom Easy and Hard environments.
+
+![](images/634ffdf84813ca11c0e122e1a00e556fb733df50e54d4f6c9664f00480c451dd.jpg)  
+Figure 13: Plot showing the training accuracy of 3 models across 3 training runs with different seeds with and without auxiliary tasks for Doom Easy environment without any smoothing.
+
+# C DOOM EXPERIMENT DETAILS
+
+Additional Results. We show the training accuracy of all models without auxiliary tasks for Doom Easy and Hard in Figure 12. We also show the training accuracy of 3 models across 3 training runs with different seeds with and without auxiliary tasks for Doom Easy environment in Figure 13.
+
+Dataset. The Doom objects used in our experiments are illustrated in Figure 14. Instructions and questions used for training and evaluation are listed in Tables 4.
+
+![](images/69d7bb5a3ad8695b8a37ae82bea6b9ec1dbc83f181543eb44b38a763cd846842.jpg)  
+Figure 14: Objects of various colors and sizes used in the ViZDoom environment.
+
+Table 4: Instructions and questions for ViZDoom experiments. We used 5 object classes (torch, pillar, keycard, skullkey, armor), 4 colors (red, green, blue, yellow), 2 sizes (tall, short), and 2 superlative sizes (smallest, largest).   
+
+<table><tr><td>SGN Instruction Type</td><td></td><td>42 Train Instructions: Not containing‘red&#x27;&amp;‘pillar&#x27;</td><td>28 Test Instructions: Containing‘red&#x27;or‘pillar&#x27;</td></tr><tr><td>Go to the (object).</td><td>Go to the color&gt;object.</td><td>torch,keycard,skullkey,armor yellow, green, blue</td><td>pillar red</td></tr><tr><td></td><td>Go to the size)object. Go to the {color) {object).</td><td>tall, short blue torch, green torch, green armor,</td><td>red torch,red skullkey,red pillar,</td></tr><tr><td></td><td></td><td>blue skullkey,blue keycard, yellow keycard, yellow skullkey</td><td>green pillar,red keycard,red armor</td></tr><tr><td></td><td>Go to the {size) (object). Go to the color) (size)object.</td><td>short torch,tall torch green tall, blue tall, blue short,</td><td>tall pillar, short pillar red short, red tall</td></tr><tr><td></td><td>Go to the size){color)object.</td><td>green short tall green, tall blue, short blue,</td><td>short red, tall red</td></tr><tr><td></td><td>Go to the {color)(size)(object).</td><td>short green green tall torch, green short torch,</td><td>red short pillar,red short torch,</td></tr><tr><td></td><td></td><td>blue short torch,blue tall torch</td><td>red tall pillar, green tall pillar, red tall torch, green short pillar</td></tr><tr><td></td><td>Go to the size) {color&gt; {object).</td><td>tall green torch,short green torch, short blue torch,tall blue torch</td><td>short red pillar, short red torch, tall red pillar, tall green pillar, tall red torch,short green pillar</td></tr><tr><td></td><td>Go to the superlative)object. Go to the {superlative&gt; (color) object.</td><td>largest, smallest smallest yellow, smallest blue, smallest green,largest blue,</td><td>largest red,smallest red</td></tr><tr><td>EQA</td><td>Question Type</td><td>largest green,largest yellow 21 Train Questions: Not containing‘blue&#x27;&amp;‘torch&#x27;</td><td>8 Test Questions: Containing‘blue&#x27;or‘torch&#x27;</td></tr><tr><td>Which {size)object is {color)in color?</td><td>What color is the {object)? What color is the {size){object&gt;? Which object is {color) in color?</td><td>pillar, keycard, skullkey,armor short pillar, tall pillar red,yellow, green</td><td>torch short torch, tall torch blue</td></tr></table>
+
+# D HOUSE3D EXPERIMENTS
+
+In the House3D domain, we train on one house environment and randomize the colors of each object at the start of each episode. The agent’s spawn location is fixed. We create instructions and questions dataset for this house similar to the Doom domain. The House3D objects used in our experiments are illustrated in Figure 15. Instructions and questions used for training and evaluation are listed in Table 6.
+
+Each model is trained for 50 million frames jointly on both SGN and EQA, without the auxiliary tasks and using identical reward functions. Similar to Doom, we use a $+ 1$ reward for reaching the correct object in SGN episodes and predicting the correct answer in the EQA episodes. We use a small negative reward of - 0.001 per time step to encourage shorter paths to target and answering the questions as soon as possible. We also use distance based reward shaping for both SGN and EQA episodes, where the agent receives a small reward proportional to decrease in distance to the target. SGN episodes end when the agent reaches any object and EQA episodes when agent predicts any answer. All episodes have a maximum length of 420 time steps.
+
+Table 5: Accuracy of all the models on the SGN and EQA train and test sets for the House3D Domain.   
+
+<table><tr><td></td><td colspan="2">SGN</td><td colspan="2">EQA</td></tr><tr><td>Model</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td></tr><tr><td>Text only</td><td>0.63</td><td>0.33</td><td>0.22</td><td>0.23</td></tr><tr><td>Image only</td><td>0.28</td><td>0.01</td><td>0.12</td><td>0.22</td></tr><tr><td>Concat</td><td>0.65</td><td>0.13</td><td>0.31</td><td>0.13</td></tr><tr><td>GA</td><td>0.98</td><td>0.20</td><td>0.92</td><td>0.03</td></tr><tr><td>FiLM</td><td>0.99</td><td>0.37</td><td>0.92</td><td>0.24</td></tr><tr><td>PACMAN</td><td>0.73</td><td>0.20</td><td>0.40</td><td>0.21</td></tr><tr><td>Dual-Attention</td><td>0.99</td><td>0.47</td><td>0.89</td><td>0.29</td></tr></table>
+
+In Table 5, we report the train and test performance of all the models on both SGN and EQA. The results are similar as in Doom: the Dual-Attention model outperforms the baselines by a considerable margin.
+
+![](images/af178f0259047b6ec08600ddcade5e3f117345df9c3c00343e94708605dc643a.jpg)  
+Figure 15: Example first-person views of the House3D environment with sample objects of various colors.
+
+Table 6: Instructions and questions for House3D experiments. We used 6 object classes (refrigerator, office chair, fish tank, fireplace, bed, sofa) and 4 colors (red, green, blue, yellow).   
+
+<table><tr><td>SGN</td><td>Instruction Type</td><td>22 Train Instructions: Not containing‘red&#x27;&amp;‘bed&#x27;</td><td>11 Test Instructions: Containing‘red&#x27;or‘bed&#x27;</td></tr><tr><td></td><td>Go to the (object). Go to the {color)(object).</td><td>refrigerator,office_chair,fish_tank,fireplace green refrigerator, green office_chair, green fish_tank,green fireplace, green sofa, blue refrigerator, blue office_chair, blue fish_tank,blue fireplace,blue sofa, yellow refrigerator,yellow office_chair, yellow fish_tank,yellow fireplace,yellow sofa</td><td>bed red bed, green bed,blue bed, yellow bed,red refrigerator, red office_chair,red fish_tank, red fireplace,red sofa</td></tr><tr><td>EQA</td><td>Go to the {color) object. Question Type</td><td>green,blue,yellow 7 Train Questions:</td><td>red 2 Test Questions:</td></tr><tr><td></td><td></td><td>Not containing‘blue&#x27;&amp;‘sofa&#x27;</td><td>Containing‘blue&#x27;or‘sofa&#x27;</td></tr><tr><td></td><td>What color is the {object)? What object is color&gt; in color?</td><td>refrigerator,office_chair,fish_tank,fireplace,bed red, green,yellow</td><td>sofa blue</td></tr></table>

parse/train/ByGq7hRqKX/ByGq7hRqKX_content_list.json

@@ -0,0 +1,1719 @@
+[
+    {
+        "type": "text",
+        "text": "CROSS-TASK KNOWLEDGE TRANSFER FOR VISUALLY-GROUNDED NAVIGATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            692,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            215,
+            544,
+            232
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent efforts on training visual navigation agents conditioned on language using deep reinforcement learning have been successful in learning policies for two different tasks: learning to follow navigational instructions and embodied question answering. In this paper, we aim to learn a multitask model capable of jointly learning both tasks, and transferring knowledge of words and their grounding in visual objects across tasks. The proposed model uses a novel Dual-Attention unit to disentangle the knowledge of words in the textual representations and visual objects in the visual representations, and align them with each other. This disentangled task-invariant alignment of representations facilitates grounding and knowledge transfer across both tasks. We show that the proposed model outperforms a range of baselines on both tasks in simulated 3D environments. We also show that this disentanglement of representations makes our model modular, interpretable, and allows for transfer to instructions containing new words by leveraging object detectors. ",
+        "bbox": [
+            233,
+            244,
+            764,
+            438
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            460,
+            336,
+            477
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep reinforcement learning has been shown to be capable of achieving super-human performance in playing games such as Atari 2600 (Mnih et al., 2013) and Go (Silver et al., 2016). Following the success of deep reinforcement learning in 3D Games such as Doom (Lample & Chaplot, 2017; Dosovitskiy & Koltun, 2017) and DeepmindLab (Mnih et al., 2016), there has been increased interest in using deep reinforcement learning for training embodied agents, which interact with a 3D environment by receiving first-person views of the environment and taking navigational actions. The simplest navigational agents learn a particular behaviour such as collecting or avoiding particular objects (Kempka et al., 2016; Jaderberg et al., 2016; Mirowski et al., 2016) or playing deathmatches (Lample & Chaplot, 2017; Dosovitskiy & Koltun, 2017). Subsequently, there have been efforts on training navigational agents whose behaviour is conditioned on a target specified using images (Zhu et al., 2017) or coordinates (Gupta et al., 2017a; Savva et al., 2017). More recently, there has been much interest in training agents conditioned on language as it offers several advantages over using images or coordinates. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            665
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Firstly, the compositionality of language allows generalization to new tasks without additional learning. Prior work (Oh et al., 2017; Hermann et al., 2017; Chaplot et al., 2017) has trained navigational agents to follow instructions and shown zero-shot generalization to new instructions which contain unseen composition of words seen in the training instructions. Secondly, language is also a convenient means for humans to communicate with autonomous agents. Language not only allows instruction but also interaction. Gordon et al. (2018) and Das et al. (2017) train agents to answer questions by navigating in the environment to gather the required information. ",
+        "bbox": [
+            174,
+            672,
+            823,
+            770
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "These multimodal tasks involve several challenges, such as perception from raw pixels, grounding of words in the instruction or question to visual objects and attributes, reasoning to perform relational tasks, fine-grained navigation in 3D environments with continuous state space, and learning to answer questions. Training a multi-task model can also facilitate knowledge transfer between the tasks and allow the model to generalize to scenarios which were not possible with single tasks. For example, if an agent learns to follow the instruction ‘Go to the red pillar’ and answer the question ‘What color is the torch?’, then it should also be able to follow the instruction ‘Go to the red torch’ and answer the question ‘What color is the pillar?’ without any additional training. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we aim to train a multi-task navigation model to follow instructions and answer questions. To test the generalization of multi-task models, we define cross-task knowledge transfer as an evaluation criteria, evaluating zero-shot learning on instructions and questions consisting of unseen composition of words in both tasks. In order to achieve cross-task knowledge transfer, words in the input space of both tasks need to be aligned with each other and with the answer space while they are being grounded to visual objects and attributes. Prior models fail to achieve this as they are designed for a single task. We propose a novel dual-attention model involving sequential Gated- and Spatial-Attention operations to perform explicit task-invariant alignment between the image representation channels and the words in the input and answer space. We create datasets and simulation scenarios for testing cross-task knowledge transfer in the Doom environment (Kempka et al., 2016) and show that the proposed model outperforms a range of baselines on both tasks. Additionally, we demonstrate that the modularity of our model allows easy addition of new objects and attributes to a trained model. We plan to open-source the implementation of our proposed model as well as the datasets and simulation environments. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c73220668e2566d5356bf6cee3722954a8f4847bd33438358c45fbb39f48d227.jpg",
+        "image_caption": [
+            "Figure 1: An example of first-person view in the 3D Doom environment with sample instructions and questions. The test set consists of unseen instructions and questions. The dataset evaluates a model for cross-task knowledge transfer between Semantic Goal Navigation (SGN) and Embodied Question Answering (EQA). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            797,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            265,
+            825,
+            433
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            455,
+            344,
+            472
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper is motivated by a series of works on learning to follow navigation instructions (Oh et al., 2017; Hermann et al., 2017; Chaplot et al., 2017; Wu et al., 2018; Yu et al., 2018a) and learning to answer questions by navigating around the environment (Das et al., 2017; Gordon et al., 2018). Among methods learning from instructions in 3D environments, Oh et al. (2017) introduced a hierarchical RL model for learning sequences of instructions by learning skills to solve subtasks. Chaplot et al. (2017) introduced a gated-attention model for multimodal fusion of textual and visual representations using multiplicative interactions, whereas Hermann et al. (2017) introduced auxiliary tasks such as temporal autoencoding and language prediction to improve sample efficiency for this task. Yu et al. (2018a) proposed guided feature transformation which involves transformation of visual representations using latent sentence embeddings computed from the language input. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            628
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Among models for embodied question answering, Das et al. (2017) introduced a hierarchical model consisting of 4 modules, each for processing images, encoding questions, navigation, and questionanswering, each of which is pretrained with supervised or imitation learning, followed by fine-tuning of the navigation model using reinforcement learning. Gordon et al. (2018) introduced the task of Interactive Question Answering which involves interacting with objects in the environment with non-navigational actions for answering questions. They proposed Hierarchical Interactive Memory Network (HIMN), which allows temporal abstraction using a factorized set of controllers. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            732
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "All of the above methods are designed for a single task, following navigational instructions or answering questions, whereas we aim to train a single model for both tasks. Yu et al. (2018b) introduced a model for interactive language acquisition by training on both Visual Question Answering and following instructions in a 2D grid world environment. We aim to tackle multimodal multitask learning in challenging 3D environments. Partial observability results in the requirement of learning to navigate for answering the questions, turning visual question answering to embodied question answering. 3D environments also allow us to test on interesting and more challenging instructions based on relative size of the objects, in addition to colors and types. ",
+        "bbox": [
+            174,
+            738,
+            823,
+            851
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In addition to the above, there is a huge body of work on multimodal learning in static settings which do not involve navigation or reinforcement learning. Some relevant works which use attention mechanisms similar to the ones used in our proposed model include Perez et al. (2017); Fukui et al. (2016); Xu & Saenko (2016); Hudson & Manning (2018); Gupta et al. (2017b) for Visual Question Answering and Zhao et al. (2018) for grounding audio to vision. ",
+        "bbox": [
+            176,
+            857,
+            823,
+            928
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/a49406c1969d1fd52bfa11b26df5a13669079ff90e34764405f0a9c3943df268.jpg",
+        "image_caption": [
+            "Figure 2: Overview of our proposed architecture, described in detail in Section 4. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            104,
+            785,
+            195
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PROBLEM FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            241,
+            418,
+            257
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Consider an autonomous agent interacting with an episodic environment as shown in Figure 1. In the beginning of each episode, the agent receives a textual input $T$ specifying the task that it needs to achieve. For example, $T$ could be an instruction describing the target object or a question querying about some visual detail of objects in the environment. At each time step $t$ , the agent observes a state $s _ { t } = ( I _ { t } , T )$ where $I _ { t }$ is the first-person (egocentric) view of the environment, and takes an action $a _ { t }$ , which could be a navigational action or an answer action. The agent’s objective is to learn a policy $\\pi ( a _ { t } | s _ { t } )$ which leads to successful completion of the task specified by the textual input $T$ . ",
+        "bbox": [
+            173,
+            268,
+            825,
+            366
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Tasks. We focus on the multi-task learning of two visually-grounded language navigation tasks: In Embodied Question Answering $( E Q A )$ , the agent is given a question (“What color is the torch?”), and it must navigate around the 3D environment to explore the environment and gather information to answer the question (“red”). In Semantic Goal Navigation (SGN), the agent is given a language instruction ( $^ { 6 6 } \\mathrm { G o }$ to the red torch”) to navigate to a goal location. ",
+        "bbox": [
+            174,
+            372,
+            825,
+            443
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Environments. We adapt the ViZDoom (Kempka et al., 2016)-based language grounding environment proposed by Chaplot et al. (2017) for visually-grounded multitask learning. It consists of a single room with 5 objects. The objects are randomized in each episode based on the textual input. We use two difficulty settings for the Doom domain: Easy: The agent is spawned at a fixed location. The candidate objects are spawned at five fixed locations along a single horizontal line in the field of view of the agent. Hard: The candidate objects and the agent are spawned at random locations and the objects may or may not be in the agents field of view in the initial configuration. The agent must explore the map to view all objects. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            560
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We use the set of instructions from Chaplot et al. (2017) and create a dataset for questions using the same set of objects and attributes. We define cross-task knowledge transfer as an evaluation criteria for testing generalization of multi-task models. We create train-test splits for both instructions and questions datasets to explicitly test a multitask model’s ability to transfer the knowledge of words across different tasks. Each instruction in the test set contains a word that is never seen in any instruction in the training set but is seen in some questions in the training set. Similarly, each question in the test set contains a word never seen in any training set question. Figure 1 illustrates the train-test split of instructions and questions used in our experiments in the Doom domain. Note that for the EQA trainset, unseen words can be present in the answer. ",
+        "bbox": [
+            173,
+            566,
+            825,
+            693
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The agent can take 4 actions: 3 navigational actions (forward, left, right) and 1 answer action. When the agent takes the answer action, the answer with the maximum probability in the output answer distribution is used. Other details such as the train-test splits are deferred to the Appendix. We also report results on an additional environment based on House3D (Wu et al., 2018) in the Appendix. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 PROPOSED METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            771,
+            377,
+            787
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we detail our proposed architecture (illustrated in Figure 2). At the start of each episode, the agent receives a textual input $T$ (an instruction or a question) specifying the task that it needs to achieve. At each time step, the agent observes an egocentric image $I _ { t }$ which is passed through a convolutional neural network (LeCun et al., 1995) with ReLU activations (Glorot et al., 2011) to produce the image representation $x _ { I } = f ( I _ { t } ; \\theta _ { \\mathrm { c o n v } } ) \\in \\mathbb { R } ^ { V \\times H \\times W }$ , where $\\theta _ { \\mathrm { c o n v } }$ denotes the parameters of the convolutional network, $V$ is the number of feature maps in the convolutional network output which is equal to the vocabulary size, and $H$ and $W$ are the height and width of each feature map. We use two representations for the textual input $T$ : (1) the bag-of-words representation denoted by $x _ { \\mathrm { B o W } } ~ \\in ~ \\mathbb { R } ^ { V }$ and (2) a sentence representation $x _ { \\mathrm { s e n t } } = f ( \\breve { T } ; \\theta _ { \\mathrm { s e n t } } ) \\in \\mathbb { R } ^ { \\breve { V } }$ , which is computed by passing the words in $T$ through a Gated Recurrent Unit (GRU) (Cho et al., 2014) network followed by a linear layer. Here, $\\theta _ { \\mathrm { s e n t } }$ denotes the parameters of the GRU network and the linear layer with ReLU activations. Next, the Dual-Attention unit $f _ { \\mathrm { D A } }$ combines the image representation with the text representations to get the complete state representation $x _ { S }$ and answer prediction $x _ { \\mathrm { A n s } }$ : ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9a477078ce9fc48266be90f6b6df84b63c02c11e6ff0d0820fb6ebcaaa177a0a.jpg",
+        "text": "$$\nx _ { \\mathrm { S } } , x _ { \\mathrm { A n s } } = f _ { \\mathrm { D A } } ( x _ { I } , x _ { \\mathrm { B o W } } , x _ { \\mathrm { s e n t } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            171,
+            602,
+            189
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, $x _ { S }$ and $x _ { \\mathrm { A n s } }$ , along with a time step embedding and a task indicator variable (for whether the task is SGN or EQA), are passed to the policy module to produce an action. ",
+        "bbox": [
+            171,
+            190,
+            823,
+            219
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 DUAL-ATTENTION UNIT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            236,
+            385,
+            251
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Dual-Attention unit uses two types of attention mechanisms, Gated-Attention $f _ { \\mathrm { G A } }$ and SpatialAttention $f _ { \\mathrm { S A } }$ , to align representations in different modalities and tasks. ",
+        "bbox": [
+            174,
+            262,
+            823,
+            290
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Gated-Attention. The Gated-Attention unit (Figure 3) was proposed in (Chaplot et al., 2017) for multimodal fusion. Intuitively, a GA unit attends to the different channels in the image representation based on the text representation. For example, if the textual input is the instruction ‘Go to the red pillar’, then the GA unit can learn to attend to channels which detect red things and pillars. More specifically, the GA unit takes as input a 3-dimensional tensor image representation $y _ { I } \\in \\mathring { \\mathbb { R } } ^ { d \\times H \\times W }$ and a text representation $\\bar { y _ { T } } \\in \\mathbb { R } ^ { d }$ , and outputs a 3-dimensional tensor ${ \\boldsymbol { z } } \\in \\mathbb { R } ^ { d \\times H \\times W }$ . Note that the dimension of $y _ { T }$ is equal to the number of feature maps and the size of the first dimension of $y _ { I }$ . In the Gated-Attention unit, each element of $y _ { T }$ is expanded to a $H \\times W$ matrix, resulting in a 3-dimensional tensor $M _ { y _ { T } } \\in \\mathbb { R } ^ { d \\times H \\times W }$ , whose $( i , j , k ) ^ { t \\bar { h } }$ element is given by $M _ { y _ { T } } [ i , j , k ] = \\bar { y } _ { T } [ i ]$ . This matrix is multiplied element-wise with the image representation: $z = f _ { \\mathrm { G A } } ( y _ { I } , y _ { T } ) = M _ { y _ { T } } \\odot y _ { I }$ , where $\\odot$ denotes the Hadamard product (Horn, 1990). ",
+        "bbox": [
+            174,
+            296,
+            549,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/888f192624493aa788242aabe8918602f25c59af6c7afb47da6321d3f27acf6d.jpg",
+        "image_caption": [
+            "Figure 3: Gated-Attention unit $f _ { \\mathrm { G A } }$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            558,
+            314,
+            808,
+            397
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            435,
+            825,
+            506
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Spatial-Attention. We propose a Spatial-Attention unit (Figure 4) which is analogous to the Gated-Attention unit except that it attends to different pixels in the image representation rather than the channels. For example, if the textual input is the question ‘Which object is blue in color?’, then we would like to spatially attend to the parts of the image which contain a blue object in order recognize the type of the blue object. The Spatial-Attention unit takes as input a 3-dimensional tensor image representation $y _ { I } \\in \\dot { \\mathbb { R } ^ { d \\times H \\times W } }$ and a 2-dimensional spatial attention map $\\mathit { y } _ { S } \\in \\mathbb { R } ^ { H \\times W }$ , and outputs a tensor $\\mathit { \\check { z } } \\in \\mathbb { R } ^ { d \\times H \\times W }$ . Note that the height and width of the spatial attention map is equal to the height and width of the image representation. In the spatialattention unit, each element of the spatial attention map is expanded to a $d$ dimensional vector. This again results in a 3-dimensional tensor $M _ { y _ { S } } \\in \\mathbb { R } ^ { d \\times \\hat { H } \\times W }$ , whose $( i , j , k ) ^ { t h }$ element is given by: $\\bar { M } _ { y s } [ i , j , k ] = y _ { S } [ j , k ]$ . Just like in the Gated-Attention unit, this matrix is multiplied element-wise with the image representation: $z = f _ { \\mathrm { S A } } ( y _ { I } , y _ { S } ) = M _ { y _ { S } } \\odot y _ { I }$ . Similar spatial attention mechanisms have been used for Visual Question Answering (Fukui et al., 2016; Xu & Saenko, 2016; Hudson & Manning, 2018; Gupta et al., 2017b) and grounding audio in vision (Zhao et al., 2018). ",
+        "bbox": [
+            174,
+            512,
+            549,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/e7a785f4ad73bbe78d600384b1b5f88adcfc6098742f7d2bb686856c9e974c72.jpg",
+        "image_caption": [
+            "Figure 4: Spatial-Attention unit $f _ { \\mathrm { S A } }$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            557,
+            529,
+            808,
+            611
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            650,
+            825,
+            762
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Dual-Attention. We now describe the operations in the Dual-Attention unit shown in Figure 5, as well as motivate the intuitions behind each operation. Given $x _ { I }$ , $x _ { \\mathrm { B o W } }$ , and $x _ { \\mathrm { s e n t } }$ , the Dual-Attention unit first computes a Gated-Attention over $x _ { I }$ using $x _ { \\mathrm { B o W } }$ : ",
+        "bbox": [
+            174,
+            768,
+            825,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/53dea56cfe2785c0aacf9210d9b50cfff6325aeac3db0508672dd32f789acce9.jpg",
+        "text": "$$\nx _ { \\mathrm { G A l } } = f _ { \\mathrm { G A } } ( x _ { I } , x _ { \\mathrm { B o W } } ) \\in \\mathbb { R } ^ { V \\times H \\times W } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            815,
+            622,
+            835
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, this first Gated-Attention unit associates each word in the vocabulary with a feature map in the image representation. A particular feature map is activated if and only if the corresponding word occurs in the textual input. In other words, the feature maps in the convolutional output learns to detect different objects and attributes, and words in the textual input specify which objects and attributes are relevant to the current task. The Gated-Attention using BoW representation attends to feature maps detecting corresponding objects and attributes, and masks all other feature maps. We use bag-of-words representation for the first GA unit as it explicitly aligns the words in textual input irrespective of whether it is a question or an instruction. Note that bag-of-words representation has been used previously in models trained for learning to follow instructions (Hermann et al., 2017). ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/a7e5f5b2f4bacd0b9ce717a508e7d79925d868fa21a8c187b4d6a12dd64fc350.jpg",
+        "image_caption": [
+            "Figure 5: Architecture of the Dual-Attention unit with example intermediate representations and operations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            98,
+            813,
+            270
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            327,
+            821,
+            371
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Next, the output of the Gated-Attention unit $x _ { \\mathrm { G A 1 } }$ is converted to a spatial attention map by summing over all channels followed by a softmax over $H \\times W$ elements: ",
+        "bbox": [
+            171,
+            377,
+            823,
+            406
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5b5dfb779e213cccb5af97bd1b97bd2d98e2f7b15763d52e68a49d10cf9a4c26.jpg",
+        "text": "$$\nx _ { \\mathrm { s p a t } } = \\sigma \\left( \\sum _ { i } ^ { V } { x _ { \\mathrm { G A l } } [ i , : , : ] } \\right) \\in \\mathbb { R } ^ { H \\times W }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            410,
+            627,
+            454
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the softmax $\\sigma ( z ) _ { j } = \\exp ( z _ { j } ) / \\sum _ { j } \\exp ( z _ { j } )$ ensures that the attention map is normalized. Summation of $x _ { \\mathrm { G A l } }$ along the depth dimension gives a spatial attention map which has high activations at spatial locations where relevant objects or attributes are detected. ReLU activations in the convolutional feature maps makes all elements positive, ensuring that the summation aggregates the activations of relevant feature maps. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            530
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$x _ { \\mathrm { s p a t } }$ and $x _ { I }$ are then passed through a Spatial-Attention unit: ",
+        "bbox": [
+            173,
+            536,
+            573,
+            551
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0a1ce057a4d7916019cef3002f085eefb3d7328dab947a5cf18fd8d11f5597d4.jpg",
+        "text": "$$\nx _ { \\mathrm { S A } } = f _ { \\mathrm { S A } } ( x _ { I } , x _ { \\mathrm { s p a t } } ) \\in \\mathbb { R } ^ { V \\times H \\times W }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            556,
+            612,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The Spatial-Attention unit outputs all attributes present at the locations where relevant objects and attributes are detected. This is especially helpful for question answering, where a single GatedAttention may not be sufficient. For example, if the textual input is ‘Which color is the pillar?’, then the model needs to attend not only to feature maps detecting pillars (done by the Gated-Attention), but also to other attributes at the spatial locations where pillars are seen in order to predict their color. Note that a single Gated-Attention is sufficient for instruction following, as shown in (Chaplot et al., 2017). For example, if the textual input is ‘Go to the green pillar’, the first Gated-Attention unit can learn to attend to feature maps detecting green objects and pillar, and learn a navigation policy based on the spatial locations of the feature map activations. ",
+        "bbox": [
+            173,
+            580,
+            825,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$x _ { \\mathrm { S A } }$ is then passed through another Gated-Attention unit with the sentence-level text representation: ",
+        "bbox": [
+            171,
+            712,
+            823,
+            727
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c2f422d394e5aa39fd0b01a9687570166e773a77be9f521371c2444b6252180e.jpg",
+        "text": "$$\nx _ { \\mathrm { G A 2 } } = f _ { \\mathrm { G A } } ( x _ { \\mathrm { S A } } , x _ { \\mathrm { s e n t } } ) \\in \\mathbb { R } ^ { V \\times H \\times W }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            731,
+            620,
+            751
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This second Gated-Attention unit enables the model to attend to different types of attributes based on the question. For instance, if the question is asking about the color (‘Which color is the pillar?’), then the model needs to attend to the feature maps corresponding to colors; or if the question is asking about the object type (‘Which object is green in color?’), then the model needs to attend to the feature maps corresponding to object types. The sentence embedding $x _ { \\mathrm { s e n t } }$ can learn to attend to multiple channels based on the textual input and mask the rest. ",
+        "bbox": [
+            173,
+            755,
+            825,
+            839
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Next, the output is transformed to answer prediction by again doing a summation and softmax but this time summing over the height and width instead of the channels: ",
+        "bbox": [
+            173,
+            844,
+            823,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0daedaacc108632c304ac35dd2039c7625699fb7bf18eea83f8178c53dfe6988.jpg",
+        "text": "$$\nx _ { \\mathrm { A n s } } = \\sigma \\left( \\sum _ { j , k } ^ { H , W } x _ { \\mathrm { G A 2 } } [ : , j , k ] \\right) \\in \\mathbb { R } ^ { V }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            878,
+            622,
+            929
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Summation of $x _ { \\mathrm { G A } 2 }$ along each feature map aggregates the activations for relevant attributes spatially. Again, ReLU activations for sentence embedding ensure aggregation of activations for each attribute or word. The answer space is identical to the textual input space $\\mathbb { R } ^ { V }$ . ",
+        "bbox": [
+            174,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, the Dual-Attention unit $f _ { \\mathrm { D A } }$ outputs the answer prediction $x _ { \\mathrm { A n s } }$ and the flattened spatial attention map $x _ { \\mathrm { S } } = \\mathrm { v e c } ( x _ { \\mathrm { s p a t } } )$ , where $\\mathrm { v e c } \\bar { ( . ) }$ denotes the flattening operation. ",
+        "bbox": [
+            171,
+            152,
+            821,
+            181
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Policy Module. The policy module takes as input the state representation $x _ { S }$ from the DualAttention unit, a time step embedding $t$ , and a task indicator variable $I$ (for whether the task is SGN or EQA). The inputs are concatenated then passed through a linear layer, then a recurrent GRU layer, then linear layers to estimate the policy function $\\pi ( a _ { t } \\mid I _ { t } , T )$ and the value function $V ( I _ { t } , T )$ . ",
+        "bbox": [
+            174,
+            188,
+            825,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "All above operations are differentiable, making the entire architecture trainable end-to-end. Note that all attention mechanisms in the Dual-Attention unit only modulate the input image representation, i.e., mask or amplify specific feature maps or pixels. This ensures that there is an explicit alignment between the words in the textual input, the feature maps in the image representation, and the words in answer space. This forces the convolutional network to encode all the information required with respect to a certain word in the corresponding output channel. This explicit taskinvariant alignment between convolutional feature maps and words in the input and answer space facilitates grounding and allows for cross-task knowledge transfer. As shown in the results later, this also makes our model modular and allows easy addition of objects and attributes to a trained model. ",
+        "bbox": [
+            174,
+            251,
+            825,
+            376
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            392,
+            318,
+            405
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The entire model is trained to predict both navigational actions and answers jointly. The policy is trained using Proximal Policy Optimization (PPO) (Schulman et al., 2017). For training the answer predictions, we use a supervised cross-entropy loss. Both types of losses have common parameters as the answer prediction is essentially an intermediate representation for the policy. ",
+        "bbox": [
+            174,
+            412,
+            823,
+            468
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Auxiliary Task. As mentioned earlier, the feature maps in the convolutional output are expected to detect different objects and attributes. Consequently, we add a spatial auxiliary task to detect the object or attribute in the convolutional output channels corresponding to the word in the bag-of-words representation. A prior work (Gupta et al., 2017b) also explored the use of attribute and object recognition as an auxiliary task for Visual Question Answering. Rather than doing fine-grained object detection, we keep the size of the auxiliary predictions the same as the convolutional output to avoid increase in number of parameters, and maintain the explicit alignment on the convolutional feature maps with the words. Consequently, auxiliary labels are $( V \\times H \\times W )$ -dimensional tensors, where each of the $V$ channels correspond to a word in the vocabulary, and each element in a channel is 1 if the corresponding object or attribute is present in the current frame spatially. Figure 6 shows examples of auxiliary task labels for the channel corresponding to the word ‘red’. The auxiliary tasks are also trained with cross-entropy loss. ",
+        "bbox": [
+            174,
+            476,
+            614,
+            601
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/fa7a1639c57b9e7bccb73053f54f5d1fe41e28c1028ec51acbe83fd8097150c0.jpg",
+        "image_caption": [
+            "Figure 6: Example auxiliary task labels for the red channel. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            627,
+            479,
+            823,
+            564
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            602,
+            825,
+            684
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS & RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            703,
+            428,
+            719
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Jointly learning semantic goal navigation and embodied question answering essentially involves a fusion of verbal and visual modalities. While prior methods are designed for a single task, we adapt several baselines for our environment and tasks by using their multimodal fusion techniques. We use two naive baselines, Image only and Text only; two baselines based on prior semantic goal navigation models, Concat (used by Hermann et al. (2017); Misra et al. (2017)) and Gated-Attention (GA) (Chaplot et al., 2017); and two baselines based on Question Answering models, FiLM (Perez et al., 2017) and PACMAN (Das et al., 2017). For fair comparison, we replace the proposed DualAttention unit with multimodal fusion techniques in the baselines and keep everything else identical to the proposed model. We provide more implementation details of all baselines in the Appendix. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            875,
+            277,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We train all models for 10 million frames in the Easy setting and 50 million frames in the Hard setting. We use a $+ 1$ reward for reaching the correct object in SGN episodes and predicting the correct answer in EQA episodes. We use a small negative reward of -0.001 per time step to encourage shorter paths to target and answering questions as soon as possible. We also use distance-based reward shaping for SGN episodes, where the agent receives a small reward proportional to decrease in distance to the target. In the next subsection we evaluate the performance of the proposed model without the reward shaping. SGN episodes end when the agent reaches any object, and EQA episodes when the agent predicts any answer. All episodes have a maximum length of 210 time steps. We train all models with and without the auxiliary tasks using identical reward functions. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f763d40f3cf3cc304935d3ef380ea01fe08bd89fadf0f7ce22ecb962077a7f5.jpg",
+        "image_caption": [
+            "Figure 7: Training accuracy of all models trained with auxiliary tasks for Easy (left) and Hard (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            98,
+            759,
+            227
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/0780412306b172e3fc51fe31cf166b5d535d27096b5b77bdb329922387195d78.jpg",
+        "table_caption": [
+            "Table 1: Accuracy of all models on SGN & EQA test sets for both Easy & Hard difficulties. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"4\">Easy</td><td colspan=\"4\">Hard</td></tr><tr><td></td><td colspan=\"2\">No Aux</td><td colspan=\"2\">Aux</td><td colspan=\"2\">No Aux</td><td colspan=\"2\">Aux</td></tr><tr><td>Model</td><td>SGN</td><td>EQA</td><td>SGN</td><td>EQA</td><td>SGN</td><td>EQA</td><td>SGN</td><td>EQA</td></tr><tr><td>Text only</td><td>0.2</td><td>0.33</td><td>0.2</td><td>0.33</td><td>0.2</td><td>0.33</td><td>0.2</td><td>0.33</td></tr><tr><td>Image only</td><td>0.20</td><td>0.09</td><td>0.21</td><td>0.08</td><td>0.16</td><td>0.08</td><td>0.15</td><td>0.08</td></tr><tr><td>Concat</td><td>0.33</td><td>0.21</td><td>0.31</td><td>0.19</td><td>0.2</td><td>0.26</td><td>0.39</td><td>0.22</td></tr><tr><td>GA</td><td>0.27</td><td>0.18</td><td>0.35</td><td>0.24</td><td>0.18</td><td>0.11</td><td>0.22</td><td>0.24</td></tr><tr><td>FiLM</td><td>0.24</td><td>0.11</td><td>0.34</td><td>0.12</td><td>0.12</td><td>0.03</td><td>0.25</td><td>0.15</td></tr><tr><td>PACMAN</td><td>0.26</td><td>0.12</td><td>0.33</td><td>0.10</td><td>0.29</td><td>0.33</td><td>0.11</td><td>0.27</td></tr><tr><td>Dual-Attention</td><td>0.86</td><td>0.53</td><td>0.96</td><td>0.58</td><td>0.86</td><td>0.38</td><td>0.82</td><td>0.59</td></tr></table>",
+        "bbox": [
+            176,
+            275,
+            823,
+            415
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            443,
+            825,
+            541
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "All models are trained jointly for both the tasks and tested on each task separately. In Figure 7, we show the training performance curves for all models trained with Auxiliary tasks in both Easy and Hard settings. In Table 1, we report the test performance of all models on both SGN and EQA for both Easy and Hard settings. During training, the Dual-Attention model learns faster as compared to the baselines in the Easy setting while achieving higher final performance in the Hard setting (see Figure 7). More interestingly, as shown in Table 1, the Dual-Attention model achieves considerably higher accuracy on the test set for SGN and EQA in both the difficulty settings when trained with or without auxiliary tasks. These results confirm the hypothesis that prior models, which are designed for a single task, lack the ability align the words in both the tasks and transfer knowledge across tasks. Lower accuracy on EQA for most models (see Table 1) indicates that EQA is more challenging than SGN as it involves alignment between not only input textual and visual representations but also with the answer space. As expected, using spatial auxiliary tasks lead to better performance for all models Visualization of the attention maps and intermediate representations in the model indicate that the textual and visual representations are aligned as expected (see Appendix for visualizations)1. ",
+        "bbox": [
+            173,
+            547,
+            825,
+            742
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 ABLATION TESTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            757,
+            334,
+            771
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We perform a series of ablation tests in order to analyze the contribution of each component in the Dual-Attention unit: without Spatial-Attention (w/o SA), without the first Gated-Attention with $x _ { B o W }$ (w/o GA1), and without the second Gated-Attention with $x _ { \\mathrm { s e n t } }$ (w/o GA2). We also try removing the task indicator variable (w/o Indicator Variable), removing reward shaping (w/o Reward Shaping), and training the proposed model on a single task, SGN or EQA (DA Single-Task). ",
+        "bbox": [
+            174,
+            777,
+            825,
+            848
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 8 shows the training performance curves for the Dual-Attention model along with all ablation models in the Easy Setting. In Table 2, we report the test set performance of all ablation models. The results indicate that SA and GA1 contribute the most to the performance of the Dual-Attention model. GA2 is critical for performance on EQA but not SGN (see Table 2). This is expected as GA2 is designed to attend to different objects and attributes based on the question and is used mainly for answer prediction. It is not critical for SGN as the spatial attention map consists of locations of relevant objects, which is sufficient for navigating to the correct object. Reward shaping and indicator variable help with learning speed (see Figure 8), but have little effect on the final performance (see Table 2). Dual-Attention models trained only on single tasks work well on SGN especially with auxiliary tasks. This is because the auxiliary task for single task models includes object detection labels corresponding to the words in the test set. This highlights a key advantage of the proposed model. Due to its modular and interpretable design, the model can used for transferring the policy to new objects and attributes without fine-tuning as discussed in the following subsection. ",
+        "bbox": [
+            176,
+            853,
+            821,
+            896
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/69a4073a5b891f27a0c6d0e7e4b8f3eb9a94e900eda6ec575b749ee8e403a1d8.jpg",
+        "image_caption": [
+            "Figure 8: Training accuracy of proposed Dual-Attention model with all ablation models trained without (left) and with (right) auxiliary tasks for the Easy environment. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            99,
+            758,
+            227
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b49aeed69fcac50cc68bdbb554ea70bb037720c598878d8f4b9ac597c18ecfdf.jpg",
+        "table_caption": [
+            "Table 2: Accuracy of all the ablation models trained with and without Auxiliary tasks on SGN and EQA test sets for the Doom Easy environment. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>No Aux SGN EQA</td><td>Aux SGN</td></tr><tr><td>w/o SA</td><td></td><td>EQA</td></tr><tr><td>w/o GA1</td><td>0.20 0.16 0.25</td><td>0.20 0.15 0.16 0.38</td></tr><tr><td>w/o GA2</td><td>0.14 0.80 0.33</td><td>0.97 0.15</td></tr><tr><td>w/o Task Indicator</td><td>0.79 0.47</td><td>0.96 0.56</td></tr><tr><td>w/o Reward Shaping</td><td>0.82 0.49</td><td>0.93 0.51</td></tr><tr><td>DA Single-Task</td><td>0.63 0.31</td><td>0.91 0.34</td></tr><tr><td></td><td></td><td></td></tr><tr><td>DA Multi-Task</td><td>0.86 0.53</td><td>0.96 0.58</td></tr></table>",
+        "bbox": [
+            173,
+            314,
+            483,
+            443
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/5c95bb849656c81c03ec6f0cf06a185b6a09bde23e4d722cc774e16cf0ff6d2f.jpg",
+        "table_caption": [
+            "Table 3: The performance of a trained policy appended with object detectors on instructions containing unseen words (‘red’ and ‘pillar’). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Instruction</td><td>Easy</td><td>Hard</td></tr><tr><td>Go to the pillar</td><td>1.00</td><td>0.71</td></tr><tr><td>Go to the red object</td><td>0.99</td><td>0.89</td></tr><tr><td>Go to the tall/short pillar</td><td>0.99</td><td>0.68</td></tr><tr><td>Go to the &lt;known_color&gt;pillar.</td><td>1.00</td><td>0.79</td></tr><tr><td>Go to the red &lt;known_object&gt;</td><td>1.00</td><td>0.93</td></tr><tr><td>Go to the largest/smallest red object</td><td>0.95</td><td>0.69</td></tr><tr><td>Go to the tall/short red pillar</td><td>0.99</td><td>0.88</td></tr><tr><td>Go to the red pillar</td><td>0.99</td><td>0.82</td></tr></table>",
+        "bbox": [
+            516,
+            314,
+            823,
+            443
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            473,
+            825,
+            613
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 EXTENSION: TRANSFER TO NEW WORDS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            631,
+            496,
+            645
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Consider a scenario of SGN where the agent is trained to follow instructions of certain objects and attributes. Suppose that the user wants the agent to follow instructions about a new object such as ‘pillar’ or a new attribute such the color ‘red’ which are never seen in any training instruction. Prior SGN models are shown to perform well to unseen combination of object-attribute pairs (Chaplot et al., 2017), but they do not generalize well to instructions containing a new word. The model retrained only on new instructions will lead to catastrophic forgetting of previous instructions. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            736
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In contrast, our model can be used for transfer to new words by training an object detector for each new word and appending it to the image representation $x _ { I }$ . In order to test this, we train a single-task SGN model using the proposed architecture on the training set for instructions. We use auxiliary tasks but only for words in the vocabulary of the instructions training set. After training the policy, we would like the agent to follow instructions containing test words ‘red’ and ‘pillar’, which the agent has never seen or received any supervision about how this attribute or object looks visually. For transferring the policy, we assume access to two object detectors which would give object detections for ‘red’ and ‘pillar’ separately. We resize the object detections to the size of a feature map in the image representation $( H \\times W )$ and append them as channels to the image representation. We also append the words ‘red’ and ‘pillar’ to the bag-of-words representations in the same order such that they are aligned with the appended feature maps. We randomly initialize the embeddings of the new words for computing the sentence embedding. The results in Table 3 show that this policy generalizes well to different types of instructions with unseen words. This suggests that a trained policy can be scaled to more objects provided the complexity of navigation remains consistent. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            150,
+            318,
+            166
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We proposed a Dual-Attention model for visually-grounded multitask learning which uses Gatedand Spatial-Attention to disentangle attributes in feature representations and align them with the answer space. We show that the proposed model is able to transfer the knowledge of words across tasks and outperforms the baselines on both Semantic Goal Navigation and Embodied Question Answering by a considerable margin. We showed that disentangled and interpretable representations make our model modular and allows for easy addition of new objects or attributes to a trained model. In future, the model can potentially be extended to transferring knowledge across different domains by using modular interpretable representations of objects which are domain-invariant. ",
+        "bbox": [
+            174,
+            176,
+            825,
+            287
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            309,
+            285,
+            324
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Devendra Singh Chaplot, Kanthashree Mysore Sathyendra, Rama Kumar Pasumarthi, Dheeraj Rajagopal, and Ruslan Salakhutdinov. Gated-attention architectures for task-oriented language grounding. arXiv preprint arXiv:1706.07230, 2017. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties ¨ of neural machine translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            429
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Das, Samyak Datta, Georgia Gkioxari, Stefan Lee, Devi Parikh, and Dhruv Batra. Embodied question answering. arXiv preprint arXiv:1711.11543, 2017. ",
+        "bbox": [
+            171,
+            440,
+            823,
+            469
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexey Dosovitskiy and Vladlen Koltun. Learning to act by predicting the future. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            481,
+            810,
+            496
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Akira Fukui, Dong Huk Park, Daylen Yang, Anna Rohrbach, Trevor Darrell, and Marcus Rohrbach. Multimodal compact bilinear pooling for visual question answering and visual grounding. arXiv preprint arXiv:1606.01847, 2016. ",
+        "bbox": [
+            176,
+            506,
+            821,
+            549
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Deep sparse rectifier neural networks. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 315–323, 2011. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            603
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Daniel Gordon, Aniruddha Kembhavi, Mohammad Rastegari, Joseph Redmon, Dieter Fox, and Ali Farhadi. Iqa: Visual question answering in interactive environments. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4089–4098, 2018. ",
+        "bbox": [
+            178,
+            613,
+            823,
+            657
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Saurabh Gupta, James Davidson, Sergey Levine, Rahul Sukthankar, and Jitendra Malik. Cognitive mapping and planning for visual navigation. arXiv preprint arXiv:1702.03920, 3, 2017a. ",
+        "bbox": [
+            171,
+            667,
+            823,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tanmay Gupta, Kevin J Shih, Saurabh Singh, Derek Hoiem, Kevin J Shih, Arun Mallya, Wei Di, Vignesh Jagadeesh, Robinson Piramuthu, K Shih, et al. Aligned image-word representations improve inductive transfer across vision-language tasks. In ICCV, pp. 4223–4232, 2017b. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            751
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karl Moritz Hermann, Felix Hill, Simon Green, Fumin Wang, Ryan Faulkner, Hubert Soyer, David Szepesvari, Wojtek Czarnecki, Max Jaderberg, Denis Teplyashin, et al. Grounded language learning in a simulated 3d world. arXiv preprint arXiv:1706.06551, 2017. ",
+        "bbox": [
+            174,
+            761,
+            825,
+            804
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Roger A Horn. The hadamard product. In Proc. Symp. Appl. Math, volume 40, pp. 87–169, 1990. ",
+        "bbox": [
+            171,
+            815,
+            812,
+            830
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Drew A Hudson and Christopher D Manning. Compositional attention networks for machine reasoning. arXiv preprint arXiv:1803.03067, 2018. ",
+        "bbox": [
+            171,
+            842,
+            823,
+            869
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michał Kempka, Marek Wydmuch, Grzegorz Runc, Jakub Toczek, and Wojciech Jaskowski. Viz- ´ doom: A doom-based ai research platform for visual reinforcement learning. arXiv preprint arXiv:1605.02097, 2016. ",
+        "bbox": [
+            174,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Lample and Devendra Singh Chaplot. Playing FPS games with deep reinforcement learning. In Thirty-First AAAI Conference on Artificial Intelligence, 2017. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, et al. Convolutional networks for images, speech, and time series. The handbook of brain theory and neural networks, 3361(10):1995, 1995. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andrew J Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, et al. Learning to navigate in complex environments. arXiv preprint arXiv:1611.03673, 2016. ",
+        "bbox": [
+            176,
+            229,
+            821,
+            272
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dipendra K Misra, John Langford, and Yoav Artzi. Mapping instructions and visual observations to actions with reinforcement learning. arXiv preprint arXiv:1704.08795, 2017. ",
+        "bbox": [
+            173,
+            281,
+            821,
+            310
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            173,
+            319,
+            823,
+            363
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In ICML, 2016. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            414
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Satinder Singh, Honglak Lee, and Pushmeet Kohli. Zero-shot task generalization with multi-task deep reinforcement learning. arXiv preprint arXiv:1706.05064, 2017. ",
+        "bbox": [
+            171,
+            422,
+            821,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ethan Perez, Florian Strub, Harm De Vries, Vincent Dumoulin, and Aaron Courville. Film: Visual reasoning with a general conditioning layer. arXiv preprint arXiv:1709.07871, 2017. ",
+        "bbox": [
+            171,
+            460,
+            825,
+            489
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Manolis Savva, Angel X. Chang, Alexey Dosovitskiy, Thomas Funkhouser, and Vladlen Koltun. MINOS: Multimodal indoor simulator for navigation in complex environments. arXiv:1712.03931, 2017. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            540
+        ],
+        "page_idx": 9
+    },
+    {
+        "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": [
+            173,
+            549,
+            823,
+            579
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            174,
+            587,
+            823,
+            630
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yi Wu, Yuxin Wu, Georgia Gkioxari, and Yuandong Tian. Building generalizable agents with a realistic and rich 3d environment. arXiv preprint arXiv:1801.02209, 2018. ",
+        "bbox": [
+            169,
+            638,
+            823,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Huijuan Xu and Kate Saenko. Ask, attend and answer: Exploring question-guided spatial attention for visual question answering. In European Conference on Computer Vision, pp. 451–466. Springer, 2016. ",
+        "bbox": [
+            174,
+            676,
+            823,
+            719
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Haonan Yu, Xiaochen Lian, Haichao Zhang, and Wei Xu. Guided feature transformation (gft): A neural language grounding module for embodied agents. arXiv preprint arXiv:1805.08329, 2018a. ",
+        "bbox": [
+            178,
+            728,
+            823,
+            771
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Haonan Yu, Haichao Zhang, and Wei Xu. Interactive grounded language acquisition and generalization in a 2d world. arXiv preprint arXiv:1802.01433, 2018b. ",
+        "bbox": [
+            171,
+            780,
+            821,
+            809
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hang Zhao, Chuang Gan, Andrew Rouditchenko, Carl Vondrick, Josh McDermott, and Antonio Torralba. The sound of pixels. arXiv preprint arXiv:1804.03160, 2018. ",
+        "bbox": [
+            173,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuke Zhu, Roozbeh Mottaghi, Eric Kolve, Joseph J Lim, Abhinav Gupta, Li Fei-Fei, and Ali Farhadi. Target-driven visual navigation in indoor scenes using deep reinforcement learning. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pp. 3357–3364. IEEE, 2017. ",
+        "bbox": [
+            176,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A VISUALIZATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            354,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/eb82cf3d410040af24e674376db93bf154e95616c9f3df8c13dcc8542653e7ae.jpg",
+        "image_caption": [
+            "Figure 9: Visualizations of convolutional output channels. We visualize the convolutional channels corresponding to 7 words (one in each row) for the same frame (shown in the rightmost column). The first column shows the auxiliary task labels for reference. The second column and third column show the output of the corresponding channel for the proposed Dual-Attention model trained without and with auxiliary tasks, respectively. As expected, the Aux model outputs are very close to the auxiliary task labels. The convolutional outputs of the No Aux model show that words and objects/properties in the images have been properly aligned even when the model is not trained with any auxiliary task labels. We do not provide any auxiliary label for words ‘smallest’ and ‘largest’ as they are not properties of an object and require relative comparison of objects. The visualizations in row 5 (corresponding to ‘smallest’) indicate that both models are able to compare the sizes of objects and detect the smallest object in the corresponding output channel even without any aux labels for the smallest object. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            143,
+            816,
+            654
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/c09df43f375517b1e7308882219ccaabee4d2f03fc7563c5a1c2705c93dc07be.jpg",
+        "image_caption": [
+            "Figure 10: Spatial Attention and Answer Prediction Visualizations. An example EQA episode with the question “Which is the smallest blue object?”. The sentence embedding of the question is shown on the top $( x _ { s e n t } )$ . As expected, the embedding attends to object type words (’torch’, ’pillar’, ’skullkey’, etc.) as the question is asking about an object type (’Which object’). The rows show increasing time steps and columns show the input frame, the input frame overlaid with the spatial attention map, the predicted answer distribution, and the action at each time step. As the agent is turning, the spatial attention attends to small and blue objects. Time steps 1, 2: The model is attending to the yellow skullkey but the probability of the answer is not sufficiently high, likely because the skullkey is not blue. Time step 3: The model cannot see the skullkey anymore so it attends to the armor which is next smallest object. Consequently, the answer prediction also predicts armor, but the policy decides not to answer due to low probability. Time step 4: As the agent turns more, it observes and attends to the blue skullkey. The answer prediction has high probability for skullkey as it’s small and blue and the policy decides to answer the question. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            286,
+            812,
+            578
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/6acfbbc3bc1a92d1814e01f282a9c869e31804d2fe115c6a5a2a0783ad26bf0f.jpg",
+        "image_caption": [
+            "Figure 11: Architecture of the policy module. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            99,
+            789,
+            186
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B ADDITIONAL EXPERIMENTAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            243,
+            534,
+            260
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.1 HYPERPARAMETERS AND NETWORK DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            279,
+            529,
+            292
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The input image is rescaled to size $3 \\times 1 6 8 \\times 3 0 0$ . The convolutional network for processing the image consisted of 3 convolutional layers: conv1 containing $3 2 ~ 8 \\mathrm { x } 8$ filters with stride 4, conv2 containing $6 4 ~ 4 \\mathrm { x } 4$ filters with stride 2, and conv3 containing $V$ 3x3 filters with stride 2. We use ReLU activations for conv1 and conv2 and sigmoid for conv3, as its output is used as auxiliary task predictions directly. We use word embeddings and GRU of size 32 followed by linear layer of size $V$ to get the sentence-level representation. The policy module uses hidden dimension 128 for the linear and GRU layers (see Figure 11). ",
+        "bbox": [
+            174,
+            306,
+            825,
+            405
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For reinforcement learning, we use Proximal Policy Optimization (PPO) with 8 actors and a time horizon of 128 steps. We use a single batch with 4 PPO epochs. The clipping parameter for PPO is set to 0.2. The discount factor $( \\gamma )$ is 0.99. We used Adam optimizer with learning rate $2 . 5 \\mathrm { e } { \\cdot } 4$ for all experiments. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            467
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.2 BASELINE DETAILS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            489,
+            351,
+            503
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Image only: Naive baseline of just using the image representation: $x _ { \\mathrm { S } } = \\sec ( x _ { I } )$ where vec(.) denotes the flattening operation. ",
+        "bbox": [
+            174,
+            518,
+            823,
+            546
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Text only: Naive baseline of just using the textual representations: $x _ { \\mathrm { S } } = [ x _ { \\mathrm { B o W } } , x _ { \\mathrm { s e n t } } ]$ ",
+        "bbox": [
+            176,
+            553,
+            736,
+            568
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Concat: The image and textual representations are concatenated: $x _ { \\mathrm { S } } = [ \\mathrm { v e c } ( x _ { I } ) , x _ { \\mathrm { B o W } } , x _ { \\mathrm { s e n t } } ]$ . Note that concatenation is the most common method of combining representations. Hermann et al. (2017) concatenate convolutional image and bag-of-words textual representations for SGN, whereas Misra et al. (2017) use concatenation with sentence-level textual representations. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            631
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Gated-Attention: Adapted from Chaplot et al. (2017), who used Gated-Attention with sentencelevel textual representations for SGN: $x _ { \\mathrm { S } } = f _ { \\mathrm { G A } } ( x _ { I } , x _ { \\mathrm { s e n t } } )$ . ",
+        "bbox": [
+            173,
+            637,
+            821,
+            666
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "FiLM: Perez et al. (2017) introduced a general-purpose conditioning method called Feature-wise Linear Modulation (FiLM) for Visual Question Answering. Using FiLM, $x _ { \\mathrm { S } } = \\gamma ( x _ { \\mathrm { s e n t } } ) \\odot x _ { I } +$ $\\beta ( x _ { \\mathrm { s e n t } } )$ where $\\gamma ( x _ { \\mathrm { s e n t } } )$ and $\\beta ( x _ { \\mathrm { s e n t } } )$ are learnable projections of the sentence representation. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            715
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "PACMAN: Das et al. (2017) presented a hierarchical RL model for EQA. We adapt their method by using the attention mechanism in their QA module, which takes the last 5 frames and the text as input, and computes the similarity of the text with each frame using dot products between image and sentence-level text representations. These similarities are converted into attention weights using softmax, and the attention-weighted image features are concatenated with question embedding and passed through a softmax classifier to predict the answer distribution. For this particular baseline, we use the last 5 frames as input at each time step, unlike the proposed model and all other baselines which use a single frame as input. The attention-weighted image features are used as the state representation. The PACMAN model used a pretrained QA module, but we train this module jointly with the Navigation model for fair comparison with the proposed model. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            861
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For each of the above method except PACMAN, we use a linear layer $f$ with ReLU activations followed by softmax $\\sigma$ to get a $V$ -dimensional answer prediction from the state representations: $x _ { \\mathrm { A n s } } = \\sigma ( \\bar { f } ( x _ { \\mathrm { S } } ; \\theta _ { L i n } ) )$ . $x _ { \\mathrm { { S } } }$ and $x _ { A n s }$ are concatenated and passed to the policy module along with the time step and task indicator variable just as in the proposed model. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/a6315480bb9a073f24a9632c6856b7874a62864e259308fb0863e2161017b386.jpg",
+        "image_caption": [
+            "Figure 12: Plot showing the training accuracy of all the models without auxiliary tasks for Doom Easy and Hard environments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            99,
+            759,
+            228
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/634ffdf84813ca11c0e122e1a00e556fb733df50e54d4f6c9664f00480c451dd.jpg",
+        "image_caption": [
+            "Figure 13: Plot showing the training accuracy of 3 models across 3 training runs with different seeds with and without auxiliary tasks for Doom Easy environment without any smoothing. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            277,
+            759,
+            405
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C DOOM EXPERIMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            465,
+            457,
+            483
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Additional Results. We show the training accuracy of all models without auxiliary tasks for Doom Easy and Hard in Figure 12. We also show the training accuracy of 3 models across 3 training runs with different seeds with and without auxiliary tasks for Doom Easy environment in Figure 13. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            540
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Dataset. The Doom objects used in our experiments are illustrated in Figure 14. Instructions and questions used for training and evaluation are listed in Tables 4. ",
+        "bbox": [
+            173,
+            547,
+            825,
+            575
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/69d7bb5a3ad8695b8a37ae82bea6b9ec1dbc83f181543eb44b38a763cd846842.jpg",
+        "image_caption": [
+            "Figure 14: Objects of various colors and sizes used in the ViZDoom environment. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            305,
+            589,
+            686,
+            727
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/7057d42e3744461df649f3b29df5a3d9702f5c717d595cdcc3987488ef779a3c.jpg",
+        "table_caption": [
+            "Table 4: Instructions and questions for ViZDoom experiments. We used 5 object classes (torch, pillar, keycard, skullkey, armor), 4 colors (red, green, blue, yellow), 2 sizes (tall, short), and 2 superlative sizes (smallest, largest). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>SGN Instruction Type</td><td></td><td>42 Train Instructions: Not containing‘red&#x27;&amp;‘pillar&#x27;</td><td>28 Test Instructions: Containing‘red&#x27;or‘pillar&#x27;</td></tr><tr><td>Go to the (object).</td><td>Go to the color&gt;object.</td><td>torch,keycard,skullkey,armor yellow, green, blue</td><td>pillar red</td></tr><tr><td></td><td>Go to the size)object. Go to the {color) {object).</td><td>tall, short blue torch, green torch, green armor,</td><td>red torch,red skullkey,red pillar,</td></tr><tr><td></td><td></td><td>blue skullkey,blue keycard, yellow keycard, yellow skullkey</td><td>green pillar,red keycard,red armor</td></tr><tr><td></td><td>Go to the {size) (object). Go to the color) (size)object.</td><td>short torch,tall torch green tall, blue tall, blue short,</td><td>tall pillar, short pillar red short, red tall</td></tr><tr><td></td><td>Go to the size){color)object.</td><td>green short tall green, tall blue, short blue,</td><td>short red, tall red</td></tr><tr><td></td><td>Go to the {color)(size)(object).</td><td>short green green tall torch, green short torch,</td><td>red short pillar,red short torch,</td></tr><tr><td></td><td></td><td>blue short torch,blue tall torch</td><td>red tall pillar, green tall pillar, red tall torch, green short pillar</td></tr><tr><td></td><td>Go to the size) {color&gt; {object).</td><td>tall green torch,short green torch, short blue torch,tall blue torch</td><td>short red pillar, short red torch, tall red pillar, tall green pillar, tall red torch,short green pillar</td></tr><tr><td></td><td>Go to the superlative)object. Go to the {superlative&gt; (color) object.</td><td>largest, smallest smallest yellow, smallest blue, smallest green,largest blue,</td><td>largest red,smallest red</td></tr><tr><td>EQA</td><td>Question Type</td><td>largest green,largest yellow 21 Train Questions: Not containing‘blue&#x27;&amp;‘torch&#x27;</td><td>8 Test Questions: Containing‘blue&#x27;or‘torch&#x27;</td></tr><tr><td>Which {size)object is {color)in color?</td><td>What color is the {object)? What color is the {size){object&gt;? Which object is {color) in color?</td><td>pillar, keycard, skullkey,armor short pillar, tall pillar red,yellow, green</td><td>torch short torch, tall torch blue</td></tr></table>",
+        "bbox": [
+            191,
+            353,
+            808,
+            720
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D HOUSE3D EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            421,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In the House3D domain, we train on one house environment and randomize the colors of each object at the start of each episode. The agent’s spawn location is fixed. We create instructions and questions dataset for this house similar to the Doom domain. The House3D objects used in our experiments are illustrated in Figure 15. Instructions and questions used for training and evaluation are listed in Table 6. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            203
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Each model is trained for 50 million frames jointly on both SGN and EQA, without the auxiliary tasks and using identical reward functions. Similar to Doom, we use a $+ 1$ reward for reaching the correct object in SGN episodes and predicting the correct answer in the EQA episodes. We use a small negative reward of - 0.001 per time step to encourage shorter paths to target and answering the questions as soon as possible. We also use distance based reward shaping for both SGN and EQA episodes, where the agent receives a small reward proportional to decrease in distance to the target. SGN episodes end when the agent reaches any object and EQA episodes when agent predicts any answer. All episodes have a maximum length of 420 time steps. ",
+        "bbox": [
+            174,
+            210,
+            483,
+            417
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/054eaa266cfb697cb6f36a23b30b1a988e4753b5ea56986060bcf5251f1d35fc.jpg",
+        "table_caption": [
+            "Table 5: Accuracy of all the models on the SGN and EQA train and test sets for the House3D Domain. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">SGN</td><td colspan=\"2\">EQA</td></tr><tr><td>Model</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td></tr><tr><td>Text only</td><td>0.63</td><td>0.33</td><td>0.22</td><td>0.23</td></tr><tr><td>Image only</td><td>0.28</td><td>0.01</td><td>0.12</td><td>0.22</td></tr><tr><td>Concat</td><td>0.65</td><td>0.13</td><td>0.31</td><td>0.13</td></tr><tr><td>GA</td><td>0.98</td><td>0.20</td><td>0.92</td><td>0.03</td></tr><tr><td>FiLM</td><td>0.99</td><td>0.37</td><td>0.92</td><td>0.24</td></tr><tr><td>PACMAN</td><td>0.73</td><td>0.20</td><td>0.40</td><td>0.21</td></tr><tr><td>Dual-Attention</td><td>0.99</td><td>0.47</td><td>0.89</td><td>0.29</td></tr></table>",
+        "bbox": [
+            496,
+            265,
+            774,
+            395
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            419,
+            576,
+            433
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In Table 5, we report the train and test performance of all the models on both SGN and EQA. The results are similar as in Doom: the Dual-Attention model outperforms the baselines by a considerable margin. ",
+        "bbox": [
+            174,
+            439,
+            826,
+            481
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/af178f0259047b6ec08600ddcade5e3f117345df9c3c00343e94708605dc643a.jpg",
+        "image_caption": [
+            "Figure 15: Example first-person views of the House3D environment with sample objects of various colors. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            494,
+            815,
+            604
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/5a2c6c4f7fcdbf5cd5e8da09a70edd31b66260c9c36a6aed86484d9c31826ff4.jpg",
+        "table_caption": [
+            "Table 6: Instructions and questions for House3D experiments. We used 6 object classes (refrigerator, office chair, fish tank, fireplace, bed, sofa) and 4 colors (red, green, blue, yellow). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>SGN</td><td>Instruction Type</td><td>22 Train Instructions: Not containing‘red&#x27;&amp;‘bed&#x27;</td><td>11 Test Instructions: Containing‘red&#x27;or‘bed&#x27;</td></tr><tr><td></td><td>Go to the (object). Go to the {color)(object).</td><td>refrigerator,office_chair,fish_tank,fireplace green refrigerator, green office_chair, green fish_tank,green fireplace, green sofa, blue refrigerator, blue office_chair, blue fish_tank,blue fireplace,blue sofa, yellow refrigerator,yellow office_chair, yellow fish_tank,yellow fireplace,yellow sofa</td><td>bed red bed, green bed,blue bed, yellow bed,red refrigerator, red office_chair,red fish_tank, red fireplace,red sofa</td></tr><tr><td>EQA</td><td>Go to the {color) object. Question Type</td><td>green,blue,yellow 7 Train Questions:</td><td>red 2 Test Questions:</td></tr><tr><td></td><td></td><td>Not containing‘blue&#x27;&amp;‘sofa&#x27;</td><td>Containing‘blue&#x27;or‘sofa&#x27;</td></tr><tr><td></td><td>What color is the {object)? What object is color&gt; in color?</td><td>refrigerator,office_chair,fish_tank,fireplace,bed red, green,yellow</td><td>sofa blue</td></tr></table>",
+        "bbox": [
+            199,
+            694,
+            797,
+            863
+        ],
+        "page_idx": 15
+    }
+]

parse/train/HXjt-kRBzvu/HXjt-kRBzvu.md

@@ -0,0 +1,391 @@
+# Bayesian Network Structure Learning using Digital Annealer
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Annealing processors, which efficiently solve a quadratic unconstrained binary   
+2 optimization (QUBO), are a potential breakthrough in improving the accuracy   
+3 of score-based Bayesian network structure learning. However, currently, the bit   
+4 capacity of an annealing processor is very limited. To utilize the power of an  
+5 nealing processors, it is necessary to encode score-based learning problems into   
+6 QUBO within the upper bound of bits. In this paper, we propose a novel approach   
+7 with direct encoding of candidate parent sets in the form of Cartesian products.   
+8 Experimental results on benchmark networks with 27 to 70 variables show that   
+9 our approach requires lesser bits than the bit capacity of the second-generation   
+10 Fujitsu digital annealer, a fully coupled annealing processor developed by with   
+11 semiconductor technology. Moreover, we demonstrate that the digital annealer   
+12 with our conversion method consistently outperforms the state-of-the-art heuristic   
+13 algorithms on the benchmark networks.
+
+# 14 1 Introduction
+
+15 A Bayesian network is a probabilistic graphical model that represents the structure of a joint probabil  
+16 ity distribution among random variables in a directed acyclic graph (DAG) [Pearl, 1988]. One class   
+17 of associated computational problems is learning the structure of a Bayesian network from data. We   
+18 focus on score-based Bayesian network structure learning for finding the DAG with a maximal score   
+19 that depends on the data [Cooper and Herskovits, 1992, Cowell, 2001].   
+20 The Bayesian network learning problem is NP-hard [Chickering et al., 2004]; therefore, the standard   
+21 methodology is using heuristic approaches. Many algorithms have been proposed to improve the   
+22 accuracy and to reduce the running time. A search over the space of orderings [Teyssier and Koller,   
+23 2005, Scanagatta et al., 2015] is one of the most successful heuristic approaches.   
+24 Annealing processors may contribute to finding a high-scoring network structure in a realistic   
+25 timeframe. An annealing processor is expected to be an alternative hardware to von Neumann   
+26 computers for quadratic unconstrained binary optimization (QUBO) problems. In particular, it is   
+27 reported that complementary metal oxide semiconductor (CMOS) annealing processors already   
+28 outperform conventional computers on the speed of solving max-cut problems [Gyoten et al., 2018].   
+29 We note that the bit capacity of an annealing processor is currently limited. Therefore, we need an   
+30 efficient conversion method of Bayesian network structure learning into QUBO within the limited   
+31 bits. Additionally, it is also important to show the lower bounds of penalty coefficients because the   
+32 precision for the biases and variable couplers is limited.   
+33 Annealing processors are classified into the nearest neighbor type and the fully connected type   
+34 [Yamamoto, 2020]. While the coupling nodes of a nearest neighbor annealing processor is limited to   
+35 only between adjacent nodes, the coupling exists between arbitrary nodes of a fully coupled annealing   
+36 processor. Though the scalability of nearest neighbor annealing processors is high, it is necessary to   
+37 consider the additional bits for minor embedding [Choi, 2008, 2010].   
+38 O’Gorman et al. 2014 proposed a method to convert score-based Bayesian network structure learning   
+39 into QUBO that requires $\mathcal { O } ( n ^ { 2 } )$ bits for $n$ random variables and a maximum parent set size $m = 2$ .   
+40 They also demonstrated the sufficient lower bounds of penalty coefficients. However, when $m \geq 3$ ,   
+41 the number of necessary auxiliary variables for a quadratization [Boros and Gruber, 2014] is at most   
+42 $O ( n ( n - 1 ) ^ { \frac { m } { 2 } } )$ . This is a significant disadvantage for the current limited bit capacity of annealing   
+43 processors.   
+44 In this study, we propose an efficient conversion method based on the advanced identification of   
+45 candidate parent sets and their representation in the form of Cartesian products. We also provide a   
+46 greedy algorithm to decompose the candidate parent sets into the form of Cartesian products and   
+47 prove the sufficient lower bounds of penalty coefficients.   
+48 Experimental results on benchmark networks with 27 to 70 variables show that our conversion method   
+49 reduces the required bits significantly in comparison to the previous work [O’Gorman et al., 2014].   
+50 Our approach allows us to utilize the power of the second generation Fujitsu digital annealer, a fully   
+51 coupled CMOS annealing processor [Aramon et al., 2019]. We demonstrate that the digital annealer   
+52 consistently outperforms the ordering space search algorithms on the benchmark networks.
+
+# 53 2 Background
+
+# 2.1 Score-based Bayesian Network Structure Learning
+
+55 The goal of score-based Bayesian network structure learning is to find a DAG with maximal score.   
+56 Given to random variables $\mathscr { X } = ( X _ { i } ) _ { i = 1 } ^ { n }$ and a complete data set of $N$ instances $\mathcal { D } = \{ D _ { 1 } , \cdot \cdot \cdot , D _ { N } \}$ ,   
+57 we optimize the parent set $\Pi _ { i }$ of each random variable,
+
+$$
+\Pi _ { 1 } ^ { * } , \cdot \cdot \cdot , \Pi _ { n } ^ { * } = \underset { \Pi _ { 1 } , \cdots , \Pi _ { n } \subset { \cal X } } { \arg \operatorname* { m i n } } \sum _ { i = 1 } ^ { n } - \log S ^ { ( i ) } ( \Pi _ { i } \mid { \mathcal { D } } ) ,
+$$
+
+where 58 ${ \mathcal { G } } = ( \mathcal { V } , { \mathcal { E } } ) , \mathcal { V } = \{ 1 , \cdots , n \} , { \mathcal { E } } = \{ ( j , i ) | j , i \in \{ 1 , \cdots , n \} , X _ { j } \in \Pi _ { i } \} ,$ and $S _ { i } : \Pi _ { i }  \mathbb { R }$ is a local score function corresponding to 59 $X _ { i }$ . The Bayesian Dirichlet equivalent uniform (BDeu) score 60 [Buntine, 1991] is one of the commonly used scores,
+
+$$
+S _ { \mathrm { B D e u } } ^ { ( i ) } ( \Pi _ { i } \mid \mathcal { D } ) \equiv \prod _ { j = 1 } ^ { \beta _ { i } } \frac { \Gamma ( \alpha _ { i , j } ) } { \Gamma ( N _ { i , j } + \alpha _ { i , j } ) } \prod _ { k = 1 } ^ { \gamma _ { i } } \frac { \Gamma ( N _ { i , j , k } + \alpha _ { i , j , k } ) } { \Gamma ( \alpha _ { i , j , k } ) } ,
+$$
+
+61 ere $\begin{array} { r } { N = \sum _ { j = 1 } ^ { \beta _ { i } } N _ { i , j } , N _ { i , j } = \sum _ { k = 1 } ^ { \gamma _ { i } } N _ { i , j , k } , \alpha _ { i , j } = \sum _ { k = 1 } ^ { \gamma _ { i } } \alpha _ { i , j , k } , \beta _ { i } } \end{array}$ is the numb f joint states of $\Pi _ { i }$ is the number of states of $X _ { i }$ , $N _ { i , j , k }$ is the number of cases of the parent set $\Pi _ { i }$ 63 and Xi in its k-th state, αi,j,k = αβ γ is the hyperparameter of the Dirichlet function, and $0 < \alpha \in \mathbb { R }$ 64 is called equivalent sample size [Heckerman et al., 1995a].
+
+# 65 2.2 Hamiltonian
+
+66 The Hamiltonian, which is the objective function of an annealing processor, is a quadratic pseudo  
+67 Boolean function,
+
+$$
+H ( \pmb { \sigma } ) = \sum _ { i \in \mathcal { V } _ { \mathrm { A P } } } h _ { i } \sigma _ { i } + \sum _ { ( i , j ) \in \mathcal { E } _ { \mathrm { A P } } } J _ { i , j } \sigma _ { i } \sigma _ { j } ,
+$$
+
+68 where ${ \pmb \sigma } = ( { \boldsymbol \sigma } _ { i } ) _ { i = 1 } ^ { | { \boldsymbol \nu } _ { \mathrm { A P } } | } \in \mathbb { B } ^ { | { \boldsymbol \nu } _ { \mathrm { A P } } | }$ , the biases $h _ { i } \in \mathbb { R }$ for all $i \in \mathcal { V } _ { \mathrm { A P } }$ , the couplers $J _ { i , j } \in \mathbb { R }$ for all   
+69 $( i , j ) \in \mathcal { E } _ { \mathrm { A P } }$ , and the graph $\mathcal { G } _ { \mathrm { A P } } = ( \nu _ { \mathrm { A P } } , \mathcal { E } _ { \mathrm { A P } } )$ . Higher degree problems are reformed into quadratic   
+70 ones using auxiliary variables. This reformulation is called quadratization.
+
+71 Definition 1. If a quadratic polynomial function $g ( \pmb { v } , \pmb { h } )$ is a quadratization of a pseudo-Boolean function 72 $f ( v )$ , then $f ( v ) = \operatorname* { m i n } _ { h \in \mathbb { B } ^ { J } } g ( v , h )$ for all $\pmb { v } \in \mathbb { B } ^ { I }$ .
+
+73 Anthony et al. 2016 proved that every pseudo-Boolean function of $I$ variables and of degree $K$ has   
+74 a quadratization involving at most $\dot { \mathcal { O } } ( \dot { I } ^ { \frac { K } { 2 } } )$ auxiliary variables. In particular, at most $\check { \mathcal { O } ( 2 ^ { \frac { I } { 2 } } ) }$ when   
+75 $K = I$ . It is well known that every pseudo-Boolean function can be uniquely represented as a   
+76 multilinear polynomial in its variables [Boros and Hamme, 2002].
+
+# 77 2.3 Basic Conversion of Score-based Bayesian Network Structure Learning
+
+Using 78 $n ( n - 1 )$ bits to encode the paths into $\pmb { d } = ( ( d _ { j , i } ) _ { 1 \leq j \leq n , j \neq i } ) _ { i = 1 } ^ { n } \in \mathbb { B } ^ { n ( n - 1 ) }$ $( d _ { j , i } = 1$ if 79 $X _ { j }$ is the parent of $X _ { i }$ , $d _ { j , i } = 0$ otherwise) and $\binom { n } { 2 }$ bits to encode the topological orders into 80 $r = ( r _ { i , j } ) _ { 1 \leq i < j \leq n } \in \mathbb { B } ^ { \binom { n } { 2 } } ( r _ { i , j } =$ if the order of $X _ { i }$ is higher than $X _ { j }$ , $r _ { i , j } = 1$ otherwise), it is 81 possible to represent eq. (1) on the Hamiltonian,
+
+$$
+H _ { \mathrm { t o t a l } } ( d , r ) \equiv \sum _ { i = 1 } ^ { n } H _ { \mathrm { s c o r e } } ^ { ( i ) } ( d , i ) + H _ { \mathrm { c y c l e } } ( d , r ) .
+$$
+
+82 The states of $d _ { \cdot , i }$ are mapped one-to-one to the states of $\Pi _ { i }$ . Let $\Pi _ { i } = \pi ^ { ( i ) } ( d _ { \cdot , i } )$ for all $1 \leq i \leq n$ .   
+83 The local score of the Hamiltonian is
+
+$$
+H _ { \mathrm { s c o r e } } ^ { ( i ) } ( d _ { \cdot , i } ) \equiv - \log S ^ { ( i ) } ( \pi ^ { ( i ) } ( d _ { \cdot , i } ) \mid \mathcal { D } ) + \log S ^ { ( i ) } ( \phi \mid \mathcal { D } ) ,
+$$
+
+84 for all $1 \leq i \leq n$ . The score function has a quadratization involving at most $\mathcal { O } ( n 2 ^ { \frac { n - 1 } { 2 } } )$ auxiliary   
+85 variables. O’Gorman et al. 2014 added the maximum parent set size constraint to the Hamiltonian.   
+86 In this case, the number of auxiliary variables is at most $\mathcal { O } ( n ( n - 1 ) ^ { \frac { m } { 2 } } )$ . The cycle constraint of the   
+87 Hamiltonian consists of the topological order constraint and the consistency constraint,
+
+$$
+H _ { \mathrm { c y c l e } } ( d , r ) \equiv \sum _ { 1 \leq i < j < k \leq n } \delta _ { 1 } R ( r _ { i , j } , r _ { j , k } , r _ { i , k } ) + \sum _ { 1 \leq i < j \leq n } \delta _ { 2 } ( d _ { i , j } r _ { i , j } + d _ { j , i } ( 1 - r _ { i , j } ) ) ,
+$$
+
+88 where $R ( r _ { 1 } , r _ { 2 } , r _ { 3 } ) = r _ { 1 } r _ { 2 } ( 1 - r _ { 3 } ) + ( 1 - r _ { 1 } ) ( 1 - r _ { 2 } ) r _ { 3 }$ for all $r _ { 1 } , r _ { 2 } , r _ { 3 } \in \mathbb { B }$ . When the penalty   
+89 coefficients $0 < \delta _ { 1 } , \delta _ { 2 } \in \mathbb { R }$ are sufficiently large, the DAG constraint is satisfied indirectly through   
+90 the relationship of the paths $^ d$ and the topological order $\pmb { r }$ . If it holds that
+
+$$
+\operatorname* { m a x } \{ 0 , \operatorname* { m a x } _ { \substack { 1 \leq j ^ { * } , i ^ { * } \leq n d _ { \cdot , j ^ { * } } \in \mathbb { B } ^ { n - 1 } } }  ( H _ { \mathrm { s c o r e } } ^ { ( i ^ { * } ) } ( d _ { \cdot , i ^ { * } } ^ { ( j ^ { * } , i ^ { * } ) } ) - H _ { \mathrm { s c o r e } } ^ { ( i ^ { * } ) } ( d _ { \cdot , i ^ { * } } ) ) \} < \delta _ { 1 } < \frac { \delta _ { 2 } } { n - 2 } ,
+$$
+
+91 then there is no cycle on the paths of the ground state, where ∗ ∗ ∗ ∗ ${ \pmb d } ^ { ( j ^ { \ast } , i ^ { \ast } ) } = ( ( d _ { j , i } ) _ { 1 \leq j \leq n , j \neq i } ^ { ( j ^ { \ast } , i ^ { \ast } ) } ) _ { i = 1 } ^ { n }$   
+92 $d _ { j , i } ^ { ( j ^ { * } , i ^ { * } ) } = 0$ if $( j , i ) = ( j ^ { * } , i ^ { * } )$ , $d _ { j , i } ^ { ( j ^ { * } , i ^ { * } ) } = d _ { j , i }$ otherwise. The computational cost to obtain the left   
+93 side of eq. (7) is at most $\mathcal { O } ( n ^ { m + 1 } )$ . In particular, at most $O ( n ^ { 2 } 2 ^ { n - 2 } )$ when $m = n - 1$ .
+
+# 94 3 Candidate Parent Set Decomposition
+
+Parent set identification is a major technique to narrow the search space of structure optimization, based on the relationship between parent sets and local scores under the DAG constraints [de Campos and Ji, 2011, Correia et al., 2020]. The collection of candidate parent sets of a random variable $X _ { i }$ is $\{ W \subseteq { \mathcal { X } } \setminus \{ X _ { i } \} \mid W ^ { \prime } \subset W \Rightarrow S ^ { ( i ) } ( W ^ { \prime } \mid { \mathcal { D } } ) < S ^ { ( i ) } ( W \mid { \mathcal { D } } ) \}$ . To reduce the required bits of the score component of the Hamiltonian, we propose an efficient conversion method with the parent set identification. We directly encode the candidate parent sets instead of using the paths $^ d$ .
+
+Moreover, we decompose the candidate parent sets $( W _ { h , i } ) _ { h = 0 } ^ { \lambda _ { i } }$ of each random variable into the form of Cartesian products as follows:
+
+1. Decompose $( W _ { h , i } ) _ { h = 0 } ^ { \lambda _ { i } }$ into $( W _ { h , i } \cap Z _ { i } ) _ { h = 0 } ^ { \lambda _ { i } } , ( W _ { h , i } \cap ( { \mathcal { X } } \setminus Z _ { i } ) ) _ { h = 0 } ^ { \lambda _ { i } } ,$   
+2. Remove duplicates in the elements of $( W _ { h , i } \cap Z _ { i } ) _ { h = 0 } ^ { \lambda _ { i } } , ( W _ { h , i } \cap ( { \mathcal { X } } \setminus Z _ { i } ) ) _ { h = 0 } ^ { \lambda _ { i } } ,$
+
+$$
+\because ( W _ { h , i } \cap Z _ { i } ) _ { h = 0 } ^ { \lambda _ { 1 , i } } , ( W _ { h , i } \cap ( \mathcal { X } \setminus Z _ { i } ) ) _ { h = 0 } ^ { \lambda _ { 2 , i } } \mathrm { ~ i n ~ } ( U _ { h , i } ) _ { h = 0 } ^ { \lambda _ { 1 , i } } , ( V _ { h , i } ) _ { h = 0 } ^ { \lambda _ { 2 , i } } ,
+$$
+
+where 106 $Z _ { i } \subseteq \cup _ { h = 0 } ^ { \lambda _ { i } } W _ { h , i } , W _ { 0 , i } = U _ { 0 , i } = V _ { 0 , i } = \phi , \lambda _ { i } , \lambda _ { 1 , i } , \lambda _ { 2 , i } \in \mathbb { N } \cup \{ 0 \}$ for all $1 \leq i \leq n$ . There 107 is a clear relationship,
+
+$$
+\begin{array} { r } { \{ W _ { 0 , i } , \cdots , W _ { \lambda _ { i } , i } \} \subseteq \{ U \cup V \mid ( U , V ) \in \{ U _ { 0 , i } , \cdots , U _ { \lambda _ { 1 , i } , i } \} \times \{ V _ { 0 , i } , \cdots , V _ { \lambda _ { 2 , i } , i } \} \} , } \end{array}
+$$
+
+108 for all $1 \leq i \leq n$ . Here, given that the Hamiltonian is a quadratic pseudo-Boolean function, we can represent the score against 109 fore, it is possible to encod110 $U _ { h , i } \cup V _ { h ^ { \prime } , i }$ by allocating ate parent sets $U _ { h , i } , V _ { h ^ { \prime } , i }$ to two bits on thamiltonian using $( U _ { h , i } ) _ { h = 0 } ^ { \lambda _ { 1 , i } } , ( V _ { h , i } ) _ { h = 0 } ^ { \lambda _ { 2 , i } }$ 111 The number of required bits of the score component of the Hamiltonian is ${ \textstyle \sum _ { i = 1 } ^ { n } } ( \lambda _ { 1 , i } + \lambda _ { 2 , i } )$ .
+
+112 Example 1. An example of the candidate parent sets in the form of Cartesian products as follows:
+
+$$
+\begin{array} { r l } & { \mathcal { X } = \{ X _ { 1 } , X _ { 2 } , X _ { 3 } , X _ { 4 } \} , \ Z _ { i } = \{ X _ { 1 } , X _ { 2 } \} , \ \lambda _ { i } = 5 , \ \lambda _ { 1 , i } = 2 , \ \lambda _ { 2 , i } = 1 } \\ & { ( W _ { h , i } ) _ { h = 0 } ^ { \lambda _ { i } } = ( \phi , \{ X _ { 1 } \} , \{ X _ { 1 } , X _ { 2 } \} , \{ X _ { 3 } , X _ { 4 } \} , \{ X _ { 1 } , X _ { 3 } , X _ { 4 } \} , \{ X _ { 1 } , X _ { 2 } , X _ { 3 } , X _ { 4 } \} ) , } \\ & { ( W _ { h , i } \cap Z _ { i } ) _ { h = 0 } ^ { \lambda _ { i } } = ( \phi , \{ X _ { 1 } \} , \{ X _ { 1 } , X _ { 2 } \} , \phi , \{ X _ { 1 } \} , \{ X _ { 1 } , X _ { 2 } \} ) , } \\ & { ( W _ { h , i } \cap ( \mathcal { X } \setminus Z _ { i } ) ) _ { h = 0 } ^ { \lambda _ { i } } = ( \phi , \phi , \phi , \{ X _ { 3 } , X _ { 4 } \} , \{ X _ { 3 } , X _ { 4 } \} , \{ X _ { 3 } , X _ { 4 } \} ) , } \\ & { ( U _ { h , i } ) _ { h = 0 } ^ { \lambda _ { 1 , i } } = ( \phi , \{ X _ { 1 } \} , \{ X _ { 1 } , X _ { 2 } \} ) , \ ( V _ { h , i } ) _ { h = 0 } ^ { \lambda _ { 2 , i } } = ( \phi , \{ X _ { 3 } , X _ { 4 } \} ) . } \end{array}
+$$
+
+We optimize 113 $Z _ { i } \subseteq \cup _ { h = 0 } ^ { \lambda _ { i } } W _ { h , i }$ to minimize $\lambda _ { 1 , i } + \lambda _ { 2 , i }$ . However, it is often infeasible to search all 114 elements of the power set $\mathcal { P } ( \cup _ { h = 0 } ^ { \lambda _ { i } } W _ { h , i } )$ . Therefore, we heuristically search 3 $Z _ { i }$ adding elements one by one, as algorithm 1. The computational cost is at most $1 \leq i \leq n$
+
+# Algorithm 1 Greedy Candidate Parent Set Decomposition
+
+1: Input: $( W _ { h , i } ) _ { h = 0 } ^ { \lambda _ { i } }$ Output: $Z$ Initialize: $\lambda  \lambda _ { i } , Z ^ { \prime }  \phi , Z  \phi$ .   
+2: for $d = 1$ to $| \cup _ { h = 0 } ^ { \lambda _ { i } } W _ { h , i } | - 1$ do   
+3: for $X$ in $\cup _ { h = 0 } ^ { \lambda _ { i } } W _ { h , i } \setminus Z$ do   
+4: if $\lambda _ { 1 , i } + \lambda _ { 2 , i } < \lambda$ for $Z _ { i } = Z \cup \{ X \}$ then $\lambda  \lambda _ { 1 , i } + \lambda _ { 2 , i } , Z ^ { \prime }  Z \cup \{ X \} .$ .   
+5: if $Z \neq Z ^ { \prime }$ then $Z  Z ^ { \prime }$ else break
+
+115
+
+116 Example 2. An example of the bit reduction flow of algorithm 1 is as follows:
+
+$$
+\begin{array} { r l } & { Z _ { i } = \phi , \lambda _ { 1 , i } = 0 , \lambda _ { 2 , i } = 5 : ( \phi ) \times ( \phi , \{ X _ { 1 } \} , \{ X _ { 1 } , X _ { 2 } \} , \{ X _ { 3 } , X _ { 4 } \} , \{ X _ { 1 } , X _ { 3 } , X _ { 4 } \} , \{ X _ { 1 } , X _ { 2 } , X _ { 3 } , X _ { 4 } \} , \{ X _ { 1 } , X _ { 3 } , X _ { 3 } \} , } \\ & { Z _ { i } = \{ X _ { 1 } \} , \lambda _ { 1 , i } = 1 , \lambda _ { 2 , i } = 3 : ( \phi , \{ X _ { 1 } \} ) \times ( \phi , \{ X _ { 2 } \} , \{ X _ { 3 } , X _ { 4 } \} , \{ X _ { 2 } , X _ { 3 } , X _ { 4 } \} ) , } \\ & { Z _ { i } = \{ X _ { 1 } , X _ { 2 } \} , \lambda _ { 1 , i } = 2 , \lambda _ { 2 , i } = 1 : ( \phi , \{ X _ { 1 } \} , \{ X _ { 1 } , X _ { 2 } \} ) \times ( \phi , \{ X _ { 3 } , X _ { 4 } \} ) . } \end{array}
+$$
+
+# 117 4 Efficient Conversion of Score-based Bayesian Network Structure Learning
+
+We make 118 $( U _ { h , i } ) _ { h = 0 } ^ { \lambda _ { 1 , i } } , ( V _ { h , i } ) _ { h = 0 } ^ { \lambda _ { 2 , i } }$ correspond to $( p _ { h , i } ) _ { h = 0 } ^ { \lambda _ { 1 , i } } , ( q _ { h , i } ) _ { h = 0 } ^ { \lambda _ { 2 , i } }$ one-to-one, where $p _ { h , i } , q _ { h ^ { \prime } , i } \in \mathbb { B }$ 119 for all $0 \leq h \leq \lambda _ { 1 , i } , 0 \leq h ^ { \prime } \leq \lambda _ { 2 , i } , 1 \leq i \leq n$ . To identify the parent sets, we use the one-to-one 120 correspondence constraint that $\begin{array} { r } { \sum _ { h = 0 } ^ { \lambda _ { 1 , i } } p _ { h , i } = \sum _ { h = 0 } ^ { \lambda _ { 2 , i } } q _ { h , i } = 1 } \end{array}$ for all $1 \leq i \leq n$ . The Hamiltonian 121 consists of the score component, the one-to-one correspondence constraint, and the cycle constraint,
+
+$$
+H _ { \mathrm { t o t a l } } ^ { * } ( p , q , r ) \equiv \sum _ { i = 1 } ^ { n } ( H _ { \mathrm { s c o r e } } ^ { * ( i ) } ( p . , i , q . , i ) + H _ { \mathrm { o n e } } ^ { * ( i ) } ( p . , i , q . , i ) ) + H _ { \mathrm { c y c l e } } ^ { * } ( p , q , r ) ,
+$$
+
+where 122 $\pmb { p } = ( ( p _ { h , i } ) _ { h = 0 } ^ { \lambda _ { 1 , i } } ) _ { i = 1 } ^ { n } , \pmb { q } = ( ( q _ { h , i } ) _ { h = 0 } ^ { \lambda _ { 2 , i } } ) _ { i = 1 } ^ { n }$ . Under the one-to correspondence constraint,   
+123 we can represent the paths among random variables indirectly using $\mathbf { \omega } _ { p , q }$   
+124 variables,
+
+$$
+d _ { j , i } ^ { * } \equiv \sum _ { 1 \leq h \leq \lambda _ { 1 , i } \atop \overline { { X } } _ { j } \in U _ { h , i } } p _ { h , i } + \sum _ { 1 \leq h \leq \lambda _ { 2 , i } \atop \overline { { X } } _ { j } \in V _ { h , i } } q _ { h , i } ,
+$$
+
+![](images/d4f7e8cc2ac82f681ab72206ecf688f4b23e1a397be97e5c0273bc55dfd11cd4.jpg)  
+Figure 1: An example of bit allocation for our conversion method. $n = 4 , \lambda _ { 1 , 1 } = 3 , \lambda _ { 2 , 1 } = 1 , \lambda _ { 1 , 2 } =$ 1 $\bar { \lambda } _ { 2 , 2 } = 0 , \lambda _ { 1 , 3 } = \bar { 1 } , \lambda _ { 2 , 3 } = 1 , \lambda _ { 1 , 4 } = 0 , \lambda _ { 2 , 4 } = 0 , U _ { 1 , 1 } = \{ 2 , 3 \} , U _ { 2 , 1 } = \{ 3 \} , U _ { 3 , 1 } = \{ 2 \} , V _ { 1 , 1 } = \{ 3 \} , U _ { 2 , 2 } = \{ 3 \} , U _ { 3 , 2 } = \{ 3 \} , U _ { 2 , 2 } = \{ 3 \} ,$ $\{ 4 \} , U _ { 1 , 2 } = \{ 3 \} , U _ { 1 , 3 } = \{ 1 \} , V _ { 1 , 3 } = \{ 4 \}$ . Circle : $\mathbf { \mu } _ { p , q }$ . Square $: \textbf {  { r } }$ . Red lines include in the score component of the Hamiltonian, a green line in the one-to-one correspondence constraint, and blue lines in the cycle constraint.
+
+125 for all $1 \leq j , i \leq n$ . Figure 1 is an example of bit allocation using our conversion method. The 126 number of bits required in our conversion method is $\begin{array} { r } { \sum _ { i = 1 } ^ { n } ( \lambda _ { 1 , i } + \lambda _ { 2 , i } ) + \binom { n } { 2 } } \end{array}$ . Note that we do not directly encode127 $p _ { 0 , i } , q _ { 0 , i }$ on the Hamiltonian.
+
+128 Score Component. The local score component of the Hamiltonian is
+
+$$
+H _ { \mathrm { s c o r r e } } ^ { * ( i ) } ( { \pmb p } _ { . , i } , { \pmb q } _ { . , i } ) \equiv \sum _ { h = 1 } ^ { \lambda _ { 1 , i } } s _ { 1 , h , i } p _ { h , i } + \sum _ { h = 1 } ^ { \lambda _ { 2 , i } } s _ { 2 , h , i } q _ { h , i } + \sum _ { h = 1 } ^ { \lambda _ { 1 , i } } \sum _ { h ^ { \prime } = 1 } ^ { \lambda _ { 2 , i } } t _ { h , h ^ { \prime } , i } p _ { h , i } q _ { h ^ { \prime } , i } ,
+$$
+
+129 for all $1 \leq i \leq n$ . We can get these coefficients by solving simultaneous equations under the   
+130 one-to-one correspondence constraint, $s _ { 1 , h , i } = \_ \log S ^ { ( i ) } ( U _ { h , i } \mid \mathcal { D } ) + \log S ^ { ( i ) } ( \phi \mid \mathcal { D } ) , s _ { 2 , h , i } =$   
+131 $\begin{array} { r } { - \log S ^ { ( i ) } ( V _ { h , i } \mid \mathcal D ) + \log S ^ { ( i ) } ( \phi \mid \mathcal D ) , t _ { h , h ^ { \prime } , i } = - \log S ^ { ( i ) } ( U _ { h , i } \cup V _ { h ^ { \prime } , i } \mid \mathcal D ) + \log S ^ { ( i ) } ( U _ { h , i } \mid \mathcal D ) + } \end{array}$   
+132 $\log S ^ { ( i ) } ( V _ { h ^ { \prime } , i } \mid \mathcal { D } ) - \log S ^ { ( i ) } ( \phi \mid \mathcal { D } )$ .
+
+133 One-to-One element from 134 $( U _ { h , i } ) _ { h = 0 } ^ { \lambda _ { 1 , i } } , ( V _ { h , i } ) _ { h = 0 } ^ { \lambda _ { 2 , i } }$ nstraint. We penalize the connection among bits to select each ,
+
+$$
+H _ { \mathrm { o n e } } ^ { * ( i ) } ( p . , . , q . , i ) \equiv \sum _ { 1 \leq h < h ^ { \prime } \leq \lambda _ { 1 , i } } \xi _ { 1 , i } p _ { h , i } p _ { h ^ { \prime } , i } + \sum _ { 1 \leq h < h ^ { \prime } \leq \lambda _ { 2 , i } } \xi _ { 2 , i } q _ { h , i } q _ { h ^ { \prime } , i } ,
+$$
+
+135 136 $1 \leq i \leq n$ penalty coefficient is induced indirectly $0 < \xi _ { 1 , i } , \xi _ { 2 , i } \in \mathbb { R }$ . If $\xi _ { 1 , i } , \xi _ { 2 , i }$ is sufficient large, $\begin{array} { r } { \sum _ { h = 0 } ^ { \lambda _ { 1 , i } } p _ { h , i } = \sum _ { h = 0 } ^ { \lambda _ { 2 , i } } q _ { h , i } = 1 } \end{array}$
+
+137 Cycle Constraint. Compared to eq. (6), the cycle constraint of the Hamiltonian is
+
+$$
+H _ { \mathrm { c y c l e } } ^ { * } ( p , q , r ) \equiv \sum _ { 1 \leq i < j < k \leq n } \delta _ { 1 } ^ { * } R ( r _ { i , j } , r _ { j , k } , r _ { i , k } ) + \sum _ { 1 \leq i < j \leq n } \delta _ { 2 } ^ { * } ( d _ { i , j } ^ { * } r _ { i , j } + d _ { j , i } ^ { * } ( 1 - r _ { i , j } ) ) ,
+$$
+
+where the penalty coefficients 138 $0 < \delta _ { 1 } ^ { * } , \delta _ { 2 } ^ { * } \in \mathbb { R }$ . By setting $\delta _ { 1 } ^ { * } , \delta _ { 2 } ^ { * }$ appropriately, we can prevent the 139 cycle from occurring.
+
+141 We demonstrate the sufficient lower bounds of penalty coefficients. The basic idea is that we find the   
+142 range of penalty coefficients so that the change in return value of the Hamiltonian is negative when   
+143 the input state changes to the state we desire to induce.   
+144 One-to-One Correspondence Constraint. We consider to decrease the value of $\scriptstyle \sum _ { h = 1 } ^ { \lambda _ { 1 , i ^ { * } } } p _ { h , i ^ { * } }$ by   
+145 146 $\begin{array} { r } { p _ { h ^ { * } , i ^ { * } } = 1 , \sum _ { h = 1 } ^ { \lambda _ { 1 , i ^ { * } } } p _ { h , i ^ { * } } > 1 } \end{array}$ , e $H _ { \mathrm { t o t a l } } ^ { * } ( p , q , r ) -$   
+$\begin{array} { r } { H _ { \mathrm { t o t a l } } ^ { * } ( p ^ { ( h ^ { * } , i ^ { * } ) } , q , r ) \geq \xi _ { 1 , i ^ { * } } + s _ { 1 , h ^ { * } , i ^ { * } } + \sum _ { h = 1 } ^ { \lambda _ { 2 , i } } t _ { h ^ { * } , h , i ^ { * } } q _ { h , i ^ { * } } . } \end{array}$ $\pmb { p } ^ { ( h ^ { * } , i ^ { * } ) } = ( ( p _ { h , i } ^ { ( h ^ { * } , i ^ { * } ) } ) _ { h = 0 } ^ { \lambda _ { 1 , i } } ) _ { i = 1 } ^ { n }$   
+147 and p(h∗,i∗)h,i = 0 if (h, i) = (h∗, i∗), p(h∗,h,i otherwise. Considering the case where $\pmb { p }$ and $\pmb q$   
+148 are swapped in the above, if $\xi _ { 1 , i } , \xi _ { 2 , i }$ satisfy that
+
+$$
+\begin{array} { r l r } & { } & { \displaystyle \operatorname* { m a x } _ { 0 \le h \le \lambda _ { 1 , i } } \bigl ( - s _ { 1 , h , i } - \sum _ { h ^ { \prime } = 1 } ^ { \lambda _ { 2 , i } } \operatorname* { m i n } \bigl \{ 0 , t _ { h , h ^ { \prime } , i } \bigr \} \bigr ) \bigr ) < \xi _ { 1 , i } , } \\ & { } & { \displaystyle \operatorname* { m a x } _ { 0 \le h \le \lambda _ { 2 , i } } \bigl ( - s _ { 2 , h , i } - \sum _ { h ^ { \prime } = 1 } ^ { \lambda _ { 1 , i } } \operatorname* { m i n } \bigl \{ 0 , t _ { h ^ { \prime } , h , i } \bigr \} \bigr ) \bigr ) < \xi _ { 2 , i } , } \end{array}
+$$
+
+149 for all $1 \leq i \leq n$ , then the grand state does not violate the one-to-one correspondence constraint.   
+150 The computational cost to obtain the left side of eq. (14) and eq. (15) is at most $\mathcal { O } ( \lambda _ { 1 , i } \lambda _ { 2 , i } )$ for all   
+151 $1 \leq i \leq n$ .   
+152 Cycle Constraint. We consider four patterns of $( r _ { i ^ { * } , j ^ { * } } , d _ { j ^ { * } , i ^ { * } } ^ { * } , d _ { i ^ { * } , j ^ { * } } ^ { * } )$ violating the consistency   
+153 constraint. It is assumed that $X _ { j ^ { * } } ~ \in ~ U _ { h ^ { * } , i ^ { * } } , X _ { j ^ { * } } ~ \notin ~ U _ { h ^ { * * } , i ^ { * } } ~ \subset ~ U _ { h ^ { * } , i ^ { * } } , p _ { h ^ { * } , i ^ { * } } ~ = ~ 1 , p _ { h ^ { * * } , i ^ { * } } ~ = ~ 0$ .   
+154 155 In thewhere $r ^ { ( i ^ { * } , j ^ { * } ) } = ( r _ { i , j } ^ { ( i ^ { * } , j ^ { * } ) } ) _ { 1 \leq i < j \leq n }$ $( 0 , 1 , 0 )$ t , $H _ { \mathrm { t o t a l } } ^ { * } ( p , q , r ) - H _ { \mathrm { t o t a l } } ^ { * } ( p , q , r ^ { ( i ^ { * } , j ^ { * } ) } ) \geq \delta _ { 2 } ^ { * } - ( n - 2 ) \delta _ { 1 } ^ { * }$ $r _ { i , j } ^ { ( i ^ { * } , j ^ { * } ) } = 1 - r _ { i , j }$ $( i , j ) = ( i ^ { * } , j ^ { * } ) , r _ { i , j } ^ { ( i ^ { * } , j ^ { * } ) } = r _ { i , j }$   
+156 otherwise. Similarly, it is possible to consider the case of $( 1 , 0 , 1 )$ . In the case of $( 0 , 1 , 1 )$ ,   
+157 it holds that $\begin{array} { r } { H _ { \mathrm { t o t a l } } ^ { * } ( p , q , r ) - H _ { \mathrm { t o t a l } } ^ { * } ( p ^ { ( h ^ { * } , h ^ { * * } , i ^ { * } ) } , q , r ) \ge \delta _ { 2 } ^ { * } + s _ { 1 , h ^ { * } , i ^ { * } } + \sum _ { h = 1 } ^ { \lambda _ { 2 , i } } t _ { h ^ { * } , h , i ^ { * } } q _ { h , i ^ { * } } - \frac { 1 - \lambda _ { 1 } } { \lambda _ { 2 } } | \nabla p _ { h } ( q _ { h } ^ { * } , h ^ { * } , i ^ { * } ) | _ { \mathbb { H } } ( q _ { h } ^ { * } , h ^ { * } , i ^ { * } ) , } \end{array}$   
+158 $\begin{array} { r } { s _ { 1 , h ^ { * * } , i ^ { * } } - \sum _ { h = 1 } ^ { \lambda _ { 2 , i } } t _ { h ^ { * * } , h , i ^ { * } } q _ { h , i ^ { * } } } \end{array}$ , where $\pmb { p } ^ { ( h ^ { * } , h ^ { * * } , i ^ { * } ) } = ( ( p _ { h , i } ^ { ( h ^ { * } , h ^ { * * } , i ^ { * } ) } ) _ { h = 0 } ^ { \lambda _ { 1 , i } } ) _ { i = 1 } ^ { n }$ h=, and $p _ { h , i } ^ { ( h ^ { * } , h ^ { * * } , i ^ { * } ) } = 0$   
+159 if $( h , i ) \ = \ ( h ^ { * } , i ^ { * } ) , p _ { h , i } ^ { ( h ^ { * } , h ^ { * * } , i ^ { * } ) } \ = \ 1$ p(h∗,h∗∗,i∗)h,i = 1 if (h, i) = (h∗∗, i∗), p(h∗,h,i $p _ { h , i } ^ { ( h ^ { * } , h ^ { * * } , i ^ { * } ) } = p _ { h , i }$ otherwise. Sim  
+160 ilarly, it is possible to consider the case of $( 1 , 1 , 1 )$ . These results suggest the relationship of   
+161 $\delta _ { 1 } ^ { * } , \delta _ { 2 } ^ { * }$ to induce the consistency constraint. Here, based on theorem 1, we consider a strategy   
+162 to repeat picking up one element from $\mathbfit { \Delta } \mathbf { r }$ and switching its value until $H _ { \mathrm { t r a n s } } ( r ) = 0$ . It is as  
+163 164 sumed that $\begin{array} { r } { T _ { \mathrm { t o t a l } } ^ { * } \big ( p ^ { ( h ^ { * } , h ^ { * * } , i ^ { * } ) } , q , r ^ { ( i ^ { * } , j ^ { * } ) } \big ) \geq \delta _ { 1 } ^ { * } + s _ { 1 , h ^ { * } , i ^ { * } } + \sum _ { h = 1 } ^ { \lambda _ { 2 , i } } t _ { h ^ { * } , h , i ^ { * } } q _ { h , i ^ { * } } - s _ { 1 , h ^ { * * } , i ^ { * } } - \sum _ { h = 1 } ^ { \lambda _ { 2 , i } } t _ { h ^ { * * } , h , i ^ { * } } q _ { h , i ^ { * } } . } \end{array}$ $H _ { \mathrm { t r a n s } } ( \mathbf { \bar { r } } ) > H _ { \mathrm { t r a n s } } ( { r ^ { ( i ^ { * } , j ^ { * } ) } } )$ . In the case of $( 1 , 1 , 0 )$ , it holds that $H _ { \mathrm { t o t a l } } ^ { * } ( p , q , r ) \sim$   
+165 Similarly, it is possible to consider the case of $( 0 , 0 , 1 )$ . In the case of $( 1 , 0 , 0 )$ or $( 0 , 0 , 0 )$ , it holds   
+166 that $\bar { H _ { \mathrm { t o t a l } } ^ { * } } ( p , \bar { q } , r ) - \bar { H _ { \mathrm { t o t a l } } ^ { * } } ( p , q , r ^ { ( i ^ { * } , j ^ { * } ) } ) \geq \delta _ { 1 } ^ { * }$ . These results suggest the lower bound of ${ { \delta } _ { 1 } ^ { * } }$ to   
+167 induce the topological order constraint. Considering the case where $\pmb { p }$ and $\pmb q$ are swapped in the   
+168 above, if $\delta _ { 1 } ^ { * } , \delta _ { 2 } ^ { * }$ satisfy that
+
+$$
+\begin{array} { c } { \displaystyle \operatorname* { m a x } _ { 1 \leq i \leq n } \operatorname* { m a x } \{ \eta _ { 1 , i } , \eta _ { 2 , i } \} < \delta _ { 1 } ^ { * } < \displaystyle \frac { \delta _ { 2 } ^ { * } } { n - 2 } , } \\ { \displaystyle \operatorname* { m a x } _ { 1 \leq j \leq n } \displaystyle \operatorname* { m a x } _ { 1 \leq i \leq 1 _ { 1 , i } } \operatorname* { m a x } _ { 0 \leq h ^ { \prime } \leq \lambda _ { 1 , i } } \operatorname* { m a x } _ { 0 \leq h ^ { \prime } \leq \lambda _ { 2 , i } } ( - s _ { 1 , h , i } - t _ { h , h ^ { \prime \prime } , i } + s _ { 1 , h ^ { \prime } , i } + t _ { h ^ { \prime } , h ^ { \prime \prime } , i } ) , } \\ { \displaystyle \eta _ { 1 , i } \equiv \displaystyle \operatorname* { m a x } _ { 1 \leq j \leq n } \displaystyle \frac { \operatorname* { m a x } _ { i } } { X _ { j } \in U _ { h , i } } \operatorname* { m a x } _ { X _ { j } \in U _ { h , i } } \operatorname* { m a x } _ { 0 \leq h ^ { \prime \prime } \leq \lambda _ { 1 , i } } ( - s _ { 2 , h , i } - t _ { h ^ { \prime \prime } , h , i } + s _ { 2 , h ^ { \prime } , i } + t _ { h ^ { \prime \prime } , h ^ { \prime \prime } , i } ) , } \\ { \displaystyle \eta _ { 2 , i } \equiv \displaystyle \operatorname* { m a x } _ { 1 \leq j \leq n } \displaystyle \operatorname* { m a x } _ { 0 \leq h ^ { \prime } \leq \lambda _ { 2 , i } } \operatorname* { m a x } _ { 0 \leq h ^ { \prime } \leq \lambda _ { 2 , i } } ( - s _ { 2 , h , i } - t _ { h ^ { \prime \prime } , h , i } + s _ { 2 , h ^ { \prime } , i } + t _ { h ^ { \prime \prime } , h ^ { \prime } , i } ) , } \\ { \displaystyle \sum _ { k \geq \ell \leq n } \displaystyle \sum _ { X _ { j } \in V _ { h , i } } \sum _ { j \in V _ { h ^ { \prime } } , i \subset V _ { h , i } } ( \operatorname* { m a x } _ { 0 \leq h ^ { \prime \prime } \leq \lambda _ { 1 , i } } ( - s _ { 2 , h , i } - t _ { h ^ { \prime \prime } , h , i } + s _ { 2 , h ^ { \prime } , i } + t _ { h ^ { \prime \prime } , h ^ { \prime \prime } , i } ) , } \end{array}
+$$
+
+169 for $n \geq 3$ , then the grand state does not violate the cycle constraint under the one-to-one cor  
+170 respondence constraint. The computational cost to obtain the left side of eq. (16) is at most   
+171 $\begin{array} { r l } {  { \mathcal { O } ( \sum _ { i = 1 } ^ { n } n \lambda _ { 1 , i } \lambda _ { 2 , i } ( \lambda _ { 1 , i } + \lambda _ { 2 , i } ) ) } \quad } & { { } } \end{array}$ .   
+172 Theorem 1. If it holds that $\begin{array} { r } { H _ { \mathrm { t r a n s } } ( { \pmb r } ) \equiv \sum _ { 1 \leq i < j < k \leq n } R ( r _ { i , j } , r _ { j , k } , r _ { i , k } ) > 0 } \end{array}$ , then there exists   
+173 at least one index pair $1 \leq i ^ { * } < j ^ { * } \leq n$ which satisfy $H _ { \mathrm { t r a n s } } ( r ) > H _ { \mathrm { t r a n s } } ( r ^ { ( i ^ { * } , j ^ { * } ) } )$ , where   
+174 r(i∗,j∗) = (r(i∗,i,j $R ( r _ { 1 } , r _ { 2 } , r _ { 3 } ) = r _ { 1 } r _ { 2 } ( 1 - r _ { 3 } ) + ( 1 - r _ { 1 } ) ( 1 - r _ { 2 } ) r _ { 3 }$ $r ^ { ( i ^ { * } , j ^ { * } ) } = ( r _ { i , j } ^ { ( i ^ { * } , j ^ { * } ) } ) _ { 1 \leq i < j \leq n }$ $r _ { i , j } ^ { ( i ^ { * } , j ^ { * } ) } = 1 - r _ { i , j } \ i f ( i , j ) = ( i ^ { * } , j ^ { * } )$ $r _ { 1 } , r _ { 2 } , r _ { 3 } \in \mathbb { B }$ ,, $r _ { i , j } ^ { ( i ^ { * } , j ^ { * } ) } = r _ { i , j }$ $r = ( r _ { i , j } ) _ { 1 \leq i < j \leq n } \in \mathbb { B } ^ { \binom { n } { 2 } }$   
+176 Proof. It does not lose the generality by considering the case of $( r _ { 1 , 2 } , r _ { 2 , 3 } , r _ { 1 , 3 } ) = ( 1 , 1 , 0 )$ . Here, it   
+177 holds that $R ( r _ { 1 , 2 } , r _ { 2 , 3 } , r _ { 1 , 3 } ) - R ( 1 - r _ { 1 , 2 } , r _ { 2 , 3 } , r _ { 1 , 3 } ) + R ( r _ { 1 , 2 } , r _ { 2 , 3 } , r _ { 1 , 3 } ) - R ( r _ { 1 , 2 } , 1 - r _ { 2 , 3 } , r _ { 1 , 3 } ) + R ( r _ { 1 , 2 } , 1 - r _ { 2 , 3 } , r _ { 1 , 3 } )$   
+178 $R ( r _ { 1 , 2 } , r _ { 2 , 3 } , r _ { 1 , 3 } ) - R ( r _ { 1 , 2 } , r _ { 2 , 3 } , 1 - r _ { 1 , 3 } ) = 3 .$ . Additionally, it holds that $R ( r _ { 1 , 2 } , r _ { 2 , i } , r _ { 1 , i } ) - R ( 1 -$   
+179 $r _ { 1 , 2 } , r _ { 2 , i } , r _ { 1 , i } ) + R ( r _ { 2 , 3 } , r _ { 3 , i } , r _ { 2 , i } ) - R ( 1 - r _ { 2 , 3 } , r _ { 3 , i } )$ ${ } _ { 3 } , r _ { 3 , i } , r _ { 2 , i } ) + R ( r _ { 1 , 3 } , r _ { 3 , i } , r _ { 1 , i } ) - R ( 1 - r _ { 1 , 3 } , r _ { 3 , i } , r _ { 1 } )$ ,i) =   
+180 0 for all $3 < i$ . Therefore, it holds that $H _ { \mathrm { t r a n s } } ( \pmb { r } ) - H _ { \mathrm { t r a n s } } ( \pmb { r } ^ { ( 1 , 2 ) } ) + H _ { \mathrm { t r a n s } } ( \pmb { r } ) - H _ { \mathrm { t r a n s } } ( \pmb { r } ^ { ( 2 , 3 ) } ) +$   
+181 $H _ { \mathrm { t r a n s } } ( \pmb { r } ) - H _ { \mathrm { t r a n s } } ( \pmb { r } ^ { ( 1 , 3 ) } ) = 3 .$ . From this result, it holds that $H _ { \mathrm { t r a n s } } ( \pmb { r } ) - H _ { \mathrm { t r a n s } } ( \pmb { r } ^ { ( i ^ { * } , j ^ { * } ) } ) > 0$ for   
+182 at least one index pair $( i ^ { * } , j ^ { * } ) \in \{ ( 1 , 2 ) , ( 2 , 3 ) , ( 1 , 3 ) \}$ . □
+
+Table 1: The benchmark networks from Bayesian network repository.   
+Algorithm 2 Greedy Candidate Parent Set Identification   
+
+<table><tr><td rowspan="2">Name</td><td rowspan="2">n</td><td rowspan="2">m</td><td rowspan="2">∑=1 |IIil n</td><td rowspan="2">∑=1 βi( -1)</td><td colspan="3">Ωi=1X n *</td></tr><tr><td>N=100</td><td>N= 1000</td><td>N = 10000</td></tr><tr><td>insurance</td><td>27</td><td>3</td><td>52</td><td>984</td><td>353</td><td>883</td><td>4036</td></tr><tr><td>water</td><td>32</td><td>5</td><td>66</td><td>10083</td><td>165</td><td>216</td><td>735</td></tr><tr><td>alarm</td><td>37</td><td>4</td><td>46</td><td>509</td><td>1829</td><td>2272</td><td>9081</td></tr><tr><td>barley</td><td>48</td><td>4</td><td>84</td><td>114005</td><td>181</td><td>310</td><td>1552</td></tr><tr><td>hailfinder</td><td>56</td><td>4</td><td>66</td><td>2656</td><td>144</td><td>692</td><td>4277</td></tr><tr><td>hepar2</td><td>70</td><td>6</td><td>123</td><td>1453</td><td>4837</td><td>665</td><td>4782</td></tr></table>
+
+The average for 10 simulated datasets.
+
+# 183 6 Experimental Results
+
+To validate the performance of our approach, we use 10 simulated datasets for each instance size $N = 1 0 0 , 1 0 0 0 , 1 0 0 0 0$ and each benchmark network. The benchmark networks are discrete networks from Bayesian network repository 1. The score function is the BDeu score with $\alpha = 1$ . It is often infeasible to identify exact candidate parent sets by searching the power set $\mathcal { P } ( \mathcal { X } \backslash \{ X _ { i } \} )$ in a realistic timeframe. We use the candidate parent sets from algorithm 2. Note that the candidate parent sets depend on the heuristic search algorithms, but we do not focus on their performance in this study. Table 1 displays the information of benchmark networks. The code to replicate each experiment in this paper is available 2.
+
+1: Input: $\mathcal { D } , i , m$ Output: $\mathcal { L }$ Initialize: ${ \mathcal { L } } \gets \{ \phi \} , { \mathcal { L } } ^ { \prime } \gets \{ \phi \} , { \mathcal { L } } ^ { \prime \prime } \gets \phi$   
+2: for $d = 1$ to $m$ do   
+3: for $W$ in $\mathcal { L } ^ { \prime }$ do   
+4: for $X$ in $\chi \setminus \{ X _ { i } \} \setminus W$ do   
+5: if $S _ { i } ( W ^ { \prime } \mid \mathcal { D } ) < S _ { i } ( W \cup \{ X \} \mid \mathcal { D } )$ for all $W ^ { \prime } \subset W \cup \{ X \} , W ^ { \prime } \in { \mathcal { L } }$ then   
+6: ${ \mathcal { L } } ^ { \prime \prime } \gets { \mathcal { L } } ^ { \prime \prime } \cup \{ W \cup \{ X \} \}$ .   
+7: if ${ \mathcal { L } } ^ { \prime \prime } \neq \phi$ then $\mathcal { L } \gets \mathcal { L } \cup \mathcal { L } ^ { \prime \prime } , \mathcal { L } ^ { \prime }  \mathcal { L } ^ { \prime \prime } , \mathcal { L } ^ { \prime \prime }  \phi$ else break   
+8: for $W$ in $\mathcal { L }$ do   
+9: if there exist $W ^ { \prime } \subset W$ that satisfies $S _ { i } ( W \mid \mathcal { D } ) \le S _ { i } ( W ^ { \prime } \mid \mathcal { D } )$ then ${ \mathcal { L } } \gets { \mathcal { L } } \setminus \{ W \}$ .
+
+# 192 6.1 Number of Required Bits for Score Component
+
+In comparison to the existing method [O’Gorman et al., 2014], we reduce the number of required bits for the score component by encoding the candidate parent sets directly. While $\textstyle \sum _ { i = 1 } ^ { n } \lambda _ { i }$ candidate parent sets is encoded in our approach, $n ( n - 1 )$ paths plus at most $O ( n ( n - 1 ) ^ { \frac { m } { 2 } } )$ auxiliary variables for $m > 2$ in the existing method. The left side of table 2 shows the reduction rate of the number of required bits for the score component. Moreover, we reduce the number of required bits for the score component to ${ \textstyle \sum _ { i = 1 } ^ { n } } ( \lambda _ { 1 , i } + \lambda _ { 2 , i } )$ by decomposing the candidate parent sets in the form of Cartesian products. The right side of table 2 shows that algorithm 1 reduces the number of required bits for the score component although there is some variation among the networks.
+
+Table 2: The reduction rate of the number of required bits for score component.   
+
+<table><tr><td rowspan="2">Name</td><td colspan="3">£ λi/n(n-1)²</td><td colspan="3">Σ=1 （1,i+λ2,i）/∑=1 1</td></tr><tr><td>N=100</td><td>N=1000</td><td>N = 10000</td><td>N = 100</td><td>N= 1000</td><td>N = 10000</td></tr><tr><td>insurance</td><td>0.09873</td><td>0.24677</td><td>1.12742</td><td>0.61367</td><td>0.47285</td><td>0.32476</td></tr><tr><td>Water</td><td>0.00097</td><td>0.00126</td><td>0.00429</td><td>0.72680</td><td>0.70588</td><td>0.44014</td></tr><tr><td>alarm</td><td>0.03814</td><td>0.04738</td><td>0.18938</td><td>0.45332</td><td>0.35537</td><td>0.21617</td></tr><tr><td>barley</td><td>0.00171</td><td>0.00292</td><td>0.01464</td><td>0.76717</td><td>0.75538</td><td>0.54149</td></tr><tr><td>hailfinder</td><td>0.00085</td><td>0.00409</td><td>0.02525</td><td>0.82773</td><td>0.60178</td><td>0.33365</td></tr><tr><td>hepar2</td><td>0.00021</td><td>0.00003</td><td>0.00021</td><td>0.49694</td><td>0.63346</td><td>0.31284</td></tr></table>
+
+\* The average ratio for 10 simulated datasets.
+
+Table 3: The number of required bits for fully coupled and nearest neighbor annealing processors.   
+
+<table><tr><td rowspan="2">Name</td><td colspan="3">∑i=1(1,i+ 入2,i）+(2） *</td><td colspan="3">∑=1(入1,i + λ2,i)(入1,i +λ2,i + 1) + (2)</td></tr><tr><td>N= 100</td><td>N =1000</td><td>N = 10000</td><td>N= 100</td><td>N= 1000</td><td>N = 10000</td></tr><tr><td>insurance</td><td>566</td><td>767</td><td>1661</td><td>3375</td><td>9023</td><td>85482</td></tr><tr><td>water</td><td>613</td><td>648</td><td>820</td><td>1434</td><td>1720</td><td>5881</td></tr><tr><td>alarm</td><td>1489</td><td>1472</td><td>2628</td><td>36761</td><td>27985</td><td>169004</td></tr><tr><td>barley</td><td>1247</td><td>1362</td><td>1968</td><td>6758</td><td>3446</td><td>24796</td></tr><tr><td>hailfinder</td><td>1659</td><td>1957</td><td>2967</td><td>2212</td><td>7084</td><td>80578</td></tr><tr><td>hepar2</td><td>4777</td><td>2836</td><td>3910</td><td>449916</td><td>9164</td><td>136939</td></tr></table>
+
+\* The average ratio for 10 simulated datasets.
+
+# 6.2 Selection of Annealing Processor
+
+From the following discussion, the Fujitsu digital annealer is suitable for our approach from the viewpoint of bit capacity.
+
+Fully Connected Type. To the best of our knowledge, the bit capacity of the Fujitsu digital annealer is the largest in fully coupled annealing processors. The second generation Fujitsu digital annealer can deal with problems on a scale of 8192 bits [Matsubara et al., 2020]. The left side of table 3 shows that it is possible to encode all the logical conversion results for benchmark networks to the circuit of the digital annealer within bit capacity.
+
+Nearest Neighbor Type. The number of additional bits required for minor embedding depends on the design of the hardware graphs. Oku et al. 2019 proposed a heuristic minor embedding algorithm for the Hitachi CMOS annealing machine [Masanao et al., 2010]. Using this algorithm, the number of required physical spins when embedding a fully connected graph is $I ^ { 2 } + I$ for $I$ variables. The conversion method proposed in this study has $n$ local fully connected graphs on $\mathbf { \Delta } _ { p , q }$ . Therefore, the number of required physical spins must be at least $\begin{array} { r } { \sum _ { i = 1 } ^ { n } ( \lambda _ { 1 , i } + \lambda _ { 2 , i } ) ( \lambda _ { 1 , i } + \lambda _ { 2 , i } + 1 ) + \binom { n } { 2 } } \end{array}$ . From the right side of table 3, it is currently infeasible to encode logical conversion results for at least some networks to the circuit of CMOS annealing machine within its 102400 nodes [Sugie et al., 2021]. As far as we know, the bit capacity of the Hitachi CMOS annealing machine is the largest in nearest neighbor annealing processors.
+
+# 6.3 Score Maximization
+
+We demonstrate the performance of Fujitsu digital annealer for score-based Bayesian network structure learning using the conversion results of $N = 1 0 0 0 0$ simulated datasets. The running time for each simulated dataset is 6000 [s].
+
+![](images/4b44701b9cc855182e35704f11ec0fbc3d89db610c0991e089d4b455ff631577.jpg)  
+Figure 2: Results of score maximization by the baseline algorithms. For each simulated dataset and each baseline algorithm, we normalized $\begin{array} { r } { \sum _ { i = 1 } ^ { \bar { n } } ( \log S ^ { ( i ) } ( \Pi _ { i } \vert \mathcal { \bar { D } } ) - \log S ^ { ( i ) } ( \phi \vert \mathcal { D } ) ) } \end{array}$ by dividing it by the corresponding value of the Fujitsu digital annealer. In this experiment, we used the second-generation Fujitsu digital annealer. SA : simulated annealing, OBS : ordering-based search, ASOBS : acyclic selection ordering-based search.
+
+Baselines. We compare the results obtained by the digital annealer with those of three heuristic algorithms. One algorithm is the simulated annealing algorithm [Heckerman et al., 1995b] with a QUBO same as the one encoded into the digital annealer. Other algorithms are the ordering space search algorithms, i.e., ordering-based search and acyclic selection ordering-based search. For a fair comparison, the running time of the simulated annealing algorithm for each simulated dataset is 6000 [s] and that of the ordering space search algorithms is 6000 [s] plus the running time of algorithm 1. The computing environment is Microsoft Windows 10 Pro, 3.6 GHz Intel Core i9 processor, and 64 GB memory.
+
+Result. Figure 2 shows that the digital annealer is better than all the baselines for all the simulated datasets from all the benchmark networks.
+
+# 7 Conclusion
+
+We proposed a novel approach of converting a score-based Bayesian network structure learning into QUBO. The essence of this approach lies in reducing the number of required bits through the advanced identification of candidate parent sets and their representation as Cartesian products. The Fujitsu digital annealer with our conversion method improved the BDeu score for 27 to 70 variables benchmark networks over existing methods. The bit capacity limitation of annealing processor is being relaxed rapidly 3. Though our approach is still a disadvantage for larger-scale networks, we expect that our proposed algorithms will be effectively applied to larger-scale score-based Bayesian network structure learning in the near future.
+
+Potential Negative Societal Impacts. The development of annealing processor technology could have an impact on various industry fields. However, the number of companies that have commercialized the API usage of annealing processors is still small. Therefore, there is a concern that the market of annealing processors will not work well and the disparities among stakeholders will be widen. Researchers are required to properly evaluate the value of technology and communicate it to the business side.
+
+248 References   
+249 Judea Pearl, editor. Probabilistic Reasoning in Intelligent Systems: Networks of Plausible Inference. Morgan Kaufmann, 1988. Gregory F. Cooper and Edward Herskovits. A bayesian method for the induction of probabilistic networks from data. Journal of Machine Learning, 9(4), 1992. Robert G. Cowell. Conditions under which conditional independence and scoring methods lead to identical selection of bayesian network models. In Jack Breese and Daphne Koller, editors, Proceedings of the 17th Conference on Uncertainty in Artificial Intelligence, pages 91–97. Morgan Kaufmann Publishers, 2001. David M. Chickering, David Heckerman, and Christopher Meek. Large-sample learning of bayesian networks is np-hard. Journal of Machine Learning Research, 20:1287–1330, 2004. Marc Teyssier and Daphne Koller. Ordering-based search: A simple and effective algorithm for learning bayesian networks. In Proceedings of the 21th Conference on Uncertainty in Artificial Intelligence, pages 584–590, 2005. Mauro Scanagatta, Cassio Polpo de Campos, Giorgio Corani, and Marco Zaffalon. Learning bayesian networks with thousands of variables. In Proceedings of the 28th International Conference on Neural Information Processing Systems, pages 1864–1872, 2015. Hidenori Gyoten, Masayuki Hiromoto, and Takashi Sato. Area efficient annealing processor for ising model without random number generator. IEICE Transactions on Information and Systems, E101.D(2):314–323, 2018. Kasho Yamamoto. Research on Annealing Processors for Large-Scale Combinatorial Optimization Problems. PhD thesis, Graduate School of Information Science and Technology Hokkaido University, 2020. Vicky Choi. Minor-embedding in adiabatic quantum computation: I. the parameter setting problem. Quantum Information Processing, 7:193–209, 2008. Vicky Choi. Minor-embedding in adiabatic quantum computation: Ii. minor-universal graph design. Quantum Information Processing, 10:343–352, 2010. Bryan A. O’Gorman, Alejandro Perdomo-Ortiz, Ryan Babbush, Alan Aspuru-Guzik, and Vadim Smelyanskiy. Bayesian network structure learning using quantum annealing. The European Physical Journal Special Topics, 225(1), 2014.   
+276 Endre Boros and Aritanan Gruber. On quadratization of pseudo-boolean functions. CoRR, abs/1404.6538, 2014.   
+277 Maliheh Aramon, Gili Rosenberg, Elisabetta Valiante, Toshiyuki Miyazawa, Hirotaka Tamura, and Helmut G. Katzgraber. Physics-inspired optimization for quadratic unconstrained problems using a digital annealer. Frontiers in Physics, 7(48), 2019. Wray Buntine. Theory refinement of bayesian networks. In Proceedings of the 7th Conference on Uncertainty in Artificial Intelligence, pages 52–60, 1991. David Heckerman, Dan Geiger, and David M. Chickering. Learning bayesian networks: The combination of knowledge and statistical data. Journal of Machine Learning, 20(3):197–243, 1995a.   
+284 Martin Anthony, Endre Boros, Yves Crama, and Aritanan Gruber. Quadratic reformulations of nonlinear binary optimization problems. Mathematical Programming, 162(1):115–144, 2016. Endre Boros and Peter L. Hamme. Pseudo-boolean optimization. Journal of Discrete Applied Mathematics, 123: 155–225, 2002. Cassio P. de Campos and Qiang Ji. Efficient structure learning of bayesian networks using constraints. Journal of Machine Learning Research, 12:663–689, 2011. Alvaro H. C. Correia, James Cussens, and Cassio de Campos. On pruning for score-based bayesian network structure learning. Journal of Machine Learning Research, 108:2709–2718, 2020. Satoshi Matsubara, Motomu Takatsu, Toshiyuki Miyazawa, Takayuki Shibasaki, Yasuhiro Watanabe, Kazuya Takemoto, and Hirotaka Tamura. Digital annealer for high-speed solving of combinatorial optimization problems and its applications. In Proceedings of the 25th Asia and South Pacific Design Automation Conference, pages 667–672, 2020.   
+296 David Eppstein. Finding large clique minors is hard. Graph Algorithms and Applications, 13(2):197–204, 2009.   
+Daisuke Oku, Kotaro Terada, Masato Hayashi, Masanao Yamaoka, Shu Tanaka, and Nozomu Togawa. A fully-connected ising model embedding method and its evaluation for cmos annealing machines. IEICE Transactions on Information and Systems, E102-D(9):1696–1706, 2019.   
+Yamaoka Masanao, Yoshimura Chihiro, Hayashi Masato, Okuyama Takuya, Aoki Hidetaka, and Mizuno Hiroyuki. A 20k-spin ising chip to solve combinatorial optimization problems with cmos annealing. IEEE Journal of Solid-State Circuits, 51(1), 2010.   
+Yuya Sugie, Yuki Yoshida, Normann Mertig, Takashi Takemoto, Hiroshi Teramoto, Atsuyoshi Nakamura, Ichigaku Takigawa, Shin ichi Minato, Masanao Yamaoka, and Tamiki Komatsuzaki. Minor-embedding heuristics for large-scale annealing processors with sparse hardware graphs of up to 102,400 nodes. Soft Computing, 2021.   
+Daphne Koller and Nir Friedman, editors. Probabilistic Graphical Models: Principles and Techniques. The MIT Press, Cambridge, Massachusetts, 2009.   
+David Heckerman, Dan Geiger, and David M. Chickering. Learning bayesian networks: Search methods and experimental results. In Preliminary Papers of the 5th International Workshop on Artificial, pages 112–128, 1995b.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See section 7.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] See section 7.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] See section 4.   
+(b) Did you include complete proofs of all theoretical results? [Yes] See section 5.
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] in the supplemental material   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See section 6.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See fig. 2.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See section 6.3.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] in the supplemental material   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/HXjt-kRBzvu/HXjt-kRBzvu_content_list.json

@@ -0,0 +1,1305 @@
+[
+    {
+        "type": "text",
+        "text": "Bayesian Network Structure Learning using Digital Annealer ",
+        "text_level": 1,
+        "bbox": [
+            266,
+            122,
+            732,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            319,
+            535,
+            335
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Annealing processors, which efficiently solve a quadratic unconstrained binary   \n2 optimization (QUBO), are a potential breakthrough in improving the accuracy   \n3 of score-based Bayesian network structure learning. However, currently, the bit   \n4 capacity of an annealing processor is very limited. To utilize the power of an  \n5 nealing processors, it is necessary to encode score-based learning problems into   \n6 QUBO within the upper bound of bits. In this paper, we propose a novel approach   \n7 with direct encoding of candidate parent sets in the form of Cartesian products.   \n8 Experimental results on benchmark networks with 27 to 70 variables show that   \n9 our approach requires lesser bits than the bit capacity of the second-generation   \n10 Fujitsu digital annealer, a fully coupled annealing processor developed by with   \n11 semiconductor technology. Moreover, we demonstrate that the digital annealer   \n12 with our conversion method consistently outperforms the state-of-the-art heuristic   \n13 algorithms on the benchmark networks. ",
+        "bbox": [
+            148,
+            352,
+            766,
+            549
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "14 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            577,
+            312,
+            593
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "15 A Bayesian network is a probabilistic graphical model that represents the structure of a joint probabil  \n16 ity distribution among random variables in a directed acyclic graph (DAG) [Pearl, 1988]. One class   \n17 of associated computational problems is learning the structure of a Bayesian network from data. We   \n18 focus on score-based Bayesian network structure learning for finding the DAG with a maximal score   \n19 that depends on the data [Cooper and Herskovits, 1992, Cowell, 2001].   \n20 The Bayesian network learning problem is NP-hard [Chickering et al., 2004]; therefore, the standard   \n21 methodology is using heuristic approaches. Many algorithms have been proposed to improve the   \n22 accuracy and to reduce the running time. A search over the space of orderings [Teyssier and Koller,   \n23 2005, Scanagatta et al., 2015] is one of the most successful heuristic approaches.   \n24 Annealing processors may contribute to finding a high-scoring network structure in a realistic   \n25 timeframe. An annealing processor is expected to be an alternative hardware to von Neumann   \n26 computers for quadratic unconstrained binary optimization (QUBO) problems. In particular, it is   \n27 reported that complementary metal oxide semiconductor (CMOS) annealing processors already   \n28 outperform conventional computers on the speed of solving max-cut problems [Gyoten et al., 2018].   \n29 We note that the bit capacity of an annealing processor is currently limited. Therefore, we need an   \n30 efficient conversion method of Bayesian network structure learning into QUBO within the limited   \n31 bits. Additionally, it is also important to show the lower bounds of penalty coefficients because the   \n32 precision for the biases and variable couplers is limited.   \n33 Annealing processors are classified into the nearest neighbor type and the fully connected type   \n34 [Yamamoto, 2020]. While the coupling nodes of a nearest neighbor annealing processor is limited to   \n35 only between adjacent nodes, the coupling exists between arbitrary nodes of a fully coupled annealing   \n36 processor. Though the scalability of nearest neighbor annealing processors is high, it is necessary to   \n37 consider the additional bits for minor embedding [Choi, 2008, 2010].   \n38 O’Gorman et al. 2014 proposed a method to convert score-based Bayesian network structure learning   \n39 into QUBO that requires $\\mathcal { O } ( n ^ { 2 } )$ bits for $n$ random variables and a maximum parent set size $m = 2$ .   \n40 They also demonstrated the sufficient lower bounds of penalty coefficients. However, when $m \\geq 3$ ,   \n41 the number of necessary auxiliary variables for a quadratization [Boros and Gruber, 2014] is at most   \n42 $O ( n ( n - 1 ) ^ { \\frac { m } { 2 } } )$ . This is a significant disadvantage for the current limited bit capacity of annealing   \n43 processors.   \n44 In this study, we propose an efficient conversion method based on the advanced identification of   \n45 candidate parent sets and their representation in the form of Cartesian products. We also provide a   \n46 greedy algorithm to decompose the candidate parent sets into the form of Cartesian products and   \n47 prove the sufficient lower bounds of penalty coefficients.   \n48 Experimental results on benchmark networks with 27 to 70 variables show that our conversion method   \n49 reduces the required bits significantly in comparison to the previous work [O’Gorman et al., 2014].   \n50 Our approach allows us to utilize the power of the second generation Fujitsu digital annealer, a fully   \n51 coupled CMOS annealing processor [Aramon et al., 2019]. We demonstrate that the digital annealer   \n52 consistently outperforms the ordering space search algorithms on the benchmark networks. ",
+        "bbox": [
+            147,
+            609,
+            825,
+            685
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            693,
+            825,
+            752
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            760,
+            825,
+            835
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            842,
+            823,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            90,
+            825,
+            166
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            172,
+            826,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            270,
+            825,
+            332
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            337,
+            826,
+            414
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "53 2 Background ",
+        "text_level": 1,
+        "bbox": [
+            156,
+            431,
+            308,
+            449
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Score-based Bayesian Network Structure Learning ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            462,
+            566,
+            478
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "55 The goal of score-based Bayesian network structure learning is to find a DAG with maximal score.   \n56 Given to random variables $\\mathscr { X } = ( X _ { i } ) _ { i = 1 } ^ { n }$ and a complete data set of $N$ instances $\\mathcal { D } = \\{ D _ { 1 } , \\cdot \\cdot \\cdot , D _ { N } \\}$ ,   \n57 we optimize the parent set $\\Pi _ { i }$ of each random variable, ",
+        "bbox": [
+            147,
+            488,
+            828,
+            535
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9885ce80b2d23ce5b895e8fff9505555e3f3c661ed5a89e650eb99b6c8db169e.jpg",
+        "text": "$$\n\\Pi _ { 1 } ^ { * } , \\cdot \\cdot \\cdot , \\Pi _ { n } ^ { * } = \\underset { \\Pi _ { 1 } , \\cdots , \\Pi _ { n } \\subset { \\cal X } } { \\arg \\operatorname* { m i n } } \\sum _ { i = 1 } ^ { n } - \\log S ^ { ( i ) } ( \\Pi _ { i } \\mid { \\mathcal { D } } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            536,
+            666,
+            583
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where 58 ${ \\mathcal { G } } = ( \\mathcal { V } , { \\mathcal { E } } ) , \\mathcal { V } = \\{ 1 , \\cdots , n \\} , { \\mathcal { E } } = \\{ ( j , i ) | j , i \\in \\{ 1 , \\cdots , n \\} , X _ { j } \\in \\Pi _ { i } \\} ,$ and $S _ { i } : \\Pi _ { i }  \\mathbb { R }$ is a local score function corresponding to 59 $X _ { i }$ . The Bayesian Dirichlet equivalent uniform (BDeu) score 60 [Buntine, 1991] is one of the commonly used scores, ",
+        "bbox": [
+            147,
+            587,
+            825,
+            633
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a243805dd06eb5d447eb326ec23a57283f4c6a766c380f56caa35dd89527f897.jpg",
+        "text": "$$\nS _ { \\mathrm { B D e u } } ^ { ( i ) } ( \\Pi _ { i } \\mid \\mathcal { D } ) \\equiv \\prod _ { j = 1 } ^ { \\beta _ { i } } \\frac { \\Gamma ( \\alpha _ { i , j } ) } { \\Gamma ( N _ { i , j } + \\alpha _ { i , j } ) } \\prod _ { k = 1 } ^ { \\gamma _ { i } } \\frac { \\Gamma ( N _ { i , j , k } + \\alpha _ { i , j , k } ) } { \\Gamma ( \\alpha _ { i , j , k } ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            636,
+            699,
+            681
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "61 ere $\\begin{array} { r } { N = \\sum _ { j = 1 } ^ { \\beta _ { i } } N _ { i , j } , N _ { i , j } = \\sum _ { k = 1 } ^ { \\gamma _ { i } } N _ { i , j , k } , \\alpha _ { i , j } = \\sum _ { k = 1 } ^ { \\gamma _ { i } } \\alpha _ { i , j , k } , \\beta _ { i } } \\end{array}$ is the numb f joint states of $\\Pi _ { i }$ is the number of states of $X _ { i }$ , $N _ { i , j , k }$ is the number of cases of the parent set $\\Pi _ { i }$ 63 and Xi in its k-th state, αi,j,k = αβ γ is the hyperparameter of the Dirichlet function, and $0 < \\alpha \\in \\mathbb { R }$ 64 is called equivalent sample size [Heckerman et al., 1995a]. ",
+        "bbox": [
+            147,
+            686,
+            825,
+            750
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "65 2.2 Hamiltonian ",
+        "text_level": 1,
+        "bbox": [
+            153,
+            765,
+            302,
+            780
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "66 The Hamiltonian, which is the objective function of an annealing processor, is a quadratic pseudo  \n67 Boolean function, ",
+        "bbox": [
+            151,
+            790,
+            825,
+            820
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/31597f6745cb0a1832de82ab45c13fd58581ee582bc67ef71d91ef2d73657958.jpg",
+        "text": "$$\nH ( \\pmb { \\sigma } ) = \\sum _ { i \\in \\mathcal { V } _ { \\mathrm { A P } } } h _ { i } \\sigma _ { i } + \\sum _ { ( i , j ) \\in \\mathcal { E } _ { \\mathrm { A P } } } J _ { i , j } \\sigma _ { i } \\sigma _ { j } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            821,
+            635,
+            859
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "68 where ${ \\pmb \\sigma } = ( { \\boldsymbol \\sigma } _ { i } ) _ { i = 1 } ^ { | { \\boldsymbol \\nu } _ { \\mathrm { A P } } | } \\in \\mathbb { B } ^ { | { \\boldsymbol \\nu } _ { \\mathrm { A P } } | }$ , the biases $h _ { i } \\in \\mathbb { R }$ for all $i \\in \\mathcal { V } _ { \\mathrm { A P } }$ , the couplers $J _ { i , j } \\in \\mathbb { R }$ for all   \n69 $( i , j ) \\in \\mathcal { E } _ { \\mathrm { A P } }$ , and the graph $\\mathcal { G } _ { \\mathrm { A P } } = ( \\nu _ { \\mathrm { A P } } , \\mathcal { E } _ { \\mathrm { A P } } )$ . Higher degree problems are reformed into quadratic   \n70 ones using auxiliary variables. This reformulation is called quadratization. ",
+        "bbox": [
+            147,
+            863,
+            825,
+            912
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "71 Definition 1. If a quadratic polynomial function $g ( \\pmb { v } , \\pmb { h } )$ is a quadratization of a pseudo-Boolean function 72 $f ( v )$ , then $f ( v ) = \\operatorname* { m i n } _ { h \\in \\mathbb { B } ^ { J } } g ( v , h )$ for all $\\pmb { v } \\in \\mathbb { B } ^ { I }$ . ",
+        "bbox": [
+            150,
+            90,
+            825,
+            122
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "73 Anthony et al. 2016 proved that every pseudo-Boolean function of $I$ variables and of degree $K$ has   \n74 a quadratization involving at most $\\dot { \\mathcal { O } } ( \\dot { I } ^ { \\frac { K } { 2 } } )$ auxiliary variables. In particular, at most $\\check { \\mathcal { O } ( 2 ^ { \\frac { I } { 2 } } ) }$ when   \n75 $K = I$ . It is well known that every pseudo-Boolean function can be uniquely represented as a   \n76 multilinear polynomial in its variables [Boros and Hamme, 2002]. ",
+        "bbox": [
+            147,
+            132,
+            825,
+            194
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "77 2.3 Basic Conversion of Score-based Bayesian Network Structure Learning ",
+        "text_level": 1,
+        "bbox": [
+            151,
+            208,
+            710,
+            224
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using 78 $n ( n - 1 )$ bits to encode the paths into $\\pmb { d } = ( ( d _ { j , i } ) _ { 1 \\leq j \\leq n , j \\neq i } ) _ { i = 1 } ^ { n } \\in \\mathbb { B } ^ { n ( n - 1 ) }$ $( d _ { j , i } = 1$ if 79 $X _ { j }$ is the parent of $X _ { i }$ , $d _ { j , i } = 0$ otherwise) and $\\binom { n } { 2 }$ bits to encode the topological orders into 80 $r = ( r _ { i , j } ) _ { 1 \\leq i < j \\leq n } \\in \\mathbb { B } ^ { \\binom { n } { 2 } } ( r _ { i , j } =$ if the order of $X _ { i }$ is higher than $X _ { j }$ , $r _ { i , j } = 1$ otherwise), it is 81 possible to represent eq. (1) on the Hamiltonian, ",
+        "bbox": [
+            145,
+            234,
+            825,
+            301
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c0da30d04c8a1fddaacfdffb5b8f06065a58a53e388bc6e3259c4a429cd99b07.jpg",
+        "text": "$$\nH _ { \\mathrm { t o t a l } } ( d , r ) \\equiv \\sum _ { i = 1 } ^ { n } H _ { \\mathrm { s c o r e } } ^ { ( i ) } ( d , i ) + H _ { \\mathrm { c y c l e } } ( d , r ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            305,
+            656,
+            347
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "82 The states of $d _ { \\cdot , i }$ are mapped one-to-one to the states of $\\Pi _ { i }$ . Let $\\Pi _ { i } = \\pi ^ { ( i ) } ( d _ { \\cdot , i } )$ for all $1 \\leq i \\leq n$ .   \n83 The local score of the Hamiltonian is ",
+        "bbox": [
+            148,
+            353,
+            826,
+            385
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bb09f48b7fec6858384bcbb6cd20d82476963e632bea6c504f451bfb26887634.jpg",
+        "text": "$$\nH _ { \\mathrm { s c o r e } } ^ { ( i ) } ( d _ { \\cdot , i } ) \\equiv - \\log S ^ { ( i ) } ( \\pi ^ { ( i ) } ( d _ { \\cdot , i } ) \\mid \\mathcal { D } ) + \\log S ^ { ( i ) } ( \\phi \\mid \\mathcal { D } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            388,
+            694,
+            410
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "84 for all $1 \\leq i \\leq n$ . The score function has a quadratization involving at most $\\mathcal { O } ( n 2 ^ { \\frac { n - 1 } { 2 } } )$ auxiliary   \n85 variables. O’Gorman et al. 2014 added the maximum parent set size constraint to the Hamiltonian.   \n86 In this case, the number of auxiliary variables is at most $\\mathcal { O } ( n ( n - 1 ) ^ { \\frac { m } { 2 } } )$ . The cycle constraint of the   \n87 Hamiltonian consists of the topological order constraint and the consistency constraint, ",
+        "bbox": [
+            145,
+            417,
+            830,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3e20f28dfe6c797545a4eb730ad0e4487247edad97daff25d4004ea43d97491f.jpg",
+        "text": "$$\nH _ { \\mathrm { c y c l e } } ( d , r ) \\equiv \\sum _ { 1 \\leq i < j < k \\leq n } \\delta _ { 1 } R ( r _ { i , j } , r _ { j , k } , r _ { i , k } ) + \\sum _ { 1 \\leq i < j \\leq n } \\delta _ { 2 } ( d _ { i , j } r _ { i , j } + d _ { j , i } ( 1 - r _ { i , j } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            483,
+            782,
+            520
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "88 where $R ( r _ { 1 } , r _ { 2 } , r _ { 3 } ) = r _ { 1 } r _ { 2 } ( 1 - r _ { 3 } ) + ( 1 - r _ { 1 } ) ( 1 - r _ { 2 } ) r _ { 3 }$ for all $r _ { 1 } , r _ { 2 } , r _ { 3 } \\in \\mathbb { B }$ . When the penalty   \n89 coefficients $0 < \\delta _ { 1 } , \\delta _ { 2 } \\in \\mathbb { R }$ are sufficiently large, the DAG constraint is satisfied indirectly through   \n90 the relationship of the paths $^ d$ and the topological order $\\pmb { r }$ . If it holds that ",
+        "bbox": [
+            145,
+            525,
+            826,
+            571
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b8b222fcc0e1e5345675d49bc19d7e6153f96aaed4ffc497120d754cd82a0829.jpg",
+        "text": "$$\n\\operatorname* { m a x } \\{ 0 , \\operatorname* { m a x } _ { \\substack { 1 \\leq j ^ { * } , i ^ { * } \\leq n d _ { \\cdot , j ^ { * } } \\in \\mathbb { B } ^ { n - 1 } } }  ( H _ { \\mathrm { s c o r e } } ^ { ( i ^ { * } ) } ( d _ { \\cdot , i ^ { * } } ^ { ( j ^ { * } , i ^ { * } ) } ) - H _ { \\mathrm { s c o r e } } ^ { ( i ^ { * } ) } ( d _ { \\cdot , i ^ { * } } ) ) \\} < \\delta _ { 1 } < \\frac { \\delta _ { 2 } } { n - 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            575,
+            763,
+            622
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "91 then there is no cycle on the paths of the ground state, where ∗ ∗ ∗ ∗ ${ \\pmb d } ^ { ( j ^ { \\ast } , i ^ { \\ast } ) } = ( ( d _ { j , i } ) _ { 1 \\leq j \\leq n , j \\neq i } ^ { ( j ^ { \\ast } , i ^ { \\ast } ) } ) _ { i = 1 } ^ { n }$   \n92 $d _ { j , i } ^ { ( j ^ { * } , i ^ { * } ) } = 0$ if $( j , i ) = ( j ^ { * } , i ^ { * } )$ , $d _ { j , i } ^ { ( j ^ { * } , i ^ { * } ) } = d _ { j , i }$ otherwise. The computational cost to obtain the left   \n93 side of eq. (7) is at most $\\mathcal { O } ( n ^ { m + 1 } )$ . In particular, at most $O ( n ^ { 2 } 2 ^ { n - 2 } )$ when $m = n - 1$ . ",
+        "bbox": [
+            147,
+            631,
+            825,
+            685
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "94 3 Candidate Parent Set Decomposition ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            702,
+            514,
+            722
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Parent set identification is a major technique to narrow the search space of structure optimization, based on the relationship between parent sets and local scores under the DAG constraints [de Campos and Ji, 2011, Correia et al., 2020]. The collection of candidate parent sets of a random variable $X _ { i }$ is $\\{ W \\subseteq { \\mathcal { X } } \\setminus \\{ X _ { i } \\} \\mid W ^ { \\prime } \\subset W \\Rightarrow S ^ { ( i ) } ( W ^ { \\prime } \\mid { \\mathcal { D } } ) < S ^ { ( i ) } ( W \\mid { \\mathcal { D } } ) \\}$ . To reduce the required bits of the score component of the Hamiltonian, we propose an efficient conversion method with the parent set identification. We directly encode the candidate parent sets instead of using the paths $^ d$ . ",
+        "bbox": [
+            173,
+            734,
+            826,
+            827
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Moreover, we decompose the candidate parent sets $( W _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { i } }$ of each random variable into the form of Cartesian products as follows: ",
+        "bbox": [
+            165,
+            832,
+            825,
+            864
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Decompose $( W _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { i } }$ into $( W _ { h , i } \\cap Z _ { i } ) _ { h = 0 } ^ { \\lambda _ { i } } , ( W _ { h , i } \\cap ( { \\mathcal { X } } \\setminus Z _ { i } ) ) _ { h = 0 } ^ { \\lambda _ { i } } ,$   \n2. Remove duplicates in the elements of $( W _ { h , i } \\cap Z _ { i } ) _ { h = 0 } ^ { \\lambda _ { i } } , ( W _ { h , i } \\cap ( { \\mathcal { X } } \\setminus Z _ { i } ) ) _ { h = 0 } ^ { \\lambda _ { i } } ,$ ",
+        "bbox": [
+            210,
+            872,
+            748,
+            914
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ab3b3cda9ea0934cb1baa7d042cb63f494af0851c4623ac066ff6b9967b3dbd2.jpg",
+        "text": "$$\n\\because ( W _ { h , i } \\cap Z _ { i } ) _ { h = 0 } ^ { \\lambda _ { 1 , i } } , ( W _ { h , i } \\cap ( \\mathcal { X } \\setminus Z _ { i } ) ) _ { h = 0 } ^ { \\lambda _ { 2 , i } } \\mathrm { ~ i n ~ } ( U _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { 1 , i } } , ( V _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { 2 , i } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            87,
+            694,
+            109
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where 106 $Z _ { i } \\subseteq \\cup _ { h = 0 } ^ { \\lambda _ { i } } W _ { h , i } , W _ { 0 , i } = U _ { 0 , i } = V _ { 0 , i } = \\phi , \\lambda _ { i } , \\lambda _ { 1 , i } , \\lambda _ { 2 , i } \\in \\mathbb { N } \\cup \\{ 0 \\}$ for all $1 \\leq i \\leq n$ . There 107 is a clear relationship, ",
+        "bbox": [
+            142,
+            117,
+            823,
+            150
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/692265dd84ddbbb674f02f50a0e26baf045418a2d9859a4d3b09281bd474988a.jpg",
+        "text": "$$\n\\begin{array} { r } { \\{ W _ { 0 , i } , \\cdots , W _ { \\lambda _ { i } , i } \\} \\subseteq \\{ U \\cup V \\mid ( U , V ) \\in \\{ U _ { 0 , i } , \\cdots , U _ { \\lambda _ { 1 , i } , i } \\} \\times \\{ V _ { 0 , i } , \\cdots , V _ { \\lambda _ { 2 , i } , i } \\} \\} , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            220,
+            155,
+            776,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "108 for all $1 \\leq i \\leq n$ . Here, given that the Hamiltonian is a quadratic pseudo-Boolean function, we can represent the score against 109 fore, it is possible to encod110 $U _ { h , i } \\cup V _ { h ^ { \\prime } , i }$ by allocating ate parent sets $U _ { h , i } , V _ { h ^ { \\prime } , i }$ to two bits on thamiltonian using $( U _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { 1 , i } } , ( V _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { 2 , i } }$ 111 The number of required bits of the score component of the Hamiltonian is ${ \\textstyle \\sum _ { i = 1 } ^ { n } } ( \\lambda _ { 1 , i } + \\lambda _ { 2 , i } )$ . ",
+        "bbox": [
+            140,
+            178,
+            828,
+            242
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "112 Example 1. An example of the candidate parent sets in the form of Cartesian products as follows: ",
+        "bbox": [
+            138,
+            246,
+            818,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/177bc226d0abc53ce1d02c4e3167229d1c8c3d1a6f610731ec9795a250229c90.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { X } = \\{ X _ { 1 } , X _ { 2 } , X _ { 3 } , X _ { 4 } \\} , \\ Z _ { i } = \\{ X _ { 1 } , X _ { 2 } \\} , \\ \\lambda _ { i } = 5 , \\ \\lambda _ { 1 , i } = 2 , \\ \\lambda _ { 2 , i } = 1 } \\\\ & { ( W _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { i } } = ( \\phi , \\{ X _ { 1 } \\} , \\{ X _ { 1 } , X _ { 2 } \\} , \\{ X _ { 3 } , X _ { 4 } \\} , \\{ X _ { 1 } , X _ { 3 } , X _ { 4 } \\} , \\{ X _ { 1 } , X _ { 2 } , X _ { 3 } , X _ { 4 } \\} ) , } \\\\ & { ( W _ { h , i } \\cap Z _ { i } ) _ { h = 0 } ^ { \\lambda _ { i } } = ( \\phi , \\{ X _ { 1 } \\} , \\{ X _ { 1 } , X _ { 2 } \\} , \\phi , \\{ X _ { 1 } \\} , \\{ X _ { 1 } , X _ { 2 } \\} ) , } \\\\ & { ( W _ { h , i } \\cap ( \\mathcal { X } \\setminus Z _ { i } ) ) _ { h = 0 } ^ { \\lambda _ { i } } = ( \\phi , \\phi , \\phi , \\{ X _ { 3 } , X _ { 4 } \\} , \\{ X _ { 3 } , X _ { 4 } \\} , \\{ X _ { 3 } , X _ { 4 } \\} ) , } \\\\ & { ( U _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { 1 , i } } = ( \\phi , \\{ X _ { 1 } \\} , \\{ X _ { 1 } , X _ { 2 } \\} ) , \\ ( V _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { 2 , i } } = ( \\phi , \\{ X _ { 3 } , X _ { 4 } \\} ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            265,
+            751,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We optimize 113 $Z _ { i } \\subseteq \\cup _ { h = 0 } ^ { \\lambda _ { i } } W _ { h , i }$ to minimize $\\lambda _ { 1 , i } + \\lambda _ { 2 , i }$ . However, it is often infeasible to search all 114 elements of the power set $\\mathcal { P } ( \\cup _ { h = 0 } ^ { \\lambda _ { i } } W _ { h , i } )$ . Therefore, we heuristically search 3 $Z _ { i }$ adding elements one by one, as algorithm 1. The computational cost is at most $1 \\leq i \\leq n$ ",
+        "bbox": [
+            142,
+            382,
+            825,
+            431
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Greedy Candidate Parent Set Decomposition ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            445,
+            558,
+            460
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1: Input: $( W _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { i } }$ Output: $Z$ Initialize: $\\lambda  \\lambda _ { i } , Z ^ { \\prime }  \\phi , Z  \\phi$ .   \n2: for $d = 1$ to $| \\cup _ { h = 0 } ^ { \\lambda _ { i } } W _ { h , i } | - 1$ do   \n3: for $X$ in $\\cup _ { h = 0 } ^ { \\lambda _ { i } } W _ { h , i } \\setminus Z$ do   \n4: if $\\lambda _ { 1 , i } + \\lambda _ { 2 , i } < \\lambda$ for $Z _ { i } = Z \\cup \\{ X \\}$ then $\\lambda  \\lambda _ { 1 , i } + \\lambda _ { 2 , i } , Z ^ { \\prime }  Z \\cup \\{ X \\} .$ .   \n5: if $Z \\neq Z ^ { \\prime }$ then $Z  Z ^ { \\prime }$ else break ",
+        "bbox": [
+            178,
+            467,
+            754,
+            549
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "115 ",
+        "bbox": [
+            142,
+            558,
+            161,
+            569
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "116 Example 2. An example of the bit reduction flow of algorithm 1 is as follows: ",
+        "bbox": [
+            142,
+            570,
+            689,
+            587
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/edf133bebbed6e9f1548b0b895521a644d3238a24083d9d1c1cef44858e4d6e6.jpg",
+        "text": "$$\n\\begin{array} { r l } & { Z _ { i } = \\phi , \\lambda _ { 1 , i } = 0 , \\lambda _ { 2 , i } = 5 : ( \\phi ) \\times ( \\phi , \\{ X _ { 1 } \\} , \\{ X _ { 1 } , X _ { 2 } \\} , \\{ X _ { 3 } , X _ { 4 } \\} , \\{ X _ { 1 } , X _ { 3 } , X _ { 4 } \\} , \\{ X _ { 1 } , X _ { 2 } , X _ { 3 } , X _ { 4 } \\} , \\{ X _ { 1 } , X _ { 3 } , X _ { 3 } \\} , } \\\\ & { Z _ { i } = \\{ X _ { 1 } \\} , \\lambda _ { 1 , i } = 1 , \\lambda _ { 2 , i } = 3 : ( \\phi , \\{ X _ { 1 } \\} ) \\times ( \\phi , \\{ X _ { 2 } \\} , \\{ X _ { 3 } , X _ { 4 } \\} , \\{ X _ { 2 } , X _ { 3 } , X _ { 4 } \\} ) , } \\\\ & { Z _ { i } = \\{ X _ { 1 } , X _ { 2 } \\} , \\lambda _ { 1 , i } = 2 , \\lambda _ { 2 , i } = 1 : ( \\phi , \\{ X _ { 1 } \\} , \\{ X _ { 1 } , X _ { 2 } \\} ) \\times ( \\phi , \\{ X _ { 3 } , X _ { 4 } \\} ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            168,
+            589,
+            816,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "117 4 Efficient Conversion of Score-based Bayesian Network Structure Learning ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            662,
+            825,
+            683
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We make 118 $( U _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { 1 , i } } , ( V _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { 2 , i } }$ correspond to $( p _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { 1 , i } } , ( q _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { 2 , i } }$ one-to-one, where $p _ { h , i } , q _ { h ^ { \\prime } , i } \\in \\mathbb { B }$ 119 for all $0 \\leq h \\leq \\lambda _ { 1 , i } , 0 \\leq h ^ { \\prime } \\leq \\lambda _ { 2 , i } , 1 \\leq i \\leq n$ . To identify the parent sets, we use the one-to-one 120 correspondence constraint that $\\begin{array} { r } { \\sum _ { h = 0 } ^ { \\lambda _ { 1 , i } } p _ { h , i } = \\sum _ { h = 0 } ^ { \\lambda _ { 2 , i } } q _ { h , i } = 1 } \\end{array}$ for all $1 \\leq i \\leq n$ . The Hamiltonian 121 consists of the score component, the one-to-one correspondence constraint, and the cycle constraint, ",
+        "bbox": [
+            142,
+            695,
+            826,
+            762
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/059a499284c7d9b86d50bb3dab59523b76c867de03060aaededf191ad90c6143.jpg",
+        "text": "$$\nH _ { \\mathrm { t o t a l } } ^ { * } ( p , q , r ) \\equiv \\sum _ { i = 1 } ^ { n } ( H _ { \\mathrm { s c o r e } } ^ { * ( i ) } ( p . , i , q . , i ) + H _ { \\mathrm { o n e } } ^ { * ( i ) } ( p . , i , q . , i ) ) + H _ { \\mathrm { c y c l e } } ^ { * } ( p , q , r ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            240,
+            765,
+            756,
+            808
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where 122 $\\pmb { p } = ( ( p _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { 1 , i } } ) _ { i = 1 } ^ { n } , \\pmb { q } = ( ( q _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { 2 , i } } ) _ { i = 1 } ^ { n }$ . Under the one-to correspondence constraint,   \n123 we can represent the paths among random variables indirectly using $\\mathbf { \\omega } _ { p , q }$   \n124 variables, ",
+        "bbox": [
+            140,
+            813,
+            825,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6dd36b70ee16072c01d515a9805ef91032a01d1c4e329914aee71ae96585c6b2.jpg",
+        "text": "$$\nd _ { j , i } ^ { * } \\equiv \\sum _ { 1 \\leq h \\leq \\lambda _ { 1 , i } \\atop \\overline { { X } } _ { j } \\in U _ { h , i } } p _ { h , i } + \\sum _ { 1 \\leq h \\leq \\lambda _ { 2 , i } \\atop \\overline { { X } } _ { j } \\in V _ { h , i } } q _ { h , i } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            863,
+            619,
+            910
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/d4f7e8cc2ac82f681ab72206ecf688f4b23e1a397be97e5c0273bc55dfd11cd4.jpg",
+        "image_caption": [
+            "Figure 1: An example of bit allocation for our conversion method. $n = 4 , \\lambda _ { 1 , 1 } = 3 , \\lambda _ { 2 , 1 } = 1 , \\lambda _ { 1 , 2 } =$ 1 $\\bar { \\lambda } _ { 2 , 2 } = 0 , \\lambda _ { 1 , 3 } = \\bar { 1 } , \\lambda _ { 2 , 3 } = 1 , \\lambda _ { 1 , 4 } = 0 , \\lambda _ { 2 , 4 } = 0 , U _ { 1 , 1 } = \\{ 2 , 3 \\} , U _ { 2 , 1 } = \\{ 3 \\} , U _ { 3 , 1 } = \\{ 2 \\} , V _ { 1 , 1 } = \\{ 3 \\} , U _ { 2 , 2 } = \\{ 3 \\} , U _ { 3 , 2 } = \\{ 3 \\} , U _ { 2 , 2 } = \\{ 3 \\} ,$ $\\{ 4 \\} , U _ { 1 , 2 } = \\{ 3 \\} , U _ { 1 , 3 } = \\{ 1 \\} , V _ { 1 , 3 } = \\{ 4 \\}$ . Circle : $\\mathbf { \\mu } _ { p , q }$ . Square $: \\textbf {  { r } }$ . Red lines include in the score component of the Hamiltonian, a green line in the one-to-one correspondence constraint, and blue lines in the cycle constraint. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            109,
+            794,
+            396
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "125 for all $1 \\leq j , i \\leq n$ . Figure 1 is an example of bit allocation using our conversion method. The 126 number of bits required in our conversion method is $\\begin{array} { r } { \\sum _ { i = 1 } ^ { n } ( \\lambda _ { 1 , i } + \\lambda _ { 2 , i } ) + \\binom { n } { 2 } } \\end{array}$ . Note that we do not directly encode127 $p _ { 0 , i } , q _ { 0 , i }$ on the Hamiltonian. ",
+        "bbox": [
+            143,
+            518,
+            826,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "128 Score Component. The local score component of the Hamiltonian is ",
+        "bbox": [
+            147,
+            570,
+            633,
+            587
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/96ebf3a679e7b0d4a55385a55a460aa1d4d03d17436fd8704348dfc1b0a44867.jpg",
+        "text": "$$\nH _ { \\mathrm { s c o r r e } } ^ { * ( i ) } ( { \\pmb p } _ { . , i } , { \\pmb q } _ { . , i } ) \\equiv \\sum _ { h = 1 } ^ { \\lambda _ { 1 , i } } s _ { 1 , h , i } p _ { h , i } + \\sum _ { h = 1 } ^ { \\lambda _ { 2 , i } } s _ { 2 , h , i } q _ { h , i } + \\sum _ { h = 1 } ^ { \\lambda _ { 1 , i } } \\sum _ { h ^ { \\prime } = 1 } ^ { \\lambda _ { 2 , i } } t _ { h , h ^ { \\prime } , i } p _ { h , i } q _ { h ^ { \\prime } , i } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            590,
+            750,
+            636
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "129 for all $1 \\leq i \\leq n$ . We can get these coefficients by solving simultaneous equations under the   \n130 one-to-one correspondence constraint, $s _ { 1 , h , i } = \\_ \\log S ^ { ( i ) } ( U _ { h , i } \\mid \\mathcal { D } ) + \\log S ^ { ( i ) } ( \\phi \\mid \\mathcal { D } ) , s _ { 2 , h , i } =$   \n131 $\\begin{array} { r } { - \\log S ^ { ( i ) } ( V _ { h , i } \\mid \\mathcal D ) + \\log S ^ { ( i ) } ( \\phi \\mid \\mathcal D ) , t _ { h , h ^ { \\prime } , i } = - \\log S ^ { ( i ) } ( U _ { h , i } \\cup V _ { h ^ { \\prime } , i } \\mid \\mathcal D ) + \\log S ^ { ( i ) } ( U _ { h , i } \\mid \\mathcal D ) + } \\end{array}$   \n132 $\\log S ^ { ( i ) } ( V _ { h ^ { \\prime } , i } \\mid \\mathcal { D } ) - \\log S ^ { ( i ) } ( \\phi \\mid \\mathcal { D } )$ . ",
+        "bbox": [
+            140,
+            638,
+            826,
+            700
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "133 One-to-One element from 134 $( U _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { 1 , i } } , ( V _ { h , i } ) _ { h = 0 } ^ { \\lambda _ { 2 , i } }$ nstraint. We penalize the connection among bits to select each , ",
+        "bbox": [
+            145,
+            707,
+            826,
+            741
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a7f05f2001ab49132a03a2f6406d91157f12a44726e37d32f2512341bb23d1b3.jpg",
+        "text": "$$\nH _ { \\mathrm { o n e } } ^ { * ( i ) } ( p . , . , q . , i ) \\equiv \\sum _ { 1 \\leq h < h ^ { \\prime } \\leq \\lambda _ { 1 , i } } \\xi _ { 1 , i } p _ { h , i } p _ { h ^ { \\prime } , i } + \\sum _ { 1 \\leq h < h ^ { \\prime } \\leq \\lambda _ { 2 , i } } \\xi _ { 2 , i } q _ { h , i } q _ { h ^ { \\prime } , i } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            743,
+            733,
+            780
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "135 136 $1 \\leq i \\leq n$ penalty coefficient is induced indirectly $0 < \\xi _ { 1 , i } , \\xi _ { 2 , i } \\in \\mathbb { R }$ . If $\\xi _ { 1 , i } , \\xi _ { 2 , i }$ is sufficient large, $\\begin{array} { r } { \\sum _ { h = 0 } ^ { \\lambda _ { 1 , i } } p _ { h , i } = \\sum _ { h = 0 } ^ { \\lambda _ { 2 , i } } q _ { h , i } = 1 } \\end{array}$ ",
+        "bbox": [
+            142,
+            784,
+            828,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "137 Cycle Constraint. Compared to eq. (6), the cycle constraint of the Hamiltonian is ",
+        "bbox": [
+            137,
+            823,
+            718,
+            839
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1f487b5e21ae0614865f7830a55d2e685e703b525cc02687348df63ee81a5b93.jpg",
+        "text": "$$\nH _ { \\mathrm { c y c l e } } ^ { * } ( p , q , r ) \\equiv \\sum _ { 1 \\leq i < j < k \\leq n } \\delta _ { 1 } ^ { * } R ( r _ { i , j } , r _ { j , k } , r _ { i , k } ) + \\sum _ { 1 \\leq i < j \\leq n } \\delta _ { 2 } ^ { * } ( d _ { i , j } ^ { * } r _ { i , j } + d _ { j , i } ^ { * } ( 1 - r _ { i , j } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            842,
+            779,
+            877
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the penalty coefficients 138 $0 < \\delta _ { 1 } ^ { * } , \\delta _ { 2 } ^ { * } \\in \\mathbb { R }$ . By setting $\\delta _ { 1 } ^ { * } , \\delta _ { 2 } ^ { * }$ appropriately, we can prevent the 139 cycle from occurring. ",
+        "bbox": [
+            137,
+            881,
+            828,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "141 We demonstrate the sufficient lower bounds of penalty coefficients. The basic idea is that we find the   \n142 range of penalty coefficients so that the change in return value of the Hamiltonian is negative when   \n143 the input state changes to the state we desire to induce.   \n144 One-to-One Correspondence Constraint. We consider to decrease the value of $\\scriptstyle \\sum _ { h = 1 } ^ { \\lambda _ { 1 , i ^ { * } } } p _ { h , i ^ { * } }$ by   \n145 146 $\\begin{array} { r } { p _ { h ^ { * } , i ^ { * } } = 1 , \\sum _ { h = 1 } ^ { \\lambda _ { 1 , i ^ { * } } } p _ { h , i ^ { * } } > 1 } \\end{array}$ , e $H _ { \\mathrm { t o t a l } } ^ { * } ( p , q , r ) -$   \n$\\begin{array} { r } { H _ { \\mathrm { t o t a l } } ^ { * } ( p ^ { ( h ^ { * } , i ^ { * } ) } , q , r ) \\geq \\xi _ { 1 , i ^ { * } } + s _ { 1 , h ^ { * } , i ^ { * } } + \\sum _ { h = 1 } ^ { \\lambda _ { 2 , i } } t _ { h ^ { * } , h , i ^ { * } } q _ { h , i ^ { * } } . } \\end{array}$ $\\pmb { p } ^ { ( h ^ { * } , i ^ { * } ) } = ( ( p _ { h , i } ^ { ( h ^ { * } , i ^ { * } ) } ) _ { h = 0 } ^ { \\lambda _ { 1 , i } } ) _ { i = 1 } ^ { n }$   \n147 and p(h∗,i∗)h,i = 0 if (h, i) = (h∗, i∗), p(h∗,h,i otherwise. Considering the case where $\\pmb { p }$ and $\\pmb q$   \n148 are swapped in the above, if $\\xi _ { 1 , i } , \\xi _ { 2 , i }$ satisfy that ",
+        "bbox": [
+            142,
+            119,
+            826,
+            166
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            172,
+            825,
+            263
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ff3f4ba76617ec792651b8309ec79b6300bf8cb7f493172eb5077060b8e53503.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { } & { \\displaystyle \\operatorname* { m a x } _ { 0 \\le h \\le \\lambda _ { 1 , i } } \\bigl ( - s _ { 1 , h , i } - \\sum _ { h ^ { \\prime } = 1 } ^ { \\lambda _ { 2 , i } } \\operatorname* { m i n } \\bigl \\{ 0 , t _ { h , h ^ { \\prime } , i } \\bigr \\} \\bigr ) \\bigr ) < \\xi _ { 1 , i } , } \\\\ & { } & { \\displaystyle \\operatorname* { m a x } _ { 0 \\le h \\le \\lambda _ { 2 , i } } \\bigl ( - s _ { 2 , h , i } - \\sum _ { h ^ { \\prime } = 1 } ^ { \\lambda _ { 1 , i } } \\operatorname* { m i n } \\bigl \\{ 0 , t _ { h ^ { \\prime } , h , i } \\bigr \\} \\bigr ) \\bigr ) < \\xi _ { 2 , i } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            265,
+            661,
+            356
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "149 for all $1 \\leq i \\leq n$ , then the grand state does not violate the one-to-one correspondence constraint.   \n150 The computational cost to obtain the left side of eq. (14) and eq. (15) is at most $\\mathcal { O } ( \\lambda _ { 1 , i } \\lambda _ { 2 , i } )$ for all   \n151 $1 \\leq i \\leq n$ .   \n152 Cycle Constraint. We consider four patterns of $( r _ { i ^ { * } , j ^ { * } } , d _ { j ^ { * } , i ^ { * } } ^ { * } , d _ { i ^ { * } , j ^ { * } } ^ { * } )$ violating the consistency   \n153 constraint. It is assumed that $X _ { j ^ { * } } ~ \\in ~ U _ { h ^ { * } , i ^ { * } } , X _ { j ^ { * } } ~ \\notin ~ U _ { h ^ { * * } , i ^ { * } } ~ \\subset ~ U _ { h ^ { * } , i ^ { * } } , p _ { h ^ { * } , i ^ { * } } ~ = ~ 1 , p _ { h ^ { * * } , i ^ { * } } ~ = ~ 0$ .   \n154 155 In thewhere $r ^ { ( i ^ { * } , j ^ { * } ) } = ( r _ { i , j } ^ { ( i ^ { * } , j ^ { * } ) } ) _ { 1 \\leq i < j \\leq n }$ $( 0 , 1 , 0 )$ t , $H _ { \\mathrm { t o t a l } } ^ { * } ( p , q , r ) - H _ { \\mathrm { t o t a l } } ^ { * } ( p , q , r ^ { ( i ^ { * } , j ^ { * } ) } ) \\geq \\delta _ { 2 } ^ { * } - ( n - 2 ) \\delta _ { 1 } ^ { * }$ $r _ { i , j } ^ { ( i ^ { * } , j ^ { * } ) } = 1 - r _ { i , j }$ $( i , j ) = ( i ^ { * } , j ^ { * } ) , r _ { i , j } ^ { ( i ^ { * } , j ^ { * } ) } = r _ { i , j }$   \n156 otherwise. Similarly, it is possible to consider the case of $( 1 , 0 , 1 )$ . In the case of $( 0 , 1 , 1 )$ ,   \n157 it holds that $\\begin{array} { r } { H _ { \\mathrm { t o t a l } } ^ { * } ( p , q , r ) - H _ { \\mathrm { t o t a l } } ^ { * } ( p ^ { ( h ^ { * } , h ^ { * * } , i ^ { * } ) } , q , r ) \\ge \\delta _ { 2 } ^ { * } + s _ { 1 , h ^ { * } , i ^ { * } } + \\sum _ { h = 1 } ^ { \\lambda _ { 2 , i } } t _ { h ^ { * } , h , i ^ { * } } q _ { h , i ^ { * } } - \\frac { 1 - \\lambda _ { 1 } } { \\lambda _ { 2 } } | \\nabla p _ { h } ( q _ { h } ^ { * } , h ^ { * } , i ^ { * } ) | _ { \\mathbb { H } } ( q _ { h } ^ { * } , h ^ { * } , i ^ { * } ) , } \\end{array}$   \n158 $\\begin{array} { r } { s _ { 1 , h ^ { * * } , i ^ { * } } - \\sum _ { h = 1 } ^ { \\lambda _ { 2 , i } } t _ { h ^ { * * } , h , i ^ { * } } q _ { h , i ^ { * } } } \\end{array}$ , where $\\pmb { p } ^ { ( h ^ { * } , h ^ { * * } , i ^ { * } ) } = ( ( p _ { h , i } ^ { ( h ^ { * } , h ^ { * * } , i ^ { * } ) } ) _ { h = 0 } ^ { \\lambda _ { 1 , i } } ) _ { i = 1 } ^ { n }$ h=, and $p _ { h , i } ^ { ( h ^ { * } , h ^ { * * } , i ^ { * } ) } = 0$   \n159 if $( h , i ) \\ = \\ ( h ^ { * } , i ^ { * } ) , p _ { h , i } ^ { ( h ^ { * } , h ^ { * * } , i ^ { * } ) } \\ = \\ 1$ p(h∗,h∗∗,i∗)h,i = 1 if (h, i) = (h∗∗, i∗), p(h∗,h,i $p _ { h , i } ^ { ( h ^ { * } , h ^ { * * } , i ^ { * } ) } = p _ { h , i }$ otherwise. Sim  \n160 ilarly, it is possible to consider the case of $( 1 , 1 , 1 )$ . These results suggest the relationship of   \n161 $\\delta _ { 1 } ^ { * } , \\delta _ { 2 } ^ { * }$ to induce the consistency constraint. Here, based on theorem 1, we consider a strategy   \n162 to repeat picking up one element from $\\mathbfit { \\Delta } \\mathbf { r }$ and switching its value until $H _ { \\mathrm { t r a n s } } ( r ) = 0$ . It is as  \n163 164 sumed that $\\begin{array} { r } { T _ { \\mathrm { t o t a l } } ^ { * } \\big ( p ^ { ( h ^ { * } , h ^ { * * } , i ^ { * } ) } , q , r ^ { ( i ^ { * } , j ^ { * } ) } \\big ) \\geq \\delta _ { 1 } ^ { * } + s _ { 1 , h ^ { * } , i ^ { * } } + \\sum _ { h = 1 } ^ { \\lambda _ { 2 , i } } t _ { h ^ { * } , h , i ^ { * } } q _ { h , i ^ { * } } - s _ { 1 , h ^ { * * } , i ^ { * } } - \\sum _ { h = 1 } ^ { \\lambda _ { 2 , i } } t _ { h ^ { * * } , h , i ^ { * } } q _ { h , i ^ { * } } . } \\end{array}$ $H _ { \\mathrm { t r a n s } } ( \\mathbf { \\bar { r } } ) > H _ { \\mathrm { t r a n s } } ( { r ^ { ( i ^ { * } , j ^ { * } ) } } )$ . In the case of $( 1 , 1 , 0 )$ , it holds that $H _ { \\mathrm { t o t a l } } ^ { * } ( p , q , r ) \\sim$   \n165 Similarly, it is possible to consider the case of $( 0 , 0 , 1 )$ . In the case of $( 1 , 0 , 0 )$ or $( 0 , 0 , 0 )$ , it holds   \n166 that $\\bar { H _ { \\mathrm { t o t a l } } ^ { * } } ( p , \\bar { q } , r ) - \\bar { H _ { \\mathrm { t o t a l } } ^ { * } } ( p , q , r ^ { ( i ^ { * } , j ^ { * } ) } ) \\geq \\delta _ { 1 } ^ { * }$ . These results suggest the lower bound of ${ { \\delta } _ { 1 } ^ { * } }$ to   \n167 induce the topological order constraint. Considering the case where $\\pmb { p }$ and $\\pmb q$ are swapped in the   \n168 above, if $\\delta _ { 1 } ^ { * } , \\delta _ { 2 } ^ { * }$ satisfy that ",
+        "bbox": [
+            140,
+            356,
+            825,
+            401
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            406,
+            826,
+            681
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f331a970455c12a4a94d5d27fe6e4ec705cbe61b8be399900e2a744f7a5f7faf.jpg",
+        "text": "$$\n\\begin{array} { c } { \\displaystyle \\operatorname* { m a x } _ { 1 \\leq i \\leq n } \\operatorname* { m a x } \\{ \\eta _ { 1 , i } , \\eta _ { 2 , i } \\} < \\delta _ { 1 } ^ { * } < \\displaystyle \\frac { \\delta _ { 2 } ^ { * } } { n - 2 } , } \\\\ { \\displaystyle \\operatorname* { m a x } _ { 1 \\leq j \\leq n } \\displaystyle \\operatorname* { m a x } _ { 1 \\leq i \\leq 1 _ { 1 , i } } \\operatorname* { m a x } _ { 0 \\leq h ^ { \\prime } \\leq \\lambda _ { 1 , i } } \\operatorname* { m a x } _ { 0 \\leq h ^ { \\prime } \\leq \\lambda _ { 2 , i } } ( - s _ { 1 , h , i } - t _ { h , h ^ { \\prime \\prime } , i } + s _ { 1 , h ^ { \\prime } , i } + t _ { h ^ { \\prime } , h ^ { \\prime \\prime } , i } ) , } \\\\ { \\displaystyle \\eta _ { 1 , i } \\equiv \\displaystyle \\operatorname* { m a x } _ { 1 \\leq j \\leq n } \\displaystyle \\frac { \\operatorname* { m a x } _ { i } } { X _ { j } \\in U _ { h , i } } \\operatorname* { m a x } _ { X _ { j } \\in U _ { h , i } } \\operatorname* { m a x } _ { 0 \\leq h ^ { \\prime \\prime } \\leq \\lambda _ { 1 , i } } ( - s _ { 2 , h , i } - t _ { h ^ { \\prime \\prime } , h , i } + s _ { 2 , h ^ { \\prime } , i } + t _ { h ^ { \\prime \\prime } , h ^ { \\prime \\prime } , i } ) , } \\\\ { \\displaystyle \\eta _ { 2 , i } \\equiv \\displaystyle \\operatorname* { m a x } _ { 1 \\leq j \\leq n } \\displaystyle \\operatorname* { m a x } _ { 0 \\leq h ^ { \\prime } \\leq \\lambda _ { 2 , i } } \\operatorname* { m a x } _ { 0 \\leq h ^ { \\prime } \\leq \\lambda _ { 2 , i } } ( - s _ { 2 , h , i } - t _ { h ^ { \\prime \\prime } , h , i } + s _ { 2 , h ^ { \\prime } , i } + t _ { h ^ { \\prime \\prime } , h ^ { \\prime } , i } ) , } \\\\ { \\displaystyle \\sum _ { k \\geq \\ell \\leq n } \\displaystyle \\sum _ { X _ { j } \\in V _ { h , i } } \\sum _ { j \\in V _ { h ^ { \\prime } } , i \\subset V _ { h , i } } ( \\operatorname* { m a x } _ { 0 \\leq h ^ { \\prime \\prime } \\leq \\lambda _ { 1 , i } } ( - s _ { 2 , h , i } - t _ { h ^ { \\prime \\prime } , h , i } + s _ { 2 , h ^ { \\prime } , i } + t _ { h ^ { \\prime \\prime } , h ^ { \\prime \\prime } , i } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            681,
+            766,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "169 for $n \\geq 3$ , then the grand state does not violate the cycle constraint under the one-to-one cor  \n170 respondence constraint. The computational cost to obtain the left side of eq. (16) is at most   \n171 $\\begin{array} { r l } {  { \\mathcal { O } ( \\sum _ { i = 1 } ^ { n } n \\lambda _ { 1 , i } \\lambda _ { 2 , i } ( \\lambda _ { 1 , i } + \\lambda _ { 2 , i } ) ) } \\quad } & { { } } \\end{array}$ .   \n172 Theorem 1. If it holds that $\\begin{array} { r } { H _ { \\mathrm { t r a n s } } ( { \\pmb r } ) \\equiv \\sum _ { 1 \\leq i < j < k \\leq n } R ( r _ { i , j } , r _ { j , k } , r _ { i , k } ) > 0 } \\end{array}$ , then there exists   \n173 at least one index pair $1 \\leq i ^ { * } < j ^ { * } \\leq n$ which satisfy $H _ { \\mathrm { t r a n s } } ( r ) > H _ { \\mathrm { t r a n s } } ( r ^ { ( i ^ { * } , j ^ { * } ) } )$ , where   \n174 r(i∗,j∗) = (r(i∗,i,j $R ( r _ { 1 } , r _ { 2 } , r _ { 3 } ) = r _ { 1 } r _ { 2 } ( 1 - r _ { 3 } ) + ( 1 - r _ { 1 } ) ( 1 - r _ { 2 } ) r _ { 3 }$ $r ^ { ( i ^ { * } , j ^ { * } ) } = ( r _ { i , j } ^ { ( i ^ { * } , j ^ { * } ) } ) _ { 1 \\leq i < j \\leq n }$ $r _ { i , j } ^ { ( i ^ { * } , j ^ { * } ) } = 1 - r _ { i , j } \\ i f ( i , j ) = ( i ^ { * } , j ^ { * } )$ $r _ { 1 } , r _ { 2 } , r _ { 3 } \\in \\mathbb { B }$ ,, $r _ { i , j } ^ { ( i ^ { * } , j ^ { * } ) } = r _ { i , j }$ $r = ( r _ { i , j } ) _ { 1 \\leq i < j \\leq n } \\in \\mathbb { B } ^ { \\binom { n } { 2 } }$   \n176 Proof. It does not lose the generality by considering the case of $( r _ { 1 , 2 } , r _ { 2 , 3 } , r _ { 1 , 3 } ) = ( 1 , 1 , 0 )$ . Here, it   \n177 holds that $R ( r _ { 1 , 2 } , r _ { 2 , 3 } , r _ { 1 , 3 } ) - R ( 1 - r _ { 1 , 2 } , r _ { 2 , 3 } , r _ { 1 , 3 } ) + R ( r _ { 1 , 2 } , r _ { 2 , 3 } , r _ { 1 , 3 } ) - R ( r _ { 1 , 2 } , 1 - r _ { 2 , 3 } , r _ { 1 , 3 } ) + R ( r _ { 1 , 2 } , 1 - r _ { 2 , 3 } , r _ { 1 , 3 } )$   \n178 $R ( r _ { 1 , 2 } , r _ { 2 , 3 } , r _ { 1 , 3 } ) - R ( r _ { 1 , 2 } , r _ { 2 , 3 } , 1 - r _ { 1 , 3 } ) = 3 .$ . Additionally, it holds that $R ( r _ { 1 , 2 } , r _ { 2 , i } , r _ { 1 , i } ) - R ( 1 -$   \n179 $r _ { 1 , 2 } , r _ { 2 , i } , r _ { 1 , i } ) + R ( r _ { 2 , 3 } , r _ { 3 , i } , r _ { 2 , i } ) - R ( 1 - r _ { 2 , 3 } , r _ { 3 , i } )$ ${ } _ { 3 } , r _ { 3 , i } , r _ { 2 , i } ) + R ( r _ { 1 , 3 } , r _ { 3 , i } , r _ { 1 , i } ) - R ( 1 - r _ { 1 , 3 } , r _ { 3 , i } , r _ { 1 } )$ ,i) =   \n180 0 for all $3 < i$ . Therefore, it holds that $H _ { \\mathrm { t r a n s } } ( \\pmb { r } ) - H _ { \\mathrm { t r a n s } } ( \\pmb { r } ^ { ( 1 , 2 ) } ) + H _ { \\mathrm { t r a n s } } ( \\pmb { r } ) - H _ { \\mathrm { t r a n s } } ( \\pmb { r } ^ { ( 2 , 3 ) } ) +$   \n181 $H _ { \\mathrm { t r a n s } } ( \\pmb { r } ) - H _ { \\mathrm { t r a n s } } ( \\pmb { r } ^ { ( 1 , 3 ) } ) = 3 .$ . From this result, it holds that $H _ { \\mathrm { t r a n s } } ( \\pmb { r } ) - H _ { \\mathrm { t r a n s } } ( \\pmb { r } ^ { ( i ^ { * } , j ^ { * } ) } ) > 0$ for   \n182 at least one index pair $( i ^ { * } , j ^ { * } ) \\in \\{ ( 1 , 2 ) , ( 2 , 3 ) , ( 1 , 3 ) \\}$ . □ ",
+        "bbox": [
+            143,
+            794,
+            825,
+            840
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            842,
+            825,
+            915
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/a7c9856d1d949d393dd0eb80d65770a55140d7b9782ff083a2109008e080a453.jpg",
+        "table_caption": [
+            "Table 1: The benchmark networks from Bayesian network repository. ",
+            "Algorithm 2 Greedy Candidate Parent Set Identification "
+        ],
+        "table_footnote": [
+            "The average for 10 simulated datasets. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Name</td><td rowspan=\"2\">n</td><td rowspan=\"2\">m</td><td rowspan=\"2\">∑=1 |IIil n</td><td rowspan=\"2\">∑=1 βi( -1)</td><td colspan=\"3\">Ωi=1X n *</td></tr><tr><td>N=100</td><td>N= 1000</td><td>N = 10000</td></tr><tr><td>insurance</td><td>27</td><td>3</td><td>52</td><td>984</td><td>353</td><td>883</td><td>4036</td></tr><tr><td>water</td><td>32</td><td>5</td><td>66</td><td>10083</td><td>165</td><td>216</td><td>735</td></tr><tr><td>alarm</td><td>37</td><td>4</td><td>46</td><td>509</td><td>1829</td><td>2272</td><td>9081</td></tr><tr><td>barley</td><td>48</td><td>4</td><td>84</td><td>114005</td><td>181</td><td>310</td><td>1552</td></tr><tr><td>hailfinder</td><td>56</td><td>4</td><td>66</td><td>2656</td><td>144</td><td>692</td><td>4277</td></tr><tr><td>hepar2</td><td>70</td><td>6</td><td>123</td><td>1453</td><td>4837</td><td>665</td><td>4782</td></tr></table>",
+        "bbox": [
+            178,
+            112,
+            816,
+            244
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            284,
+            826,
+            392
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "183 6 Experimental Results ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            409,
+            385,
+            426
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To validate the performance of our approach, we use 10 simulated datasets for each instance size $N = 1 0 0 , 1 0 0 0 , 1 0 0 0 0$ and each benchmark network. The benchmark networks are discrete networks from Bayesian network repository 1. The score function is the BDeu score with $\\alpha = 1$ . It is often infeasible to identify exact candidate parent sets by searching the power set $\\mathcal { P } ( \\mathcal { X } \\backslash \\{ X _ { i } \\} )$ in a realistic timeframe. We use the candidate parent sets from algorithm 2. Note that the candidate parent sets depend on the heuristic search algorithms, but we do not focus on their performance in this study. Table 1 displays the information of benchmark networks. The code to replicate each experiment in this paper is available 2. ",
+        "bbox": [
+            161,
+            440,
+            825,
+            560
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1: Input: $\\mathcal { D } , i , m$ Output: $\\mathcal { L }$ Initialize: ${ \\mathcal { L } } \\gets \\{ \\phi \\} , { \\mathcal { L } } ^ { \\prime } \\gets \\{ \\phi \\} , { \\mathcal { L } } ^ { \\prime \\prime } \\gets \\phi$   \n2: for $d = 1$ to $m$ do   \n3: for $W$ in $\\mathcal { L } ^ { \\prime }$ do   \n4: for $X$ in $\\chi \\setminus \\{ X _ { i } \\} \\setminus W$ do   \n5: if $S _ { i } ( W ^ { \\prime } \\mid \\mathcal { D } ) < S _ { i } ( W \\cup \\{ X \\} \\mid \\mathcal { D } )$ for all $W ^ { \\prime } \\subset W \\cup \\{ X \\} , W ^ { \\prime } \\in { \\mathcal { L } }$ then   \n6: ${ \\mathcal { L } } ^ { \\prime \\prime } \\gets { \\mathcal { L } } ^ { \\prime \\prime } \\cup \\{ W \\cup \\{ X \\} \\}$ .   \n7: if ${ \\mathcal { L } } ^ { \\prime \\prime } \\neq \\phi$ then $\\mathcal { L } \\gets \\mathcal { L } \\cup \\mathcal { L } ^ { \\prime \\prime } , \\mathcal { L } ^ { \\prime }  \\mathcal { L } ^ { \\prime \\prime } , \\mathcal { L } ^ { \\prime \\prime }  \\phi$ else break   \n8: for $W$ in $\\mathcal { L }$ do   \n9: if there exist $W ^ { \\prime } \\subset W$ that satisfies $S _ { i } ( W \\mid \\mathcal { D } ) \\le S _ { i } ( W ^ { \\prime } \\mid \\mathcal { D } )$ then ${ \\mathcal { L } } \\gets { \\mathcal { L } } \\setminus \\{ W \\}$ . ",
+        "bbox": [
+            179,
+            594,
+            769,
+            732
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "192 6.1 Number of Required Bits for Score Component ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            756,
+            542,
+            772
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In comparison to the existing method [O’Gorman et al., 2014], we reduce the number of required bits for the score component by encoding the candidate parent sets directly. While $\\textstyle \\sum _ { i = 1 } ^ { n } \\lambda _ { i }$ candidate parent sets is encoded in our approach, $n ( n - 1 )$ paths plus at most $O ( n ( n - 1 ) ^ { \\frac { m } { 2 } } )$ auxiliary variables for $m > 2$ in the existing method. The left side of table 2 shows the reduction rate of the number of required bits for the score component. Moreover, we reduce the number of required bits for the score component to ${ \\textstyle \\sum _ { i = 1 } ^ { n } } ( \\lambda _ { 1 , i } + \\lambda _ { 2 , i } )$ by decomposing the candidate parent sets in the form of Cartesian products. The right side of table 2 shows that algorithm 1 reduces the number of required bits for the score component although there is some variation among the networks. ",
+        "bbox": [
+            173,
+            782,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/9bd062d18b3ef55c8e5bb42eb932e0f079596c4f7adfd8ed361ffebe48d4050a.jpg",
+        "table_caption": [
+            "Table 2: The reduction rate of the number of required bits for score component. "
+        ],
+        "table_footnote": [
+            "\\* The average ratio for 10 simulated datasets. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Name</td><td colspan=\"3\">£ λi/n(n-1)²</td><td colspan=\"3\">Σ=1 （1,i+λ2,i）/∑=1 1</td></tr><tr><td>N=100</td><td>N=1000</td><td>N = 10000</td><td>N = 100</td><td>N= 1000</td><td>N = 10000</td></tr><tr><td>insurance</td><td>0.09873</td><td>0.24677</td><td>1.12742</td><td>0.61367</td><td>0.47285</td><td>0.32476</td></tr><tr><td>Water</td><td>0.00097</td><td>0.00126</td><td>0.00429</td><td>0.72680</td><td>0.70588</td><td>0.44014</td></tr><tr><td>alarm</td><td>0.03814</td><td>0.04738</td><td>0.18938</td><td>0.45332</td><td>0.35537</td><td>0.21617</td></tr><tr><td>barley</td><td>0.00171</td><td>0.00292</td><td>0.01464</td><td>0.76717</td><td>0.75538</td><td>0.54149</td></tr><tr><td>hailfinder</td><td>0.00085</td><td>0.00409</td><td>0.02525</td><td>0.82773</td><td>0.60178</td><td>0.33365</td></tr><tr><td>hepar2</td><td>0.00021</td><td>0.00003</td><td>0.00021</td><td>0.49694</td><td>0.63346</td><td>0.31284</td></tr></table>",
+        "bbox": [
+            187,
+            112,
+            805,
+            244
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/0e2a828933a4eae3fb9f4dd942541213267e723378a120f59ccbd2c808927665.jpg",
+        "table_caption": [
+            "Table 3: The number of required bits for fully coupled and nearest neighbor annealing processors. "
+        ],
+        "table_footnote": [
+            "\\* The average ratio for 10 simulated datasets. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Name</td><td colspan=\"3\">∑i=1(1,i+ 入2,i）+(2） *</td><td colspan=\"3\">∑=1(入1,i + λ2,i)(入1,i +λ2,i + 1) + (2)</td></tr><tr><td>N= 100</td><td>N =1000</td><td>N = 10000</td><td>N= 100</td><td>N= 1000</td><td>N = 10000</td></tr><tr><td>insurance</td><td>566</td><td>767</td><td>1661</td><td>3375</td><td>9023</td><td>85482</td></tr><tr><td>water</td><td>613</td><td>648</td><td>820</td><td>1434</td><td>1720</td><td>5881</td></tr><tr><td>alarm</td><td>1489</td><td>1472</td><td>2628</td><td>36761</td><td>27985</td><td>169004</td></tr><tr><td>barley</td><td>1247</td><td>1362</td><td>1968</td><td>6758</td><td>3446</td><td>24796</td></tr><tr><td>hailfinder</td><td>1659</td><td>1957</td><td>2967</td><td>2212</td><td>7084</td><td>80578</td></tr><tr><td>hepar2</td><td>4777</td><td>2836</td><td>3910</td><td>449916</td><td>9164</td><td>136939</td></tr></table>",
+        "bbox": [
+            174,
+            297,
+            825,
+            431
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            166,
+            474,
+            821,
+            505
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.2 Selection of Annealing Processor ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            522,
+            441,
+            537
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "From the following discussion, the Fujitsu digital annealer is suitable for our approach from the viewpoint of bit capacity. ",
+        "bbox": [
+            176,
+            550,
+            823,
+            580
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Fully Connected Type. To the best of our knowledge, the bit capacity of the Fujitsu digital annealer is the largest in fully coupled annealing processors. The second generation Fujitsu digital annealer can deal with problems on a scale of 8192 bits [Matsubara et al., 2020]. The left side of table 3 shows that it is possible to encode all the logical conversion results for benchmark networks to the circuit of the digital annealer within bit capacity. ",
+        "bbox": [
+            173,
+            587,
+            825,
+            662
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Nearest Neighbor Type. The number of additional bits required for minor embedding depends on the design of the hardware graphs. Oku et al. 2019 proposed a heuristic minor embedding algorithm for the Hitachi CMOS annealing machine [Masanao et al., 2010]. Using this algorithm, the number of required physical spins when embedding a fully connected graph is $I ^ { 2 } + I$ for $I$ variables. The conversion method proposed in this study has $n$ local fully connected graphs on $\\mathbf { \\Delta } _ { p , q }$ . Therefore, the number of required physical spins must be at least $\\begin{array} { r } { \\sum _ { i = 1 } ^ { n } ( \\lambda _ { 1 , i } + \\lambda _ { 2 , i } ) ( \\lambda _ { 1 , i } + \\lambda _ { 2 , i } + 1 ) + \\binom { n } { 2 } } \\end{array}$ . From the right side of table 3, it is currently infeasible to encode logical conversion results for at least some networks to the circuit of CMOS annealing machine within its 102400 nodes [Sugie et al., 2021]. As far as we know, the bit capacity of the Hitachi CMOS annealing machine is the largest in nearest neighbor annealing processors. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            820
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.3 Score Maximization ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            839,
+            352,
+            853
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate the performance of Fujitsu digital annealer for score-based Bayesian network structure learning using the conversion results of $N = 1 0 0 0 0$ simulated datasets. The running time for each simulated dataset is 6000 [s]. ",
+        "bbox": [
+            161,
+            867,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/4b44701b9cc855182e35704f11ec0fbc3d89db610c0991e089d4b455ff631577.jpg",
+        "image_caption": [
+            "Figure 2: Results of score maximization by the baseline algorithms. For each simulated dataset and each baseline algorithm, we normalized $\\begin{array} { r } { \\sum _ { i = 1 } ^ { \\bar { n } } ( \\log S ^ { ( i ) } ( \\Pi _ { i } \\vert \\mathcal { \\bar { D } } ) - \\log S ^ { ( i ) } ( \\phi \\vert \\mathcal { D } ) ) } \\end{array}$ by dividing it by the corresponding value of the Fujitsu digital annealer. In this experiment, we used the second-generation Fujitsu digital annealer. SA : simulated annealing, OBS : ordering-based search, ASOBS : acyclic selection ordering-based search. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            93,
+            803,
+            340
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Baselines. We compare the results obtained by the digital annealer with those of three heuristic algorithms. One algorithm is the simulated annealing algorithm [Heckerman et al., 1995b] with a QUBO same as the one encoded into the digital annealer. Other algorithms are the ordering space search algorithms, i.e., ordering-based search and acyclic selection ordering-based search. For a fair comparison, the running time of the simulated annealing algorithm for each simulated dataset is 6000 [s] and that of the ordering space search algorithms is 6000 [s] plus the running time of algorithm 1. The computing environment is Microsoft Windows 10 Pro, 3.6 GHz Intel Core i9 processor, and 64 GB memory. ",
+        "bbox": [
+            171,
+            462,
+            825,
+            583
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Result. Figure 2 shows that the digital annealer is better than all the baselines for all the simulated datasets from all the benchmark networks. ",
+        "bbox": [
+            173,
+            589,
+            823,
+            619
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            638,
+            299,
+            656
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We proposed a novel approach of converting a score-based Bayesian network structure learning into QUBO. The essence of this approach lies in reducing the number of required bits through the advanced identification of candidate parent sets and their representation as Cartesian products. The Fujitsu digital annealer with our conversion method improved the BDeu score for 27 to 70 variables benchmark networks over existing methods. The bit capacity limitation of annealing processor is being relaxed rapidly 3. Though our approach is still a disadvantage for larger-scale networks, we expect that our proposed algorithms will be effectively applied to larger-scale score-based Bayesian network structure learning in the near future. ",
+        "bbox": [
+            173,
+            671,
+            825,
+            792
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Potential Negative Societal Impacts. The development of annealing processor technology could have an impact on various industry fields. However, the number of companies that have commercialized the API usage of annealing processors is still small. Therefore, there is a concern that the market of annealing processors will not work well and the disparities among stakeholders will be widen. Researchers are required to properly evaluate the value of technology and communicate it to the business side. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            890
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "248 References   \n249 Judea Pearl, editor. Probabilistic Reasoning in Intelligent Systems: Networks of Plausible Inference. Morgan Kaufmann, 1988. Gregory F. Cooper and Edward Herskovits. A bayesian method for the induction of probabilistic networks from data. Journal of Machine Learning, 9(4), 1992. Robert G. Cowell. Conditions under which conditional independence and scoring methods lead to identical selection of bayesian network models. In Jack Breese and Daphne Koller, editors, Proceedings of the 17th Conference on Uncertainty in Artificial Intelligence, pages 91–97. Morgan Kaufmann Publishers, 2001. David M. Chickering, David Heckerman, and Christopher Meek. Large-sample learning of bayesian networks is np-hard. Journal of Machine Learning Research, 20:1287–1330, 2004. Marc Teyssier and Daphne Koller. Ordering-based search: A simple and effective algorithm for learning bayesian networks. In Proceedings of the 21th Conference on Uncertainty in Artificial Intelligence, pages 584–590, 2005. Mauro Scanagatta, Cassio Polpo de Campos, Giorgio Corani, and Marco Zaffalon. Learning bayesian networks with thousands of variables. In Proceedings of the 28th International Conference on Neural Information Processing Systems, pages 1864–1872, 2015. Hidenori Gyoten, Masayuki Hiromoto, and Takashi Sato. Area efficient annealing processor for ising model without random number generator. IEICE Transactions on Information and Systems, E101.D(2):314–323, 2018. Kasho Yamamoto. Research on Annealing Processors for Large-Scale Combinatorial Optimization Problems. PhD thesis, Graduate School of Information Science and Technology Hokkaido University, 2020. Vicky Choi. Minor-embedding in adiabatic quantum computation: I. the parameter setting problem. Quantum Information Processing, 7:193–209, 2008. Vicky Choi. Minor-embedding in adiabatic quantum computation: Ii. minor-universal graph design. Quantum Information Processing, 10:343–352, 2010. Bryan A. O’Gorman, Alejandro Perdomo-Ortiz, Ryan Babbush, Alan Aspuru-Guzik, and Vadim Smelyanskiy. Bayesian network structure learning using quantum annealing. The European Physical Journal Special Topics, 225(1), 2014.   \n276 Endre Boros and Aritanan Gruber. On quadratization of pseudo-boolean functions. CoRR, abs/1404.6538, 2014.   \n277 Maliheh Aramon, Gili Rosenberg, Elisabetta Valiante, Toshiyuki Miyazawa, Hirotaka Tamura, and Helmut G. Katzgraber. Physics-inspired optimization for quadratic unconstrained problems using a digital annealer. Frontiers in Physics, 7(48), 2019. Wray Buntine. Theory refinement of bayesian networks. In Proceedings of the 7th Conference on Uncertainty in Artificial Intelligence, pages 52–60, 1991. David Heckerman, Dan Geiger, and David M. Chickering. Learning bayesian networks: The combination of knowledge and statistical data. Journal of Machine Learning, 20(3):197–243, 1995a.   \n284 Martin Anthony, Endre Boros, Yves Crama, and Aritanan Gruber. Quadratic reformulations of nonlinear binary optimization problems. Mathematical Programming, 162(1):115–144, 2016. Endre Boros and Peter L. Hamme. Pseudo-boolean optimization. Journal of Discrete Applied Mathematics, 123: 155–225, 2002. Cassio P. de Campos and Qiang Ji. Efficient structure learning of bayesian networks using constraints. Journal of Machine Learning Research, 12:663–689, 2011. Alvaro H. C. Correia, James Cussens, and Cassio de Campos. On pruning for score-based bayesian network structure learning. Journal of Machine Learning Research, 108:2709–2718, 2020. Satoshi Matsubara, Motomu Takatsu, Toshiyuki Miyazawa, Takayuki Shibasaki, Yasuhiro Watanabe, Kazuya Takemoto, and Hirotaka Tamura. Digital annealer for high-speed solving of combinatorial optimization problems and its applications. In Proceedings of the 25th Asia and South Pacific Design Automation Conference, pages 667–672, 2020.   \n296 David Eppstein. Finding large clique minors is hard. Graph Algorithms and Applications, 13(2):197–204, 2009.   \nDaisuke Oku, Kotaro Terada, Masato Hayashi, Masanao Yamaoka, Shu Tanaka, and Nozomu Togawa. A fully-connected ising model embedding method and its evaluation for cmos annealing machines. IEICE Transactions on Information and Systems, E102-D(9):1696–1706, 2019.   \nYamaoka Masanao, Yoshimura Chihiro, Hayashi Masato, Okuyama Takuya, Aoki Hidetaka, and Mizuno Hiroyuki. A 20k-spin ising chip to solve combinatorial optimization problems with cmos annealing. IEEE Journal of Solid-State Circuits, 51(1), 2010.   \nYuya Sugie, Yuki Yoshida, Normann Mertig, Takashi Takemoto, Hiroshi Teramoto, Atsuyoshi Nakamura, Ichigaku Takigawa, Shin ichi Minato, Masanao Yamaoka, and Tamiki Komatsuzaki. Minor-embedding heuristics for large-scale annealing processors with sparse hardware graphs of up to 102,400 nodes. Soft Computing, 2021.   \nDaphne Koller and Nir Friedman, editors. Probabilistic Graphical Models: Principles and Techniques. The MIT Press, Cambridge, Massachusetts, 2009.   \nDavid Heckerman, Dan Geiger, and David M. Chickering. Learning bayesian networks: Search methods and experimental results. In Preliminary Papers of the 5th International Workshop on Artificial, pages 112–128, 1995b. ",
+        "bbox": [
+            145,
+            56,
+            830,
+            912
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            90,
+            826,
+            323
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            347,
+            254,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            372,
+            330,
+            386
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See section 7.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] See section 7.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            240,
+            390,
+            825,
+            462
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            465,
+            467,
+            479
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] See section 4.   \n(b) Did you include complete proofs of all theoretical results? [Yes] See section 5. ",
+        "bbox": [
+            238,
+            483,
+            769,
+            512
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            516,
+            377,
+            529
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] in the supplemental material   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See section 6.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See fig. 2.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See section 6.3. ",
+        "bbox": [
+            240,
+            534,
+            825,
+            642
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            210,
+            647,
+            767,
+            660
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] in the supplemental material   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            240,
+            665,
+            825,
+            763
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            227,
+            767,
+            661,
+            781
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            240,
+            785,
+            825,
+            867
+        ],
+        "page_idx": 10
+    }
+]

parse/train/KbV-UZRKb3g/KbV-UZRKb3g.md

@@ -0,0 +1,225 @@
+# Understanding and Improving Early Stopping for Learning with Noisy Labels
+
+Yingbin Bai1∗ Erkun Yang2∗ Bo Han3 Yanhua Yang2 Jiatong Li4 Yinian Mao4 Gang Niu5 Tongliang Liu1†
+
+1TML Lab, University of Sydney; 2Xidian University; 3Hong Kong Baptist University; 4Meituan-Dianping Group; 5RIKEN AIP
+
+# Abstract
+
+The memorization effect of deep neural network (DNN) plays a pivotal role in many state-of-the-art label-noise learning methods. To exploit this property, the early stopping trick, which stops the optimization at the early stage of training, is usually adopted. Current methods generally decide the early stopping point by considering a DNN as a whole. However, a DNN can be considered as a composition of a series of layers, and we find that the latter layers in a DNN are much more sensitive to label noise, while their former counterparts are quite robust. Therefore, selecting a stopping point for the whole network may make different DNN layers antagonistically affect each other, thus degrading the final performance. In this paper, we propose to separate a DNN into different parts and progressively train them to address this problem. Instead of the early stopping which trains a whole DNN all at once, we initially train former DNN layers by optimizing the DNN with a relatively large number of epochs. During training, we progressively train the latter DNN layers by using a smaller number of epochs with the preceding layers fixed to counteract the impact of noisy labels. We term the proposed method as progressive early stopping (PES). Despite its simplicity, compared with the traditional early stopping, PES can help to obtain more promising and stable results. Furthermore, by combining PES with existing approaches on noisy label training, we achieve state-of-the-art performance on image classification benchmarks. The code is made public at https://github.com/tmllab/PES.
+
+# 1 Introduction
+
+Deep networks have revolutionized a wide variety of tasks, such as image processing, speech recognition, and language modeling [7], However, this highly relies on the availability of large annotated data, which may not be feasible in practice. Instead, many large datasets with lower quality annotations are collected from online queries [5] or social-network tagging [18]. Such annotations inevitably contain mistakes or label noise. As deep networks have large model capacities, they can easily memorize and eventually overfit the noisy labels, leading to poor generalization performance [36]. Therefore, it is of great importance to develop a methodology that is robust to noisy annotations.
+
+Existing methods on learning with noisy labels (LNL) can be mainly categorized into two groups: model-based and model-free algorithms. Methods in the first category mainly model noisy labels with the noise transition matrix [24, 34, 33, 30]. With perfectly estimated noise transition matrix, models trained with corrected losses can approximate to the models trained with clean labels. However, current methods are usually fragile to estimate the noise transition matrix for heavy noisy data and are also hard to handle a large number of classes [9]. The second type explores the dynamic process of optimization policies, which relates to the memorization effect−deep neural networks tend to first memorize and fit majority (clean) patterns and then overfit minority (noisy) patterns [2]. Recently, based on this phenomenon, many methods [9, 26, 15, 16, 29] have been proposed and achieved promising performance.
+
+![](images/c7512ec26780dca9b15dc452cb391a4d5b9e7d1c3d1347ce8d597d9d4f66ce84.jpg)  
+Figure 1: We train a ResNet-18 model on CIFAR-10 with three types of noisy labels and evaluate the impact of noisy labels on the representations from the 9-th layer, the 17-th layer, and the final layer. The X-axis is the number of epochs for the first block of the network. The curves present the mean of five runs and the best performances are indicated with dotted vertical lines.
+
+To exploit the memorization effect, when the double descent phenomenon [3, 22, 11] cannot be guaranteed to occur, a core issue is to study when to stop the optimization of the network. While stopping the training for too few epochs can avoid overfitting to noisy labels, it can also make the network underfit to clean labels. Current methods [25, 23] usually adopt an early stopping strategy, which decides the stopping point by considering the network as a whole. However, since DNNs are usually optimized with stochastic gradient descent (SGD) with backpropagation, supervisory signals will gradually propagate through the whole network from latter layers (i.e., layers that are closer to output layers) to former layers (i.e., layers that are closer to input layers). Noting that the output layer is followed by the empirical risk in the optimization procedure. We hypothesize that noisy labels may have more severe impacts for the latter layers, which is different from current methods [9, 15] that usually stop the training of the whole network at once.
+
+To empirically verify the above hypothesis, we analyze the impact of noisy labels on representations from different layers with different training epochs. To quantitatively measure the impact of noisy labels from intermediate layers, we first train the whole network on noisy data with different training epochs and fix the parameters for the selected layer and its previous layers. We then reinitialize and optimize the rest layers with clean data, and the final classification performance is adopted to evaluate the impact of noisy labels. For the final layer, we directly report the overall classification performance. As illustrated in Figure 1, we can see that latter layers always achieve the best performance at relatively smaller epoch numbers and then exhibit stronger performance drops with additional training epochs, which verifies the hypothesis that noisy data may have more severe impacts for latter layers. With this understanding, we can infer that the early stopping, which optimizes the network all at once, may fail to fully exploit the memorization effect and induce sub-optimal performance.
+
+To address the above problem, we propose to optimize a DNN by considering it as a composition of several DNN parts and present a novel progressive early stopping (PES) method. Specifically, we initially train former DNN layers by optimizing them with a relatively large number of epochs. Then, to alleviate the impact of noisy labels for latter layers, we reinitialize and progressively train latter DNN layers by using smaller numbers of epochs with preceding DNN layers fixed. Since different layers are progressively trained with different early stopping epochs, we term the proposed method as progressive early stopping (PES). Despite its simplicity, compared with normal early stopping trick, PES can help to better exploit the memorization effect and obtain more promising and stable results. Moreover, since the model size and training epochs are gradually reduced during the optimization procedure, the training time of PES is only slightly greater than that of the normal early stopping. Finally, by combining PES with existing approaches on noisy label training tasks, we establish new state-of-the-art (SOTA) results on CIFAR-10 and CIFAR-100 with synthetic noise. We also achieve competitive results on one dataset with real-world noise: Clothing-1M [32].
+
+The rest of the paper is organized as follows. In Section 2, we first introduce the proposed progressive early stopping and then present the details of the proposed algorithm by combining our method with existing approaches on noisy label training tasks. Section 3 shows the experimental results of our proposed method. Related works are briefly reviewed in Section 4. Finally, concluding remarks are given in Section 5.
+
+# 2 Proposed Method
+
+Let $D$ be the distribution of a pair of random variables $( X , Y ) \in \mathcal { X } \times \{ 1 , . . . K \}$ , where $\boldsymbol { X }$ indicates the variable of instances, $\mathbf { Y }$ is the variable of labels, $\mathcal { X }$ denotes the feature space, and $K$ is the number of classes. In many real-world problems, examples independently drawn from the distribution $D$ are unavailable. Before being observed, the clean labels are usually randomly corrupted into noisy labels. Let $\tilde { D }$ be the distribution of the noisy example $( X , { \tilde { Y } } )$ , where $\tilde { Y }$ indicates the variable of noisy labels. For label-noise learning, we can only access a sample set $\{ \pmb { x } _ { i } , \tilde { y } _ { i } ) \} _ { i = 1 } ^ { n }$ independently drawn from $\tilde { D }$ . The aim is to learn a robust classifier from the noisy sample set that can classify test instances accurately.
+
+In the following, we first elaborate on the proposed progressive early stopping (PES). Then, based on PES, we provide a learning algorithm that learns with confident examples and semi-supervised learning techniques.
+
+# 2.1 Progressive Early Stopping
+
+When trained with noisy labels, if clean labels are of majority within each noisy class, deep networks tend to first fit clean labels during an early learning stage before eventually memorizing the wrong labels, which can be explained by the memorization effect. Many current methods utilize this property to counteract the influence of noisy labels by stopping the optimization at an early learning phase. Specifically, a deep classifier can be obtained by optimizing the following objective function with a relatively small epoch number $T$ :
+
+$$
+\operatorname* { m i n } _ { \Theta } \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathcal { L } ( f ( x _ { i } ; \Theta ) , \tilde { y } _ { i } ) ,
+$$
+
+where $f ( \cdot ; \Theta )$ is a deep classifier with model parameters $\Theta$ and $\mathcal { L }$ is the cross-entropy loss. When trained with noisy data, early learning regularization (ELR) [16] reveals that, for the most commonly used cross-entropy loss, the gradient is well correlated with the correct direction at the early learning phase. Therefore, with a properly defined small epoch number $T$ , the classifier can have higher accuracy than at initialization. While, if we continue to optimize the deep model after $T$ epochs, the classifier will be able to memorize more noise labels. Therefore, it is critical to select a proper epoch number $T$ to utilize the memorization effect and alleviate the influence of noisy labels.
+
+Current methods typically select the epoch number $T$ by considering the network as a whole. However, as Figure 1 makes clear, the impact of noisy labels on different DNN layers are different, which implies that the traditional early stopping trick, which optimizes the whole network all at once, may make different DNN layers to be antagonistically affected by each other, thus degrading the final model performance. To this end, we propose to separate a DNN into different parts and progressively train layers in different parts with different training epochs. Specifically, assume that the whole network $f ( \cdot ; \Theta )$ can be constituted with $L$ DNN parts
+
+$$
+\begin{array} { l } { z _ { 1 } = f _ { 1 } ( \pmb { x } ; \Theta _ { 1 } ) , } \\ { z _ { l } = f _ { l } ( z _ { l - 1 } ; \Theta _ { l } ) , \quad l = 2 , \ldots , L } \end{array}
+$$
+
+where $f _ { l } ( \cdot ; \Theta _ { l } )$ is the $l$ -th DNN part and $z _ { l }$ is the corresponding output. The output of the last part $z _ { L }$ is the prediction. The network $f ( \cdot ; \Theta )$ can also be represented as $f ( \cdot ; \Theta _ { 1 } , . . . \Theta _ { L } )$ . To counteract the impact of noisy labels, We initially optimize the parameter $\Theta _ { 1 }$ for the first part by training the whole network for $T _ { 1 }$ epochs with the following objective
+
+$$
+\operatorname* { m i n } _ { \Theta _ { 1 } \ldots \Theta _ { k } } \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathcal { L } ( f ( \pmb { x } _ { i } ; \Theta _ { 1 } , \ldots , \Theta _ { L } ) , \tilde { y } _ { i } ) .
+$$
+
+![](images/93c2dd94c2a0f5dd8e852ee49fbcbcd3facdbcf530179d0abf899ddba8541bf1.jpg)  
+Figure 2: Performance of the traditional early stopping trick and the proposed PES on CIFAR-10 with different types of label noise. The lines present the mean of five runs.
+
+Then, we keep the obtained parameter $\Theta _ { 1 } ^ { * }$ fixed, reinitialize and progressively learn the $l$ -th $( l =$ $2 , \ldots , L )$ DNN part with the parameters for preceding DNN parts fixed. The training procedure is conducted with $T _ { l }$ epochs by optimizing the following objective
+
+$$
+\operatorname* { m i n } _ { \Theta _ { l } \ldots \Theta _ { k } } \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathcal { L } ( f ( x _ { i } ; \Theta _ { 1 } ^ { * } , \ldots , \Theta _ { l - 1 } ^ { * } , \Theta _ { l } , \ldots , \Theta _ { L } ) , \tilde { y } _ { i } ) , \quad l = 2 \ldots L
+$$
+
+We gradually optimize the $( l + 1 )$ -th DNN part with the obtained parameter $\Theta _ { l } ^ { * }$ fixed, the optimization is continued until all the parameters have been optimized. As elaborated above, latter DNN parts are more sensitive to noisy labels than their former counterparts. Therefore, for the above initializing optimization in Eq. (3) and the following $L - 1$ steps of optimization in Eq. (4), we gradually reduce the training epochs (i.e. $T _ { 1 } \geq T _ { 2 } \geq \cdot \cdot \cdot \geq T _ { L } )$ to better exploit the memorization effect. After optimization, we can obtain the final network as $f ( \cdot , \Theta ) = \bar { f } ( \cdot ; \Theta _ { 1 } ^ { * } , \ldots , \Theta _ { L } ^ { * } )$ . Since this model is obtained by progressively exploiting the early stopping strategies for different DNN parts, we term the proposed method as progressive early stopping (PES).
+
+To explicitly verify the effectiveness of the proposed PES method, we conduct several pilot experiments, which compare the traditional early stopping and PES with label noise from different types and different levels. The results are illustrated in Figure 2, from which we can see that, compared with models trained with traditional early stopping, models trained with PES can achieve superior classification accuracy with smaller variations in all the cases. Current state-of-the-art methods [15] usually adopt models with the traditional early stopping as base models to distill confident examples and then utilize semi-supervised learning techniques by considering confident examples as labeled data and other noisy examples as unlabeled data to further improve the results. The final performance still heavily relies on the base model trained with noisy labels. By improving the performance of the base model, our method combined with semi-supervised learning techniques is able to establish new state-of-the-art results. In the following subsections, we will elaborate on how to utilize PES to distill confident examples and further combine it with semi-supervised learning techniques.
+
+# 2.2 Learning with Confident Examples
+
+Based on the deep network optimized with progressive early stopping, we can select confident examples to facilitate the model training. Here, confident examples refer to examples that have high probabilities with clean labels. In this paper, we treat examples whose predictions are consistent with given labels as confident examples. In addition, to make the results more robust, we generate two different augmentations for any given input and use the average prediction to decide its predicted label. Formally, we can obtain the confident example set $\mathcal { D } _ { l }$ as
+
+$$
+\begin{array} { c } { \mathcal { D } _ { l } = \{ ( \pmb { x } _ { i } , \tilde { y } _ { i } ) | \tilde { y } _ { i } = \hat { y } _ { i } , i = 1 , \ldots , n \} , } \\ { \hat { y } _ { i } = \underset { k \in \{ 1 , \ldots , K \} } { \arg \operatorname* { m a x } } \ \frac { 1 } { 2 } [ f ^ { k } ( \mathrm { A u g m e n t } ( \pmb { x } _ { i } ) ; \Theta ) + f ^ { k } ( \mathrm { A u g m e n t } ( \pmb { x } _ { i } ) ; \Theta ) ] , } \end{array}
+$$
+
+where Augment $( \cdot )$ indicates normal data augmentation operation including horizontal random flip and random crops, and $f ^ { k } ( x ; \Theta )$ is the predicted probability of $_ { \textbf { \em x } }$ belonging to class $k$ . Note that Augment $\left( \cdot \right)$ is a stochastic transformation, so the two terms in Eq (5) are not identical. The average
+
+Input: Neural network with trainable parameters $\boldsymbol { \Theta } = \{ \Theta _ { 1 } , \dots , \Theta _ { L } \}$ , Noisy training dataset   
+$\{ \bar { \pmb { x } _ { i } } , \tilde { y } _ { i } ) \} _ { i = 1 } ^ { n }$ , Number of training epochs for different part: $T _ { 1 } , \dots , T _ { L }$ , and training epochs $T _ { c }$   
+for refining with confident examples.   
+for $i = 1 , \dots , T _ { 1 }$ do   
+Optimize network parameter $\Theta$ with Eq. (3);   
+for $l = 2$ , . . . , $L$ do Froze $\left\{ \Theta _ { 1 } , \ldots , \Theta _ { l - 1 } \right\}$ and re-initialize $\big \{ \Theta _ { l } , \dots , \Theta _ { L } \big \}$ ; for $i = 1 , \dots , T _ { l }$ do Optimize network parameter $\big \{ \Theta _ { l } , \dots , \Theta _ { L } \big \}$ with Eq. (4);   
+Unfroze $\Theta$ ;   
+for $i = 1 , \dots , T _ { c }$ do Extract confident example set $\mathcal { D } _ { l }$ and unlabeled set $\mathcal { D } _ { u }$ with classifier $f ( \cdot , \Theta )$ by Eq. (7); Training the classifier $f ( \cdot , \Theta )$ with MixMatch loss on $\mathcal { D } _ { l }$ and $\mathcal { D } _ { u }$ ;   
+Evaluate the obtained classifier $f ( \cdot , \Theta )$ .
+
+prediction of augmented examples provides a more stable prediction and is found empirically to improve performance. After obtaining the confident example set, one can easily train a classifier by considering confident examples as clean data. However, since the number of confident examples for different classes can vary greatly, directly training the model with the obtained confident example set may introduce a severe class imbalance problem. To this end, we adopt a weighted classification loss
+
+$$
+\mathcal { L } _ { c } = \sum _ { i = 1 } ^ { N } w _ { y _ { i } } \mathcal { L } _ { p } ( \tilde { y } _ { i } , f ( \pmb { x } _ { i } ; \Theta ) ) ,
+$$
+
+where $w _ { i }$ is the corresponding class weight. Assuming that $\sigma _ { k } = | \{ ( \pmb { x } _ { i } , \tilde { y } _ { i } ) | \tilde { y } _ { i } = k , ( \pmb { x } _ { i } , \tilde { y } _ { i } ) \in \mathcal { D } _ { l } \} |$ denotes the cardinality of the confident example set belonging to the $k$ -th class. Then, we can set $w _ { i } = \sigma _ { i } / ( \sum _ { j = 1 } ^ { K } \sigma _ { j } )$ to indicate the corresponding class importance.
+
+# 2.3 Combining with Semi-Supervised Learning
+
+Training with only confident examples neglects the rest data and may suffer from insufficient training examples. To tackle this problem, we further resort to semi-supervised learning techniques by considering confident examples as labeled data and other noisy examples as unlabeled data. Specifically, the labeled data set and unlabeled data set can be obtained as
+
+$$
+\begin{array} { c } { { \displaystyle { \int } { \mathcal D } _ { l } = \{ ( \boldsymbol x _ { i } , \tilde { y } _ { i } ) | \tilde { y } _ { i } = \hat { y } _ { i } , i = 1 , . . . n \} } } \\ { { \displaystyle { \mathcal D } _ { u } = \{ \boldsymbol x _ { i } | \tilde { y } _ { i } \neq \hat { y } _ { i } , i = 1 , . . . n \} } } \\ { { \displaystyle { \hat { y } _ { i } = \arg \operatorname* { m a x } _ { k \in \{ 1 , . . . K \} } \frac { 1 } { 2 } [ f ^ { k } ( \mathrm { A u g m e n t } ( \boldsymbol x _ { i } ) ; \Theta ) + f ^ { k } ( \mathrm { A u g m e n t } ( \boldsymbol x _ { i } ) ; \Theta ) ] } , } } \end{array}
+$$
+
+where the labeled data set $\mathcal { D } _ { l }$ is the same as that in Eq (6), and $\mathcal { D } _ { u }$ is the rest unlabeled data set. Similar to [15], we adopt MixMatch [4] as the semi-supervised learning framework to train the final classification models. For more details about semi-supervised learning, we refer to [4]. The whole learning algorithm is summarized in Algorithm 1.
+
+# 3 Experiments
+
+# 3.1 Datasets and Implementation Details
+
+Datasets: We evaluate our method on two synthetic datasets, CIFAR-10 and CIFAR-100 [12] with different levels of symmetric, pairflip, and instance-dependent label noise (abbreviated as instance label noise) and a real-world dataset Clothing-1M [32]. Both CIFAR-10 and CIFAR-100 contain $5 0 \mathrm { k }$ training images and $1 0 \mathrm { k }$ test images of size $3 2 \times 3 2$ . Following previous works [9, 31, 16, 29], symmetric noise is generated by uniformly flipping labels for a percentage of the training dataset to all possible labels. Pairflip noise flips noisy labels into their adjacent class. And, instance noise is generated by image features. More details about the synthetic label noise are given in the supplementary material. For the flipping rate, it can include [9, 31] or ex-include [15, 16] true labels. We use the flipping rate including correct labels in Table 3 to compare with results in [15], and use without correct labels in the rest of the experiments. Clothing-1M [32] is a large-scale dataset with real-world noisy labels, whose images are clawed from the online shopping websites, and labels are generated based on surrounding texts. It contains 1 million training images, and $1 5 \mathrm { k }$ validation images, and 10k test images with clean labels.
+
+Table 1: Preliminary analysis of the performance and the quality of extracted confident examples on CIFAR-10. The mean and standard deviation are computed over five runs.   
+
+<table><tr><td rowspan=1 colspan=1>Metrics</td><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>Sym-20%</td><td rowspan=1 colspan=1>Sym-50%</td><td rowspan=1 colspan=1>Pair-45%</td><td rowspan=1 colspan=1>Inst-20%</td><td rowspan=1 colspan=1>Inst-40%</td></tr><tr><td rowspan=1 colspan=1>Test Accuracy</td><td rowspan=1 colspan=1>Early StoppingPES</td><td rowspan=1 colspan=1>82.55±2.4685.87±1.59</td><td rowspan=1 colspan=1>70.76±1.2475.87±1.33</td><td rowspan=1 colspan=1>60.62±5.5962.40±2.34</td><td rowspan=1 colspan=1>84.41±0.9086.58±0.45</td><td rowspan=1 colspan=1>74.73±2.6577.07±1.18</td></tr><tr><td rowspan=1 colspan=1>Label Precision</td><td rowspan=1 colspan=1>Early StoppingPES</td><td rowspan=1 colspan=1>98.81±0.1598.96±0.09</td><td rowspan=1 colspan=1>94.65±0.1995.46±0.14</td><td rowspan=1 colspan=1>72.53±5.2672.99±2.27</td><td rowspan=1 colspan=1>98.70±0.4398.52±0.19</td><td rowspan=1 colspan=1>90.77±1.8790.63±0.92</td></tr><tr><td rowspan=1 colspan=1>Label Recall</td><td rowspan=1 colspan=1>Early StoppingPES</td><td rowspan=1 colspan=1>88.51±2.2692.67±1.43</td><td rowspan=1 colspan=1>75.18±1.0081.03±1.83</td><td rowspan=1 colspan=1>67.84±5.0671.06±2.27</td><td rowspan=1 colspan=1>90.37±1.0193.24±0.60</td><td rowspan=1 colspan=1>82.15±3.1785.91±0.68</td></tr></table>
+
+Baselines: Semi-supervised learning may strongly boost the performance, we separately compare our method with approaches with or without semi-supervised learning. For the comparison with baselines with semi-supervised learning, we combine our proposed method with MixMatch used in [15] as indicated in Subsection 2.3. (1) Approaches without semi-supervised learning: Co-teaching [9], Forward [24], Joint Optim [25], T-revision [31], DMI [34], and CDR [29]. (2) Methods with semi-supervised learning: M-correction [1], DivideMix [15], and $\mathrm { E L R + }$ [16]. We also adopt standard training with cross-entropy (CE) and MixUp [37] as baselines to show improvements.
+
+Network structure and optimization: Our method is implemented by PyTorch v1.6. Baseline methods are implemented based on public codes with hyper-parameters set according to the original papers. For DivideMix and $\mathrm { E L R + }$ , we evaluate the test accuracy with the first network. To better demonstrate the robustness of our algorithm, we keep the hyper-parameters fixed for different types of label noise. More technique details are given in the supplementary material.
+
+For experiments without semi-supervised learning, we follow [31], and use ResNet-18 [10] for CIFAR-10 and ResNet-34 for CIFAR-100. We split networks into three parts, the layers above block 4 as part 1, block 4 of ResNet as part 2, and the final layer as part 3. $T _ { 1 }$ is defined as 25 for CIFAR-10 and 30 for CIFAR-100, $T _ { 2 }$ as 7, and $T _ { 3 }$ as 5. The network is trained for 200 epochs and SGD with 0.9 momentum is used. The initial learning rate is set to 0.1 and decayed with a factor of 10 at the 100th and 150th epoch respectively, and a weight decay is set to $1 0 ^ { - 4 }$ . For $T _ { 2 }$ and $T _ { 3 }$ , we employ an Adam optimizer with a learning rate of $1 0 ^ { - 4 }$ .
+
+For experiments with semi-supervised learning, we follow the setting of [15] with PreAct Resnet-18. We set the final layer as part 2, the rest as part 1. $T _ { 1 }$ is defined as 20 for CIFAR-10 and 35 for CIFAR-100, and $T _ { 2 }$ as 5. The network is trained for 300 epochs. For optimization, we use a single cycle of cosine annealing [19], and the learning rate begins from $2 \times \mathrm { \bar { 1 0 ^ { - 2 } } }$ and ends at $2 \times 1 0 ^ { - 4 }$ , with a weight decay of $5 \times 1 0 ^ { - 4 }$ . An Adam optimizer is adopted with a learning rate of $1 0 ^ { - 4 }$ for $T _ { 2 }$ . For hyper-parameters from MixMatch, we set them according to the original paper [4].
+
+For Clothing-1M [32], we follow the previous work [25], and employ a ResNet-50 [10] pre-trained on ImageNet [13]. We set the final layer as part 2, the rest as part 1. $T _ { 1 }$ and $T _ { 2 }$ are defined as 20 and 7 respectively. The network is trained with CE loss for 50 epochs and SGD is used with 0.9 momentum and a weight decay of $1 0 ^ { - 3 }$ . The learning rate is $5 \times 1 0 ^ { - 3 }$ and decayed by a factor of 10 at the 20th and 30th epoch respectively. We employ an Adam optimizer with a learning rate of $5 \times 1 0 ^ { - 6 }$ for $T _ { 2 }$
+
+# 3.2 Preliminary Experiments
+
+In Figure 2, we can observe that with the PES trick, the performance of classifiers is generally improved compared with that the traditional early stopping trick. In this section, we further carefully analyze the quality of extracted labels by examining them from three aspects, i.e., test accuracy, label precision, and label recall. Here, label precision indicates the ratio of the number of extracted confident examples with correct labels in the total confident example set, and label recall represents the ratio of the number of confident examples with correct labels among the total correctly labeled examples. Specifically, we train a neural network on CIFAR-10 with different kinds and levels of label noise for 25 epochs respectively and report the performance for each case before and after the proposed PES is applied.
+
+Table 2: Comparison with state-of-the-art methods without semi-supervised learning on CIFAR-10 and CIFAR-100. The mean and standard deviation computed over five runs are presented.   
+
+<table><tr><td rowspan="2">Dataset</td><td rowspan="2">Method</td><td colspan="2">Symmetric</td><td>Pairflip</td><td colspan="2">Instance</td></tr><tr><td>20%</td><td>50%</td><td>45%</td><td>20%</td><td>40%</td></tr><tr><td rowspan="8">CIFAR10</td><td>CE</td><td>84.00±0.66</td><td>75.51±1.24</td><td>63.34±6.03</td><td>85.10±0.68</td><td>77.00±2.17</td></tr><tr><td>Co-teaching</td><td>87.16±0.11</td><td>72.80±0.45</td><td>70.11±1.16</td><td>86.54±0.11</td><td>80.98±0.39</td></tr><tr><td>Forward</td><td>85.63±0.52</td><td>77.92±0.66</td><td>60.15±1.97</td><td>85.29±0.38</td><td>74.72±3.24</td></tr><tr><td> Joint Optim</td><td>89.70±0.11</td><td>85.00±0.17</td><td>82.63±1.38</td><td>89.69±0.42</td><td>82.62±0.57</td></tr><tr><td>T-revision</td><td>89.63±0.13</td><td>83.40±0.65</td><td>77.06±6.47</td><td>90.46±0.13</td><td>85.37±3.36</td></tr><tr><td>DMI</td><td>88.18±0.36</td><td>78.28±0.48</td><td>57.60±14.56</td><td>89.14±0.36</td><td>84.78±1.97</td></tr><tr><td>CDR</td><td>89.72±0.38</td><td>82.64±0.89</td><td>73.67±0.54</td><td>90.41±0.34</td><td>83.07±1.33</td></tr><tr><td>Ours</td><td>92.38±0.40</td><td>87.45±0.35</td><td>88.43±1.08</td><td>92.69±0.44</td><td>89.73±0.51</td></tr><tr><td rowspan="8">CIFAR100</td><td>CE</td><td>51.43±0.58</td><td>37.69±3.45</td><td>34.10±2.04</td><td>52.19±1.42</td><td>42.26±1.29</td></tr><tr><td>Co-teaching</td><td>59.28±0.47</td><td>41.37±0.08</td><td>33.22±0.48</td><td>57.24±0.69</td><td>45.69±0.99</td></tr><tr><td>Forward</td><td>57.75±0.37</td><td>44.66±1.01</td><td>27.88±0.80</td><td>58.76±0.66</td><td>44.50±0.72</td></tr><tr><td> Joint Optim</td><td>64.55±0.38</td><td>50.22±0.41</td><td>42.61±0.61</td><td>65.15±0.31</td><td>55.57±0.41</td></tr><tr><td>T-revision</td><td>65.40±1.07</td><td>50.24±1.45</td><td>41.10±1.95</td><td>60.71±0.73</td><td>51.54±0.91</td></tr><tr><td>DMI</td><td>58.73±0.70</td><td>44.25±1.14</td><td>26.90±0.45</td><td>58.05±0.20</td><td>47.36±0.68</td></tr><tr><td>CDR</td><td>66.52±0.24</td><td>55.30±0.96</td><td>43.87±1.35</td><td>67.33±0.67</td><td>55.94±0.56</td></tr><tr><td>Ours</td><td>68.89±0.45</td><td>58.90±2.72</td><td>57.18±1.44</td><td>70.49±0.79</td><td>65.68±1.41</td></tr></table>
+
+Table 3: Comparison with state-of-the-art methods with semi-supervised learning on CIFAR-10 and CIFAR-100 with symmetric label noise from different levels. Results with \* are token from [15]. The mean and standard deviation are computed over three runs.   
+
+<table><tr><td>Dataset</td><td colspan="3">CIFAR-10</td><td colspan="3">CIFAR-100</td></tr><tr><td>Methods /Noise</td><td>Sym-20%</td><td>Sym-50%</td><td>Sym-80%</td><td>Sym-20%</td><td>Sym-50%</td><td>Sym-80%</td></tr><tr><td>CE</td><td>86.5±0.6</td><td>80.6±0.2</td><td>63.7±0.8</td><td>57.9±0.4</td><td>47.3±0.2</td><td>22.3±1.2</td></tr><tr><td>MixUp</td><td>93.2±0.3</td><td>88.2±0.3</td><td>73.3±0.3</td><td>69.5±0.2</td><td>57.1±0.6</td><td>34.1±0.6</td></tr><tr><td>M-correction*</td><td>94.0</td><td>92.0</td><td>86.8</td><td>73.9</td><td>66.1</td><td>48.2</td></tr><tr><td>DivideMix*</td><td>95.2</td><td>94.2</td><td>93.0</td><td>75.2</td><td>72.8</td><td>58.3</td></tr><tr><td>DivideMix</td><td>95.6±0.1</td><td>94.6±0.1</td><td>92.9±0.3</td><td>75.3±0.1</td><td>72.7±0.6</td><td>56.4±0.3</td></tr><tr><td>ELR+</td><td>94.9±0.2</td><td>93.6±0.1</td><td>90.4±0.2</td><td>75.5±0.2</td><td>71.0±0.2</td><td>50.4±0.8</td></tr><tr><td>Ours (Semi)</td><td>95.9±0.1</td><td>95.1±0.2</td><td>93.1±0.2</td><td>77.4±0.3</td><td>74.3±0.6</td><td>61.6±0.6</td></tr></table>
+
+Results in Table 1 clearly show that, compared with the traditional early stopping, PES can help to obtain higher accuracies, precisions, and recalls for most cases. For instance-dependent label noise, PES can achieve higher recall values with comparable label precision values. Note that models with high recall values can help to collect more confident examples, which is critical for learning with confident examples and semi-supervised learning. Therefore, by enhancing the performance of the initial model, PES can help to improve the final classification performance in all cases, which is also verified by the experiments in Section 3.3.
+
+# 3.3 Classification Accuracy Evaluation
+
+Synthetic datasets. We first verify the effectiveness of our proposed method without semi-supervised learning techniques on two synthetic datasets: CIFAR-10 and CIFAR-100. For both of these two datasets, we leave $10 \%$ of data with noisy labels as noisy validation set. Results are presented in Table 2, which shows that our proposed method can consistently outperform all other baselines across various settings by a large margin.
+
+Table 4: Comparison with state-of-the-art methods with semi-supervised learning on CIFAR-10 and CIFAR-100 with instance-dependent and pairflip label noise from different levels. The mean and standard deviation are computed over three runs.   
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=3>CIFAR-10</td><td rowspan=1 colspan=3>CIFAR-100</td></tr><tr><td rowspan=1 colspan=1>Methods/Noise</td><td rowspan=1 colspan=1>Inst-20%</td><td rowspan=1 colspan=1>Inst-40%</td><td rowspan=1 colspan=1>Pair-45%</td><td rowspan=1 colspan=1>Inst-20%</td><td rowspan=1 colspan=1>Inst-40%</td><td rowspan=1 colspan=1>Pair-45%</td></tr><tr><td rowspan=4 colspan=1>CEMixUpDivideMixELR+</td><td rowspan=1 colspan=1>87.5±0.5</td><td rowspan=1 colspan=1>78.9±0.7</td><td rowspan=1 colspan=1>74.9±1.7</td><td rowspan=1 colspan=1>56.8±0.4</td><td rowspan=1 colspan=1>48.2±0.5</td><td rowspan=1 colspan=1>38.5±0.6</td></tr><tr><td rowspan=2 colspan=1>93.3±0.295.5±0.1</td><td rowspan=2 colspan=1>87.6±0.594.5±0.2</td><td rowspan=2 colspan=1>82.4±1.085.6±1.7</td><td rowspan=1 colspan=1>67.1±0.1</td><td rowspan=2 colspan=1>55.0±0.170.9±0.1</td><td rowspan=2 colspan=1>44.2±0.548.2±1.0</td></tr><tr><td rowspan=1 colspan=1>75.2±0.2</td><td rowspan=1 colspan=1>70.9±0.1</td></tr><tr><td rowspan=1 colspan=1>94.9±0.1</td><td rowspan=1 colspan=1>94.3±0.2</td><td rowspan=1 colspan=1>86.1±1.2</td><td rowspan=1 colspan=1>75.8±0.1</td><td rowspan=1 colspan=1>74.3±0.3</td><td rowspan=1 colspan=1>65.3±1.3</td></tr><tr><td rowspan=1 colspan=1>Ours (Semi)</td><td rowspan=1 colspan=1>95.9±0.1</td><td rowspan=1 colspan=1>95.3±0.1</td><td rowspan=1 colspan=1>94.5±0.3</td><td rowspan=1 colspan=1>77.6±0.3</td><td rowspan=1 colspan=1>76.1±0.4</td><td rowspan=1 colspan=1>73.6±1.7</td></tr></table>
+
+Table 5: Compassion with state-of-the-art methods on Clothing-1M. Results of baseline methods are taken from the original papers. ours represent the results obtained by PES with a single network and ours\* indicate the results obtained by PES with an ensemble model.   
+
+<table><tr><td rowspan=1 colspan=1>CE</td><td rowspan=1 colspan=1>Forward</td><td rowspan=1 colspan=1>Joint-Optim</td><td rowspan=1 colspan=1>DMI</td><td rowspan=1 colspan=1>T-revision</td><td rowspan=1 colspan=1>DivideMix*</td><td rowspan=1 colspan=1>ELR+*</td><td rowspan=1 colspan=1>Ours</td><td rowspan=1 colspan=1>Ours*</td></tr><tr><td rowspan=1 colspan=1>69.21</td><td rowspan=1 colspan=1>69.84</td><td rowspan=1 colspan=1>72.16</td><td rowspan=1 colspan=1>72.46</td><td rowspan=1 colspan=1>74.18</td><td rowspan=1 colspan=1>74.76</td><td rowspan=1 colspan=1>74.81</td><td rowspan=1 colspan=1>74.64</td><td rowspan=1 colspan=1>74.99</td></tr></table>
+
+![](images/61ae512b2fb46bee07bd5e6157d516e400cd564030c729a91354232a89157ebe.jpg)  
+Figure 3: Sensitivity analysis for different training iteration numbers: $T _ { 2 }$ and $T _ { 3 }$
+
+Table 3 and Table 4 present the mean accuracy and standard deviation for our method and all baselines on CIFAR-10 and CIFAR-100, respectively. From the results, we can get that the proposed method can outperform all baselines in all cases. For pairflip label noise, the advantages of our proposed method become more apparent, and it significantly outperforms state-of-the-art methods by over $8 \%$ on both CIFAR-10 and CIFAR-100. These empirical results support our proposal that PES can improve the quality of selected confident examples, which helps improve performance and reduce the variance of the final classifier.
+
+Real-world dataset. We evaluate the performance of the proposed method on a real-world dataset with Clothing-1M [32] and select methods such as CE, Forward, Joint-Optim, DMI, and T-revision, which use a single network, and also methods such as DivideMix and $\mathrm { E L R + }$ , which adopt an ensemble model with two different networks, as baselines. We also report the results for the proposed PES with a single network as ours and the results for PES, which ensembles two networks, as ours\*. The overall results are reported in Table 5, from which we can observe that the proposed PES with a single network can outperform all baselines using a single network. And with an ensemble model, which contains two different networks, our method can outperform all the adopted baselines. These results clearly demonstrate that, by improving the performance of the initial classification network, our method is more flexible to handle such real-world noise problems.
+
+# 3.4 Sensitivity Analysis
+
+In this section, we investigate the hyper-parameter sensitivity for the training iteration number $T _ { 2 }$ and $T _ { 3 }$ , respectively. We firstly analyze the training epoch number for the second DNN part by varying $T _ { 2 }$ from the range of [0, 10]. The results are illustrated in Figure 3a, from which can find that, with the increasing of $T _ { 2 }$ , the performance of PES first increase and then decrease in all the cases except for $45 \%$ Pairflip noise on the CIFAR-10 dataset. While the model achieves the best performance with $T _ { 2 }$ as 7 for all types of noisy labels. Then we fix $T _ { 2 }$ as 7, and analyze the impact of the third DNN part by varying $T _ { 3 }$ from the range of [0, 10]. The results are shown in Figure 3b. Although the performance variance for different $T _ { 3 }$ is smaller than that for $T _ { 2 }$ , we can still observe that the best performance can be obtained when $T _ { 3 }$ is set as 5. More importantly, from these two figures, we can get that both $T _ { 2 }$ and $T _ { 3 }$ are robust to the different types of noisy labels.
+
+Table 6: Training time comparison for baselines on CIFAR-10 with $50 \%$ Symmetric label noise.   
+
+<table><tr><td rowspan=1 colspan=1>CE</td><td rowspan=1 colspan=1>Co-teaching</td><td rowspan=1 colspan=1>CDR</td><td rowspan=1 colspan=1>T-revision</td><td rowspan=1 colspan=1>ELR+</td><td rowspan=1 colspan=1>DivideMix</td><td rowspan=1 colspan=1>Ours</td><td rowspan=1 colspan=1>Ours (Semi)</td></tr><tr><td rowspan=1 colspan=1>0.9h</td><td rowspan=1 colspan=1>1.5h</td><td rowspan=1 colspan=1>3.0h</td><td rowspan=1 colspan=1>3.5h</td><td rowspan=1 colspan=1>2.2h</td><td rowspan=1 colspan=1>5.5h</td><td rowspan=1 colspan=1>1.0h</td><td rowspan=1 colspan=1>3.1h</td></tr></table>
+
+# 3.5 Training Time Comparison
+
+In this section, we compare the training time of our method and other state-of-the-art baselines. All the experiments are conducted on a server with a single Nvidia V100 GPU. The training times for all the methods are reported in Table 6, from which we can get that our algorithm with cross-entropy loss achieves the fastest speed across all baselines, only about 1 hour. Our method combining with MixMatch [4] is also fast, only a little more than half of the training time of DivideMix. The time of $\mathrm { E L R + }$ [16] shows superior, but $\mathrm { E L R + }$ trains the network with fewer epochs, with 200 epochs compared with ours for 300 epochs.
+
+# 4 Related work
+
+Learning with noisy data has been well studied [17, 6, 21, 27, 20]. Current works can be mainly categorized into two groups: model-based and model-free methods. In this section, we briefly review some closely related works.
+
+The first type models the relationship between clean labels and noisy labels by estimating the noise transition matrix and build a loss function to correct the loss [24, 30, 35, 28]. [24] first combines algorithms for estimating the noise rates and loss correction techniques together and introduces two alternative procedures for loss correction. It also proves that both of the two procedures enjoy formal robustness guarantees w.r.t. the clean data distribution. DMI [34] proposes an information-theoretic loss function, which utilizes Shannon’s mutual information and is robustness to different kinds of label noise. T-revision [31] estimates the noise transition matrix without anchor points by adding a fine-tuned slack variables. Although these methods have made certain progress, they are usually fragile to estimate the noise transition matrix for heavy noisy data and are also hard to handle a large number of classes. Therefore, in this paper, we mainly focus on the model-free methods.
+
+The second strand mainly counteracts noisy labels by exploiting the memorization effect that deep networks tend to first memorize and fit majority (clean) patterns and then overfit minority (noisy) patterns [2]. To exploit this property, Co-teaching [9] employs two networks with different initialization and uses small loss to select confident examples. M-correction [1] uses two Gaussian Mixture Models to identify confident examples, instead of using networks themselves. DivideMix [15] extends Co-teaching [9] and employs two Beta Mixture Model to select confident examples. MixMatch [4] is then adopted to leverage unconfident examples with a semi-supervised learning framework. All the above methods exploit the memorization effect by considering the adopted network as a whole. Recently, [14] shows that networks training with noisy labels can produce good representations, if the structure of networks suits the targeted tasks. Our method further explains that noisy labels have different impacts for different layers in a DNN. And latter layers will receive earlier and more severe impact than their former counterparts. Therefore, by considering a DNN as a composition of several layers and training different layers with different epochs, our method is able to better exploit the memorization effect and achieve superior performance.
+
+# 5 Conclusion
+
+In this work, we provide a progressive early stopping (PES) method to better exploit the memorization effect of deep neural networks (DNN) for noisy-label learning. We first find that the impact of noisy labels for former layers in a DNN is much less and later than that for latter DNN layers, and then build upon this insight to propose the PES method, which separates a DNN into different parts and progressively train each part to counteract the different impacts of noisy labels for different DNN layers. To show that PES can boost the performance of state-of-the-art methods, we conduct extensive experiments across multiple synthetic and real-world noisy datasets and demonstrate that the proposed PES can help to obtain substantial performance improvements compared to current state-of-the-art baselines. The main limitation of our method lies in that, by splitting a DNN into different parts, PES introduces several additional hyper-parameters that need to be tuned carefully. In the future, we will extend the work in the following aspects. First, we will study other mechanisms that distinguishing desired and undesired memorization rather than early stopping, e.g., the gradient ascent trick [8]. Second, we are interested in combining PES with interesting ideas from semi-supervised learning and unsupervised learning.
+
+# Acknowledgments and Disclosure of Funding
+
+YB was partially supported by Agriculture Consultant and Smart Management. BH was supported by the RGC Early Career Scheme No. 22200720, NSFC Young Scientists Fund No. 62006202 and HKBU CSD Departmental Incentive Grant. YY was partially supported by Key Research and Development Program of Shaanxi (ProgramNo. 2021ZDLGY01-03). GN was supported by JST AIP Acceleration Research Grant Number JPMJCR20U3, Japan. TL was partially supported by Australian Research Council Projects DE-190101473 and IC-190100031.
+
+References   
+[1] Eric Arazo, Diego Ortego, Paul Albert, Noel E. O’Connor, and Kevin McGuinness. Unsupervised label noise modeling and loss correction. In ICML, pages 312–321, 2019.   
+[2] Devansh Arpit, Stanislaw Jastrzebski, Nicolas Ballas, David Krueger, Emmanuel Bengio, Maxinder S. Kanwal, Tegan Maharaj, Asja Fischer, Aaron C. Courville, Yoshua Bengio, and Simon Lacoste-Julien. A closer look at memorization in deep networks. In ICML, pages 233–242, 2017.   
+[3] Mikhail Belkin, Daniel Hsu, Siyuan Ma, and Soumik Mandal. Reconciling modern machine-learning practice and the classical bias–variance trade-off. Proceedings of the National Academy of Sciences, 116(32):15849–15854, 2019.   
+[4] David Berthelot, Nicholas Carlini, Ian J. Goodfellow, Nicolas Papernot, Avital Oliver, and Colin Raffel. Mixmatch: A holistic approach to semi-supervised learning. In NeurIPS, pages 5050–5060, 2019.   
+[5] Youngchul Cha and Junghoo Cho. Social-network analysis using topic models. In SIGIR, pages 565–574, 2012.   
+[6] Jacob Goldberger and Ehud Ben-Reuven. Training deep neural-networks using a noise adaptation layer. In ICLR, 2017.   
+[7] Ian Goodfellow, Yoshua Bengio, Aaron Courville, and Yoshua Bengio. Deep learning. The MIT Press, 2016.   
+[8] Bo Han, Gang Niu, Xingrui Yu, Quanming Yao, Miao Xu, Ivor W. Tsang, and Masashi Sugiyama. SIGUA: forgetting may make learning with noisy labels more robust. In ICML, pages 4006–4016, 2020.   
+[9] Bo Han, Quanming Yao, Xingrui Yu, Gang Niu, Miao Xu, Weihua Hu, Ivor Tsang, and Masashi Sugiyama. Co-teaching: Robust training of deep neural networks with extremely noisy labels. In NeurIPS, pages 8527–8537, 2018.   
+[10] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pages 770–778, 2016.   
+[11] Takashi Ishida, Ikko Yamane, Tomoya Sakai, Gang Niu, and Masashi Sugiyama. Do we need zero training loss after achieving zero training error? In ICML, pages 4604–4614, 2020.   
+[12] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, 2009.   
+[13] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NeurIPS, pages 1097–1105, 2012.   
+[14] Jingling Li, Mozhi Zhang, Keyulu Xu, John P. Dickerson, and Jimmy Ba. Noisy labels can induce good representations. arXiv preprint arXiv:2012.12896, 2020.   
+[15] Junnan Li, Richard Socher, and Steven C. H. Hoi. Dividemix: Learning with noisy labels as semi-supervised learning. In ICLR, 2020.   
+[16] Sheng Liu, Jonathan Niles-Weed, Narges Razavian, and Carlos Fernandez-Granda. Early-learning regularization prevents memorization of noisy labels. In NeurIPS, pages 20331–20342, 2020.   
+[17] Tongliang Liu and Dacheng Tao. Classification with noisy labels by importance reweighting. IEEE Transactions on pattern analysis and machine intelligence, 38(3):447–461, 2016.   
+[18] Wei Liu, Yu-Gang Jiang, Jiebo Luo, and Shih-Fu Chang. Noise resistant graph ranking for improved web image search. In CVPR, pages 849–856, 2011.   
+[19] Ilya Loshchilov and Frank Hutter. SGDR: stochastic gradient descent with warm restarts. In ICLR, 2017.   
+[20] Xingjun Ma, Hanxun Huang, Yisen Wang, Simone Romano, Sarah M. Erfani, and James Bailey. Normalized loss functions for deep learning with noisy labels. In ICML, pages 6543–6553, 2020.   
+[21] Xingjun Ma, Yisen Wang, Michael E. Houle, Shuo Zhou, Sarah M. Erfani, Shu-Tao Xia, Sudanthi N. R. Wijewickrema, and James Bailey. Dimensionality-driven learning with noisy labels. In ICML, pages 3361–3370, 2018.   
+[22] Preetum Nakkiran, Gal Kaplun, Yamini Bansal, Tristan Yang, Boaz Barak, and Ilya Sutskever. Deep double descent: Where bigger models and more data hurt. In ICLR, 2020.   
+[23] Duc Tam Nguyen, Chaithanya Kumar Mummadi, Thi-Phuong-Nhung Ngo, Thi Hoai Phuong Nguyen, Laura Beggel, and Thomas Brox. SELF: learning to filter noisy labels with self-ensembling. In ICLR, 2020.   
+[24] Giorgio Patrini, Alessandro Rozza, Aditya Krishna Menon, Richard Nock, and Lizhen Qu. Making deep neural networks robust to label noise: A loss correction approach. In CVPR, pages 2233–2241, 2017.   
+[25] Daiki Tanaka, Daiki Ikami, Toshihiko Yamasaki, and Kiyoharu Aizawa. Joint optimization framework for learning with noisy labels. In CVPR, pages 5552–5560, 2018.   
+[26] Yisen Wang, Weiyang Liu, Xingjun Ma, James Bailey, Hongyuan Zha, Le Song, and Shu-Tao Xia. Iterative learning with open-set noisy labels. In CVPR, pages 8688–8696, 2018.   
+[27] Yisen Wang, Xingjun Ma, Zaiyi Chen, Yuan Luo, Jinfeng Yi, and James Bailey. Symmetric cross entropy for robust learning with noisy labels. In ICCV, pages 322–330, 2019.   
+[28] Songhua Wu, Xiaobo Xia, Tongliang Liu, Bo Han, Mingming Gong, Nannan Wang, Haifeng Liu, and Gang Niu. Class2simi: A noise reduction perspective on learning with noisy labels. In ICML, pages 11285–11295, 2021.   
+[29] Xiaobo Xia, Tongliang Liu, Bo Han, Chen Gong, Nannan Wang, Zongyuan Ge, and Yi Chang. Robust early-learning: Hindering the memorization of noisy labels. In ICLR, 2021.   
+[30] Xiaobo Xia, Tongliang Liu, Bo Han, Nannan Wang, Mingming Gong, Haifeng Liu, Gang Niu, Dacheng Tao, and Masashi Sugiyama. Part-dependent label noise: Towards instance-dependent label noise. In NeurIPS, pages 7597–7610, 2020.   
+[31] Xiaobo Xia, Tongliang Liu, Nannan Wang, Bo Han, Chen Gong, Gang Niu, and Masashi Sugiyama. Are anchor points really indispensable in label-noise learning? In NeurIPS, pages 6835–6846, 2019.   
+[32] Tong Xiao, Tian Xia, Yi Yang, Chang Huang, and Xiaogang Wang. Learning from massive noisy labeled data for image classification. In CVPR, pages 2691–2699, 2015.   
+[33] Qizhe Xie, Zihang Dai, Eduard H. Hovy, Thang Luong, and Quoc Le. Unsupervised data augmentation for consistency training. In NeurIPS, pages 6256–6268, 2020.   
+[34] Yilun Xu, Peng Cao, Yuqing Kong, and Yizhou Wang. L_dmi: A novel information-theoretic loss function for training deep nets robust to label noise. In NeurIPS, pages 6222–6233, 2019.   
+[35] Yu Yao, Tongliang Liu, Bo Han, Mingming Gong, Jiankang Deng, Gang Niu, and Masashi Sugiyama. Dual T: reducing estimation error for transition matrix in label-noise learning. In NeurIPS, pages 7260–7271, 2020.   
+[36] Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In ICLR, 2016.   
+[37] Hongyi Zhang, Moustapha Cissé, Yann N. Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In ICLR, 2018.

parse/train/KbV-UZRKb3g/KbV-UZRKb3g_content_list.json

@@ -0,0 +1,976 @@
+[
+    {
+        "type": "text",
+        "text": "Understanding and Improving Early Stopping for Learning with Noisy Labels ",
+        "text_level": 1,
+        "bbox": [
+            199,
+            122,
+            800,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yingbin Bai1∗ Erkun Yang2∗ Bo Han3 Yanhua Yang2 Jiatong Li4 Yinian Mao4 Gang Niu5 Tongliang Liu1† ",
+        "bbox": [
+            292,
+            224,
+            710,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1TML Lab, University of Sydney; 2Xidian University; 3Hong Kong Baptist University; 4Meituan-Dianping Group; 5RIKEN AIP ",
+        "bbox": [
+            214,
+            260,
+            784,
+            290
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            325,
+            535,
+            342
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The memorization effect of deep neural network (DNN) plays a pivotal role in many state-of-the-art label-noise learning methods. To exploit this property, the early stopping trick, which stops the optimization at the early stage of training, is usually adopted. Current methods generally decide the early stopping point by considering a DNN as a whole. However, a DNN can be considered as a composition of a series of layers, and we find that the latter layers in a DNN are much more sensitive to label noise, while their former counterparts are quite robust. Therefore, selecting a stopping point for the whole network may make different DNN layers antagonistically affect each other, thus degrading the final performance. In this paper, we propose to separate a DNN into different parts and progressively train them to address this problem. Instead of the early stopping which trains a whole DNN all at once, we initially train former DNN layers by optimizing the DNN with a relatively large number of epochs. During training, we progressively train the latter DNN layers by using a smaller number of epochs with the preceding layers fixed to counteract the impact of noisy labels. We term the proposed method as progressive early stopping (PES). Despite its simplicity, compared with the traditional early stopping, PES can help to obtain more promising and stable results. Furthermore, by combining PES with existing approaches on noisy label training, we achieve state-of-the-art performance on image classification benchmarks. The code is made public at https://github.com/tmllab/PES. ",
+        "bbox": [
+            233,
+            357,
+            766,
+            632
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            659,
+            310,
+            676
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep networks have revolutionized a wide variety of tasks, such as image processing, speech recognition, and language modeling [7], However, this highly relies on the availability of large annotated data, which may not be feasible in practice. Instead, many large datasets with lower quality annotations are collected from online queries [5] or social-network tagging [18]. Such annotations inevitably contain mistakes or label noise. As deep networks have large model capacities, they can easily memorize and eventually overfit the noisy labels, leading to poor generalization performance [36]. Therefore, it is of great importance to develop a methodology that is robust to noisy annotations. ",
+        "bbox": [
+            174,
+            690,
+            825,
+            801
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Existing methods on learning with noisy labels (LNL) can be mainly categorized into two groups: model-based and model-free algorithms. Methods in the first category mainly model noisy labels with the noise transition matrix [24, 34, 33, 30]. With perfectly estimated noise transition matrix, models trained with corrected losses can approximate to the models trained with clean labels. However, current methods are usually fragile to estimate the noise transition matrix for heavy noisy data and are also hard to handle a large number of classes [9]. The second type explores the dynamic process of optimization policies, which relates to the memorization effect−deep neural networks tend to first memorize and fit majority (clean) patterns and then overfit minority (noisy) patterns [2]. Recently, based on this phenomenon, many methods [9, 26, 15, 16, 29] have been proposed and achieved promising performance. ",
+        "bbox": [
+            176,
+            808,
+            825,
+            863
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c7512ec26780dca9b15dc452cb391a4d5b9e7d1c3d1347ce8d597d9d4f66ce84.jpg",
+        "image_caption": [
+            "Figure 1: We train a ResNet-18 model on CIFAR-10 with three types of noisy labels and evaluate the impact of noisy labels on the representations from the 9-th layer, the 17-th layer, and the final layer. The X-axis is the number of epochs for the first block of the network. The curves present the mean of five runs and the best performances are indicated with dotted vertical lines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            101,
+            820,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            325,
+            825,
+            409
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To exploit the memorization effect, when the double descent phenomenon [3, 22, 11] cannot be guaranteed to occur, a core issue is to study when to stop the optimization of the network. While stopping the training for too few epochs can avoid overfitting to noisy labels, it can also make the network underfit to clean labels. Current methods [25, 23] usually adopt an early stopping strategy, which decides the stopping point by considering the network as a whole. However, since DNNs are usually optimized with stochastic gradient descent (SGD) with backpropagation, supervisory signals will gradually propagate through the whole network from latter layers (i.e., layers that are closer to output layers) to former layers (i.e., layers that are closer to input layers). Noting that the output layer is followed by the empirical risk in the optimization procedure. We hypothesize that noisy labels may have more severe impacts for the latter layers, which is different from current methods [9, 15] that usually stop the training of the whole network at once. ",
+        "bbox": [
+            174,
+            414,
+            825,
+            566
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To empirically verify the above hypothesis, we analyze the impact of noisy labels on representations from different layers with different training epochs. To quantitatively measure the impact of noisy labels from intermediate layers, we first train the whole network on noisy data with different training epochs and fix the parameters for the selected layer and its previous layers. We then reinitialize and optimize the rest layers with clean data, and the final classification performance is adopted to evaluate the impact of noisy labels. For the final layer, we directly report the overall classification performance. As illustrated in Figure 1, we can see that latter layers always achieve the best performance at relatively smaller epoch numbers and then exhibit stronger performance drops with additional training epochs, which verifies the hypothesis that noisy data may have more severe impacts for latter layers. With this understanding, we can infer that the early stopping, which optimizes the network all at once, may fail to fully exploit the memorization effect and induce sub-optimal performance. ",
+        "bbox": [
+            174,
+            573,
+            825,
+            726
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address the above problem, we propose to optimize a DNN by considering it as a composition of several DNN parts and present a novel progressive early stopping (PES) method. Specifically, we initially train former DNN layers by optimizing them with a relatively large number of epochs. Then, to alleviate the impact of noisy labels for latter layers, we reinitialize and progressively train latter DNN layers by using smaller numbers of epochs with preceding DNN layers fixed. Since different layers are progressively trained with different early stopping epochs, we term the proposed method as progressive early stopping (PES). Despite its simplicity, compared with normal early stopping trick, PES can help to better exploit the memorization effect and obtain more promising and stable results. Moreover, since the model size and training epochs are gradually reduced during the optimization procedure, the training time of PES is only slightly greater than that of the normal early stopping. Finally, by combining PES with existing approaches on noisy label training tasks, we establish new state-of-the-art (SOTA) results on CIFAR-10 and CIFAR-100 with synthetic noise. We also achieve competitive results on one dataset with real-world noise: Clothing-1M [32]. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The rest of the paper is organized as follows. In Section 2, we first introduce the proposed progressive early stopping and then present the details of the proposed algorithm by combining our method with existing approaches on noisy label training tasks. Section 3 shows the experimental results of our proposed method. Related works are briefly reviewed in Section 4. Finally, concluding remarks are given in Section 5. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Proposed Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            180,
+            352,
+            198
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $D$ be the distribution of a pair of random variables $( X , Y ) \\in \\mathcal { X } \\times \\{ 1 , . . . K \\}$ , where $\\boldsymbol { X }$ indicates the variable of instances, $\\mathbf { Y }$ is the variable of labels, $\\mathcal { X }$ denotes the feature space, and $K$ is the number of classes. In many real-world problems, examples independently drawn from the distribution $D$ are unavailable. Before being observed, the clean labels are usually randomly corrupted into noisy labels. Let $\\tilde { D }$ be the distribution of the noisy example $( X , { \\tilde { Y } } )$ , where $\\tilde { Y }$ indicates the variable of noisy labels. For label-noise learning, we can only access a sample set $\\{ \\pmb { x } _ { i } , \\tilde { y } _ { i } ) \\} _ { i = 1 } ^ { n }$ independently drawn from $\\tilde { D }$ . The aim is to learn a robust classifier from the noisy sample set that can classify test instances accurately. ",
+        "bbox": [
+            173,
+            212,
+            826,
+            329
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the following, we first elaborate on the proposed progressive early stopping (PES). Then, based on PES, we provide a learning algorithm that learns with confident examples and semi-supervised learning techniques. ",
+        "bbox": [
+            174,
+            334,
+            825,
+            377
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Progressive Early Stopping ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            393,
+            401,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "When trained with noisy labels, if clean labels are of majority within each noisy class, deep networks tend to first fit clean labels during an early learning stage before eventually memorizing the wrong labels, which can be explained by the memorization effect. Many current methods utilize this property to counteract the influence of noisy labels by stopping the optimization at an early learning phase. Specifically, a deep classifier can be obtained by optimizing the following objective function with a relatively small epoch number $T$ : ",
+        "bbox": [
+            173,
+            419,
+            826,
+            502
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c0c8c02abfce6194ad608c4820ea855fb6789ee70cf2039f7d84b2ec9d9be1ed.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\Theta } \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\mathcal { L } ( f ( x _ { i } ; \\Theta ) , \\tilde { y } _ { i } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            511,
+            589,
+            553
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $f ( \\cdot ; \\Theta )$ is a deep classifier with model parameters $\\Theta$ and $\\mathcal { L }$ is the cross-entropy loss. When trained with noisy data, early learning regularization (ELR) [16] reveals that, for the most commonly used cross-entropy loss, the gradient is well correlated with the correct direction at the early learning phase. Therefore, with a properly defined small epoch number $T$ , the classifier can have higher accuracy than at initialization. While, if we continue to optimize the deep model after $T$ epochs, the classifier will be able to memorize more noise labels. Therefore, it is critical to select a proper epoch number $T$ to utilize the memorization effect and alleviate the influence of noisy labels. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            656
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Current methods typically select the epoch number $T$ by considering the network as a whole. However, as Figure 1 makes clear, the impact of noisy labels on different DNN layers are different, which implies that the traditional early stopping trick, which optimizes the whole network all at once, may make different DNN layers to be antagonistically affected by each other, thus degrading the final model performance. To this end, we propose to separate a DNN into different parts and progressively train layers in different parts with different training epochs. Specifically, assume that the whole network $f ( \\cdot ; \\Theta )$ can be constituted with $L$ DNN parts ",
+        "bbox": [
+            173,
+            662,
+            825,
+            761
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c49b4c2da11083b29e1461cfbacf31110bb24c4b4430f414be9d136f95e70e52.jpg",
+        "text": "$$\n\\begin{array} { l } { z _ { 1 } = f _ { 1 } ( \\pmb { x } ; \\Theta _ { 1 } ) , } \\\\ { z _ { l } = f _ { l } ( z _ { l - 1 } ; \\Theta _ { l } ) , \\quad l = 2 , \\ldots , L } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            766,
+            612,
+            805
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $f _ { l } ( \\cdot ; \\Theta _ { l } )$ is the $l$ -th DNN part and $z _ { l }$ is the corresponding output. The output of the last part $z _ { L }$ is the prediction. The network $f ( \\cdot ; \\Theta )$ can also be represented as $f ( \\cdot ; \\Theta _ { 1 } , . . . \\Theta _ { L } )$ . To counteract the impact of noisy labels, We initially optimize the parameter $\\Theta _ { 1 }$ for the first part by training the whole network for $T _ { 1 }$ epochs with the following objective ",
+        "bbox": [
+            174,
+            810,
+            825,
+            867
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8f9f562c089aae98a23044dad475a993b51a64c95507fed67028e7a03c4884fc.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\Theta _ { 1 } \\ldots \\Theta _ { k } } \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\mathcal { L } ( f ( \\pmb { x } _ { i } ; \\Theta _ { 1 } , \\ldots , \\Theta _ { L } ) , \\tilde { y } _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            875,
+            633,
+            916
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/93c2dd94c2a0f5dd8e852ee49fbcbcd3facdbcf530179d0abf899ddba8541bf1.jpg",
+        "image_caption": [
+            "Figure 2: Performance of the traditional early stopping trick and the proposed PES on CIFAR-10 with different types of label noise. The lines present the mean of five runs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            102,
+            818,
+            239
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Then, we keep the obtained parameter $\\Theta _ { 1 } ^ { * }$ fixed, reinitialize and progressively learn the $l$ -th $( l =$ $2 , \\ldots , L )$ DNN part with the parameters for preceding DNN parts fixed. The training procedure is conducted with $T _ { l }$ epochs by optimizing the following objective ",
+        "bbox": [
+            174,
+            287,
+            825,
+            330
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6cf91797c88f1e24c4a6f13692f97ac06e4c0a1ac0851bf9e6baf25712dea2a2.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\Theta _ { l } \\ldots \\Theta _ { k } } \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\mathcal { L } ( f ( x _ { i } ; \\Theta _ { 1 } ^ { * } , \\ldots , \\Theta _ { l - 1 } ^ { * } , \\Theta _ { l } , \\ldots , \\Theta _ { L } ) , \\tilde { y } _ { i } ) , \\quad l = 2 \\ldots L\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            335,
+            725,
+            376
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We gradually optimize the $( l + 1 )$ -th DNN part with the obtained parameter $\\Theta _ { l } ^ { * }$ fixed, the optimization is continued until all the parameters have been optimized. As elaborated above, latter DNN parts are more sensitive to noisy labels than their former counterparts. Therefore, for the above initializing optimization in Eq. (3) and the following $L - 1$ steps of optimization in Eq. (4), we gradually reduce the training epochs (i.e. $T _ { 1 } \\geq T _ { 2 } \\geq \\cdot \\cdot \\cdot \\geq T _ { L } )$ to better exploit the memorization effect. After optimization, we can obtain the final network as $f ( \\cdot , \\Theta ) = \\bar { f } ( \\cdot ; \\Theta _ { 1 } ^ { * } , \\ldots , \\Theta _ { L } ^ { * } )$ . Since this model is obtained by progressively exploiting the early stopping strategies for different DNN parts, we term the proposed method as progressive early stopping (PES). ",
+        "bbox": [
+            173,
+            381,
+            825,
+            493
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To explicitly verify the effectiveness of the proposed PES method, we conduct several pilot experiments, which compare the traditional early stopping and PES with label noise from different types and different levels. The results are illustrated in Figure 2, from which we can see that, compared with models trained with traditional early stopping, models trained with PES can achieve superior classification accuracy with smaller variations in all the cases. Current state-of-the-art methods [15] usually adopt models with the traditional early stopping as base models to distill confident examples and then utilize semi-supervised learning techniques by considering confident examples as labeled data and other noisy examples as unlabeled data to further improve the results. The final performance still heavily relies on the base model trained with noisy labels. By improving the performance of the base model, our method combined with semi-supervised learning techniques is able to establish new state-of-the-art results. In the following subsections, we will elaborate on how to utilize PES to distill confident examples and further combine it with semi-supervised learning techniques. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 Learning with Confident Examples ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            680,
+            457,
+            695
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Based on the deep network optimized with progressive early stopping, we can select confident examples to facilitate the model training. Here, confident examples refer to examples that have high probabilities with clean labels. In this paper, we treat examples whose predictions are consistent with given labels as confident examples. In addition, to make the results more robust, we generate two different augmentations for any given input and use the average prediction to decide its predicted label. Formally, we can obtain the confident example set $\\mathcal { D } _ { l }$ as ",
+        "bbox": [
+            174,
+            704,
+            825,
+            790
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f0ca8b2be795a56146eeba463a76de4df49127ec5a09e9825eff949f223573dc.jpg",
+        "text": "$$\n\\begin{array} { c } { \\mathcal { D } _ { l } = \\{ ( \\pmb { x } _ { i } , \\tilde { y } _ { i } ) | \\tilde { y } _ { i } = \\hat { y } _ { i } , i = 1 , \\ldots , n \\} , } \\\\ { \\hat { y } _ { i } = \\underset { k \\in \\{ 1 , \\ldots , K \\} } { \\arg \\operatorname* { m a x } } \\ \\frac { 1 } { 2 } [ f ^ { k } ( \\mathrm { A u g m e n t } ( \\pmb { x } _ { i } ) ; \\Theta ) + f ^ { k } ( \\mathrm { A u g m e n t } ( \\pmb { x } _ { i } ) ; \\Theta ) ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            803,
+            715,
+            859
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where Augment $( \\cdot )$ indicates normal data augmentation operation including horizontal random flip and random crops, and $f ^ { k } ( x ; \\Theta )$ is the predicted probability of $_ { \\textbf { \\em x } }$ belonging to class $k$ . Note that Augment $\\left( \\cdot \\right)$ is a stochastic transformation, so the two terms in Eq (5) are not identical. The average ",
+        "bbox": [
+            176,
+            868,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input: Neural network with trainable parameters $\\boldsymbol { \\Theta } = \\{ \\Theta _ { 1 } , \\dots , \\Theta _ { L } \\}$ , Noisy training dataset   \n$\\{ \\bar { \\pmb { x } _ { i } } , \\tilde { y } _ { i } ) \\} _ { i = 1 } ^ { n }$ , Number of training epochs for different part: $T _ { 1 } , \\dots , T _ { L }$ , and training epochs $T _ { c }$   \nfor refining with confident examples.   \nfor $i = 1 , \\dots , T _ { 1 }$ do   \nOptimize network parameter $\\Theta$ with Eq. (3);   \nfor $l = 2$ , . . . , $L$ do Froze $\\left\\{ \\Theta _ { 1 } , \\ldots , \\Theta _ { l - 1 } \\right\\}$ and re-initialize $\\big \\{ \\Theta _ { l } , \\dots , \\Theta _ { L } \\big \\}$ ; for $i = 1 , \\dots , T _ { l }$ do Optimize network parameter $\\big \\{ \\Theta _ { l } , \\dots , \\Theta _ { L } \\big \\}$ with Eq. (4);   \nUnfroze $\\Theta$ ;   \nfor $i = 1 , \\dots , T _ { c }$ do Extract confident example set $\\mathcal { D } _ { l }$ and unlabeled set $\\mathcal { D } _ { u }$ with classifier $f ( \\cdot , \\Theta )$ by Eq. (7); Training the classifier $f ( \\cdot , \\Theta )$ with MixMatch loss on $\\mathcal { D } _ { l }$ and $\\mathcal { D } _ { u }$ ;   \nEvaluate the obtained classifier $f ( \\cdot , \\Theta )$ . ",
+        "bbox": [
+            171,
+            112,
+            792,
+            323
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "prediction of augmented examples provides a more stable prediction and is found empirically to improve performance. After obtaining the confident example set, one can easily train a classifier by considering confident examples as clean data. However, since the number of confident examples for different classes can vary greatly, directly training the model with the obtained confident example set may introduce a severe class imbalance problem. To this end, we adopt a weighted classification loss ",
+        "bbox": [
+            173,
+            353,
+            825,
+            425
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2d952161669f286508b4ff5d83652860d38fb213b9f942b25cfcf93e6118bade.jpg",
+        "text": "$$\n\\mathcal { L } _ { c } = \\sum _ { i = 1 } ^ { N } w _ { y _ { i } } \\mathcal { L } _ { p } ( \\tilde { y } _ { i } , f ( \\pmb { x } _ { i } ; \\Theta ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            439,
+            602,
+            482
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $w _ { i }$ is the corresponding class weight. Assuming that $\\sigma _ { k } = | \\{ ( \\pmb { x } _ { i } , \\tilde { y } _ { i } ) | \\tilde { y } _ { i } = k , ( \\pmb { x } _ { i } , \\tilde { y } _ { i } ) \\in \\mathcal { D } _ { l } \\} |$ denotes the cardinality of the confident example set belonging to the $k$ -th class. Then, we can set $w _ { i } = \\sigma _ { i } / ( \\sum _ { j = 1 } ^ { K } \\sigma _ { j } )$ to indicate the corresponding class importance. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 Combining with Semi-Supervised Learning ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            546,
+            516,
+            563
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training with only confident examples neglects the rest data and may suffer from insufficient training examples. To tackle this problem, we further resort to semi-supervised learning techniques by considering confident examples as labeled data and other noisy examples as unlabeled data. Specifically, the labeled data set and unlabeled data set can be obtained as ",
+        "bbox": [
+            176,
+            571,
+            825,
+            627
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a92713a47a810a07f4fbd6225dc073925113f0874b4ff035aa8d78e39c94acb1.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\displaystyle { \\int } { \\mathcal D } _ { l } = \\{ ( \\boldsymbol x _ { i } , \\tilde { y } _ { i } ) | \\tilde { y } _ { i } = \\hat { y } _ { i } , i = 1 , . . . n \\} } } \\\\ { { \\displaystyle { \\mathcal D } _ { u } = \\{ \\boldsymbol x _ { i } | \\tilde { y } _ { i } \\neq \\hat { y } _ { i } , i = 1 , . . . n \\} } } \\\\ { { \\displaystyle { \\hat { y } _ { i } = \\arg \\operatorname* { m a x } _ { k \\in \\{ 1 , . . . K \\} } \\frac { 1 } { 2 } [ f ^ { k } ( \\mathrm { A u g m e n t } ( \\boldsymbol x _ { i } ) ; \\Theta ) + f ^ { k } ( \\mathrm { A u g m e n t } ( \\boldsymbol x _ { i } ) ; \\Theta ) ] } , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            633,
+            714,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the labeled data set $\\mathcal { D } _ { l }$ is the same as that in Eq (6), and $\\mathcal { D } _ { u }$ is the rest unlabeled data set. Similar to [15], we adopt MixMatch [4] as the semi-supervised learning framework to train the final classification models. For more details about semi-supervised learning, we refer to [4]. The whole learning algorithm is summarized in Algorithm 1. ",
+        "bbox": [
+            178,
+            710,
+            820,
+            767
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            785,
+            312,
+            803
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 Datasets and Implementation Details ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            815,
+            470,
+            832
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets: We evaluate our method on two synthetic datasets, CIFAR-10 and CIFAR-100 [12] with different levels of symmetric, pairflip, and instance-dependent label noise (abbreviated as instance label noise) and a real-world dataset Clothing-1M [32]. Both CIFAR-10 and CIFAR-100 contain $5 0 \\mathrm { k }$ training images and $1 0 \\mathrm { k }$ test images of size $3 2 \\times 3 2$ . Following previous works [9, 31, 16, 29], symmetric noise is generated by uniformly flipping labels for a percentage of the training dataset to all possible labels. Pairflip noise flips noisy labels into their adjacent class. And, instance noise is generated by image features. More details about the synthetic label noise are given in the supplementary material. For the flipping rate, it can include [9, 31] or ex-include [15, 16] true labels. We use the flipping rate including correct labels in Table 3 to compare with results in [15], and use without correct labels in the rest of the experiments. Clothing-1M [32] is a large-scale dataset with real-world noisy labels, whose images are clawed from the online shopping websites, and labels are generated based on surrounding texts. It contains 1 million training images, and $1 5 \\mathrm { k }$ validation images, and 10k test images with clean labels. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/00db2b4f97c9dec5546d30e722898d28a5de7b60aab6b4c0b55768812cd9dac7.jpg",
+        "table_caption": [
+            "Table 1: Preliminary analysis of the performance and the quality of extracted confident examples on CIFAR-10. The mean and standard deviation are computed over five runs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Metrics</td><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>Sym-20%</td><td rowspan=1 colspan=1>Sym-50%</td><td rowspan=1 colspan=1>Pair-45%</td><td rowspan=1 colspan=1>Inst-20%</td><td rowspan=1 colspan=1>Inst-40%</td></tr><tr><td rowspan=1 colspan=1>Test Accuracy</td><td rowspan=1 colspan=1>Early StoppingPES</td><td rowspan=1 colspan=1>82.55±2.4685.87±1.59</td><td rowspan=1 colspan=1>70.76±1.2475.87±1.33</td><td rowspan=1 colspan=1>60.62±5.5962.40±2.34</td><td rowspan=1 colspan=1>84.41±0.9086.58±0.45</td><td rowspan=1 colspan=1>74.73±2.6577.07±1.18</td></tr><tr><td rowspan=1 colspan=1>Label Precision</td><td rowspan=1 colspan=1>Early StoppingPES</td><td rowspan=1 colspan=1>98.81±0.1598.96±0.09</td><td rowspan=1 colspan=1>94.65±0.1995.46±0.14</td><td rowspan=1 colspan=1>72.53±5.2672.99±2.27</td><td rowspan=1 colspan=1>98.70±0.4398.52±0.19</td><td rowspan=1 colspan=1>90.77±1.8790.63±0.92</td></tr><tr><td rowspan=1 colspan=1>Label Recall</td><td rowspan=1 colspan=1>Early StoppingPES</td><td rowspan=1 colspan=1>88.51±2.2692.67±1.43</td><td rowspan=1 colspan=1>75.18±1.0081.03±1.83</td><td rowspan=1 colspan=1>67.84±5.0671.06±2.27</td><td rowspan=1 colspan=1>90.37±1.0193.24±0.60</td><td rowspan=1 colspan=1>82.15±3.1785.91±0.68</td></tr></table>",
+        "bbox": [
+            176,
+            131,
+            823,
+            239
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            262,
+            825,
+            375
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines: Semi-supervised learning may strongly boost the performance, we separately compare our method with approaches with or without semi-supervised learning. For the comparison with baselines with semi-supervised learning, we combine our proposed method with MixMatch used in [15] as indicated in Subsection 2.3. (1) Approaches without semi-supervised learning: Co-teaching [9], Forward [24], Joint Optim [25], T-revision [31], DMI [34], and CDR [29]. (2) Methods with semi-supervised learning: M-correction [1], DivideMix [15], and $\\mathrm { E L R + }$ [16]. We also adopt standard training with cross-entropy (CE) and MixUp [37] as baselines to show improvements. ",
+        "bbox": [
+            173,
+            380,
+            825,
+            478
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Network structure and optimization: Our method is implemented by PyTorch v1.6. Baseline methods are implemented based on public codes with hyper-parameters set according to the original papers. For DivideMix and $\\mathrm { E L R + }$ , we evaluate the test accuracy with the first network. To better demonstrate the robustness of our algorithm, we keep the hyper-parameters fixed for different types of label noise. More technique details are given in the supplementary material. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            553
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For experiments without semi-supervised learning, we follow [31], and use ResNet-18 [10] for CIFAR-10 and ResNet-34 for CIFAR-100. We split networks into three parts, the layers above block 4 as part 1, block 4 of ResNet as part 2, and the final layer as part 3. $T _ { 1 }$ is defined as 25 for CIFAR-10 and 30 for CIFAR-100, $T _ { 2 }$ as 7, and $T _ { 3 }$ as 5. The network is trained for 200 epochs and SGD with 0.9 momentum is used. The initial learning rate is set to 0.1 and decayed with a factor of 10 at the 100th and 150th epoch respectively, and a weight decay is set to $1 0 ^ { - 4 }$ . For $T _ { 2 }$ and $T _ { 3 }$ , we employ an Adam optimizer with a learning rate of $1 0 ^ { - 4 }$ . ",
+        "bbox": [
+            173,
+            559,
+            825,
+            656
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For experiments with semi-supervised learning, we follow the setting of [15] with PreAct Resnet-18. We set the final layer as part 2, the rest as part 1. $T _ { 1 }$ is defined as 20 for CIFAR-10 and 35 for CIFAR-100, and $T _ { 2 }$ as 5. The network is trained for 300 epochs. For optimization, we use a single cycle of cosine annealing [19], and the learning rate begins from $2 \\times \\mathrm { \\bar { 1 0 ^ { - 2 } } }$ and ends at $2 \\times 1 0 ^ { - 4 }$ , with a weight decay of $5 \\times 1 0 ^ { - 4 }$ . An Adam optimizer is adopted with a learning rate of $1 0 ^ { - 4 }$ for $T _ { 2 }$ . For hyper-parameters from MixMatch, we set them according to the original paper [4]. ",
+        "bbox": [
+            174,
+            662,
+            826,
+            746
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For Clothing-1M [32], we follow the previous work [25], and employ a ResNet-50 [10] pre-trained on ImageNet [13]. We set the final layer as part 2, the rest as part 1. $T _ { 1 }$ and $T _ { 2 }$ are defined as 20 and 7 respectively. The network is trained with CE loss for 50 epochs and SGD is used with 0.9 momentum and a weight decay of $1 0 ^ { - 3 }$ . The learning rate is $5 \\times 1 0 ^ { - 3 }$ and decayed by a factor of 10 at the 20th and 30th epoch respectively. We employ an Adam optimizer with a learning rate of $5 \\times 1 0 ^ { - 6 }$ for $T _ { 2 }$ ",
+        "bbox": [
+            174,
+            752,
+            825,
+            821
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 Preliminary Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            842,
+            390,
+            857
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Figure 2, we can observe that with the PES trick, the performance of classifiers is generally improved compared with that the traditional early stopping trick. In this section, we further carefully analyze the quality of extracted labels by examining them from three aspects, i.e., test accuracy, label precision, and label recall. Here, label precision indicates the ratio of the number of extracted confident examples with correct labels in the total confident example set, and label recall represents the ratio of the number of confident examples with correct labels among the total correctly labeled examples. Specifically, we train a neural network on CIFAR-10 with different kinds and levels of label noise for 25 epochs respectively and report the performance for each case before and after the proposed PES is applied. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/faf2277129f4013a50d7d87c0c93cc22f297e8287191fc976ac1e57bb5e493c0.jpg",
+        "table_caption": [
+            "Table 2: Comparison with state-of-the-art methods without semi-supervised learning on CIFAR-10 and CIFAR-100. The mean and standard deviation computed over five runs are presented. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset</td><td rowspan=\"2\">Method</td><td colspan=\"2\">Symmetric</td><td>Pairflip</td><td colspan=\"2\">Instance</td></tr><tr><td>20%</td><td>50%</td><td>45%</td><td>20%</td><td>40%</td></tr><tr><td rowspan=\"8\">CIFAR10</td><td>CE</td><td>84.00±0.66</td><td>75.51±1.24</td><td>63.34±6.03</td><td>85.10±0.68</td><td>77.00±2.17</td></tr><tr><td>Co-teaching</td><td>87.16±0.11</td><td>72.80±0.45</td><td>70.11±1.16</td><td>86.54±0.11</td><td>80.98±0.39</td></tr><tr><td>Forward</td><td>85.63±0.52</td><td>77.92±0.66</td><td>60.15±1.97</td><td>85.29±0.38</td><td>74.72±3.24</td></tr><tr><td> Joint Optim</td><td>89.70±0.11</td><td>85.00±0.17</td><td>82.63±1.38</td><td>89.69±0.42</td><td>82.62±0.57</td></tr><tr><td>T-revision</td><td>89.63±0.13</td><td>83.40±0.65</td><td>77.06±6.47</td><td>90.46±0.13</td><td>85.37±3.36</td></tr><tr><td>DMI</td><td>88.18±0.36</td><td>78.28±0.48</td><td>57.60±14.56</td><td>89.14±0.36</td><td>84.78±1.97</td></tr><tr><td>CDR</td><td>89.72±0.38</td><td>82.64±0.89</td><td>73.67±0.54</td><td>90.41±0.34</td><td>83.07±1.33</td></tr><tr><td>Ours</td><td>92.38±0.40</td><td>87.45±0.35</td><td>88.43±1.08</td><td>92.69±0.44</td><td>89.73±0.51</td></tr><tr><td rowspan=\"8\">CIFAR100</td><td>CE</td><td>51.43±0.58</td><td>37.69±3.45</td><td>34.10±2.04</td><td>52.19±1.42</td><td>42.26±1.29</td></tr><tr><td>Co-teaching</td><td>59.28±0.47</td><td>41.37±0.08</td><td>33.22±0.48</td><td>57.24±0.69</td><td>45.69±0.99</td></tr><tr><td>Forward</td><td>57.75±0.37</td><td>44.66±1.01</td><td>27.88±0.80</td><td>58.76±0.66</td><td>44.50±0.72</td></tr><tr><td> Joint Optim</td><td>64.55±0.38</td><td>50.22±0.41</td><td>42.61±0.61</td><td>65.15±0.31</td><td>55.57±0.41</td></tr><tr><td>T-revision</td><td>65.40±1.07</td><td>50.24±1.45</td><td>41.10±1.95</td><td>60.71±0.73</td><td>51.54±0.91</td></tr><tr><td>DMI</td><td>58.73±0.70</td><td>44.25±1.14</td><td>26.90±0.45</td><td>58.05±0.20</td><td>47.36±0.68</td></tr><tr><td>CDR</td><td>66.52±0.24</td><td>55.30±0.96</td><td>43.87±1.35</td><td>67.33±0.67</td><td>55.94±0.56</td></tr><tr><td>Ours</td><td>68.89±0.45</td><td>58.90±2.72</td><td>57.18±1.44</td><td>70.49±0.79</td><td>65.68±1.41</td></tr></table>",
+        "bbox": [
+            189,
+            131,
+            803,
+            400
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/db3492c5afea51549904ef40bb3ab4ac7a34d054f0b1e535e19df964e1db2048.jpg",
+        "table_caption": [
+            "Table 3: Comparison with state-of-the-art methods with semi-supervised learning on CIFAR-10 and CIFAR-100 with symmetric label noise from different levels. Results with \\* are token from [15]. The mean and standard deviation are computed over three runs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td colspan=\"3\">CIFAR-10</td><td colspan=\"3\">CIFAR-100</td></tr><tr><td>Methods /Noise</td><td>Sym-20%</td><td>Sym-50%</td><td>Sym-80%</td><td>Sym-20%</td><td>Sym-50%</td><td>Sym-80%</td></tr><tr><td>CE</td><td>86.5±0.6</td><td>80.6±0.2</td><td>63.7±0.8</td><td>57.9±0.4</td><td>47.3±0.2</td><td>22.3±1.2</td></tr><tr><td>MixUp</td><td>93.2±0.3</td><td>88.2±0.3</td><td>73.3±0.3</td><td>69.5±0.2</td><td>57.1±0.6</td><td>34.1±0.6</td></tr><tr><td>M-correction*</td><td>94.0</td><td>92.0</td><td>86.8</td><td>73.9</td><td>66.1</td><td>48.2</td></tr><tr><td>DivideMix*</td><td>95.2</td><td>94.2</td><td>93.0</td><td>75.2</td><td>72.8</td><td>58.3</td></tr><tr><td>DivideMix</td><td>95.6±0.1</td><td>94.6±0.1</td><td>92.9±0.3</td><td>75.3±0.1</td><td>72.7±0.6</td><td>56.4±0.3</td></tr><tr><td>ELR+</td><td>94.9±0.2</td><td>93.6±0.1</td><td>90.4±0.2</td><td>75.5±0.2</td><td>71.0±0.2</td><td>50.4±0.8</td></tr><tr><td>Ours (Semi)</td><td>95.9±0.1</td><td>95.1±0.2</td><td>93.1±0.2</td><td>77.4±0.3</td><td>74.3±0.6</td><td>61.6±0.6</td></tr></table>",
+        "bbox": [
+            214,
+            463,
+            784,
+            599
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            612,
+            825,
+            695
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results in Table 1 clearly show that, compared with the traditional early stopping, PES can help to obtain higher accuracies, precisions, and recalls for most cases. For instance-dependent label noise, PES can achieve higher recall values with comparable label precision values. Note that models with high recall values can help to collect more confident examples, which is critical for learning with confident examples and semi-supervised learning. Therefore, by enhancing the performance of the initial model, PES can help to improve the final classification performance in all cases, which is also verified by the experiments in Section 3.3. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            799
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 Classification Accuracy Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            815,
+            457,
+            832
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Synthetic datasets. We first verify the effectiveness of our proposed method without semi-supervised learning techniques on two synthetic datasets: CIFAR-10 and CIFAR-100. For both of these two datasets, we leave $10 \\%$ of data with noisy labels as noisy validation set. Results are presented in Table 2, which shows that our proposed method can consistently outperform all other baselines across various settings by a large margin. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/30f68d18682a41f23ee5c16e39c70d68c6be5ad1521db00b67346216a25d82d5.jpg",
+        "table_caption": [
+            "Table 4: Comparison with state-of-the-art methods with semi-supervised learning on CIFAR-10 and CIFAR-100 with instance-dependent and pairflip label noise from different levels. The mean and standard deviation are computed over three runs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=3>CIFAR-10</td><td rowspan=1 colspan=3>CIFAR-100</td></tr><tr><td rowspan=1 colspan=1>Methods/Noise</td><td rowspan=1 colspan=1>Inst-20%</td><td rowspan=1 colspan=1>Inst-40%</td><td rowspan=1 colspan=1>Pair-45%</td><td rowspan=1 colspan=1>Inst-20%</td><td rowspan=1 colspan=1>Inst-40%</td><td rowspan=1 colspan=1>Pair-45%</td></tr><tr><td rowspan=4 colspan=1>CEMixUpDivideMixELR+</td><td rowspan=1 colspan=1>87.5±0.5</td><td rowspan=1 colspan=1>78.9±0.7</td><td rowspan=1 colspan=1>74.9±1.7</td><td rowspan=1 colspan=1>56.8±0.4</td><td rowspan=1 colspan=1>48.2±0.5</td><td rowspan=1 colspan=1>38.5±0.6</td></tr><tr><td rowspan=2 colspan=1>93.3±0.295.5±0.1</td><td rowspan=2 colspan=1>87.6±0.594.5±0.2</td><td rowspan=2 colspan=1>82.4±1.085.6±1.7</td><td rowspan=1 colspan=1>67.1±0.1</td><td rowspan=2 colspan=1>55.0±0.170.9±0.1</td><td rowspan=2 colspan=1>44.2±0.548.2±1.0</td></tr><tr><td rowspan=1 colspan=1>75.2±0.2</td><td rowspan=1 colspan=1>70.9±0.1</td></tr><tr><td rowspan=1 colspan=1>94.9±0.1</td><td rowspan=1 colspan=1>94.3±0.2</td><td rowspan=1 colspan=1>86.1±1.2</td><td rowspan=1 colspan=1>75.8±0.1</td><td rowspan=1 colspan=1>74.3±0.3</td><td rowspan=1 colspan=1>65.3±1.3</td></tr><tr><td rowspan=1 colspan=1>Ours (Semi)</td><td rowspan=1 colspan=1>95.9±0.1</td><td rowspan=1 colspan=1>95.3±0.1</td><td rowspan=1 colspan=1>94.5±0.3</td><td rowspan=1 colspan=1>77.6±0.3</td><td rowspan=1 colspan=1>76.1±0.4</td><td rowspan=1 colspan=1>73.6±1.7</td></tr></table>",
+        "bbox": [
+            222,
+            145,
+            772,
+            252
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/fd26d18ed5ae3d06898df87d4bef68e8bf94d61f481d809a16bbd2362705f40d.jpg",
+        "table_caption": [
+            "Table 5: Compassion with state-of-the-art methods on Clothing-1M. Results of baseline methods are taken from the original papers. ours represent the results obtained by PES with a single network and ours\\* indicate the results obtained by PES with an ensemble model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>CE</td><td rowspan=1 colspan=1>Forward</td><td rowspan=1 colspan=1>Joint-Optim</td><td rowspan=1 colspan=1>DMI</td><td rowspan=1 colspan=1>T-revision</td><td rowspan=1 colspan=1>DivideMix*</td><td rowspan=1 colspan=1>ELR+*</td><td rowspan=1 colspan=1>Ours</td><td rowspan=1 colspan=1>Ours*</td></tr><tr><td rowspan=1 colspan=1>69.21</td><td rowspan=1 colspan=1>69.84</td><td rowspan=1 colspan=1>72.16</td><td rowspan=1 colspan=1>72.46</td><td rowspan=1 colspan=1>74.18</td><td rowspan=1 colspan=1>74.76</td><td rowspan=1 colspan=1>74.81</td><td rowspan=1 colspan=1>74.64</td><td rowspan=1 colspan=1>74.99</td></tr></table>",
+        "bbox": [
+            207,
+            324,
+            790,
+            357
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/61ae512b2fb46bee07bd5e6157d516e400cd564030c729a91354232a89157ebe.jpg",
+        "image_caption": [
+            "Figure 3: Sensitivity analysis for different training iteration numbers: $T _ { 2 }$ and $T _ { 3 }$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            284,
+            386,
+            712,
+            542
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3 and Table 4 present the mean accuracy and standard deviation for our method and all baselines on CIFAR-10 and CIFAR-100, respectively. From the results, we can get that the proposed method can outperform all baselines in all cases. For pairflip label noise, the advantages of our proposed method become more apparent, and it significantly outperforms state-of-the-art methods by over $8 \\%$ on both CIFAR-10 and CIFAR-100. These empirical results support our proposal that PES can improve the quality of selected confident examples, which helps improve performance and reduce the variance of the final classifier. ",
+        "bbox": [
+            173,
+            582,
+            825,
+            679
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Real-world dataset. We evaluate the performance of the proposed method on a real-world dataset with Clothing-1M [32] and select methods such as CE, Forward, Joint-Optim, DMI, and T-revision, which use a single network, and also methods such as DivideMix and $\\mathrm { E L R + }$ , which adopt an ensemble model with two different networks, as baselines. We also report the results for the proposed PES with a single network as ours and the results for PES, which ensembles two networks, as ours\\*. The overall results are reported in Table 5, from which we can observe that the proposed PES with a single network can outperform all baselines using a single network. And with an ensemble model, which contains two different networks, our method can outperform all the adopted baselines. These results clearly demonstrate that, by improving the performance of the initial classification network, our method is more flexible to handle such real-world noise problems. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            824
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.4 Sensitivity Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            843,
+            348,
+            858
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we investigate the hyper-parameter sensitivity for the training iteration number $T _ { 2 }$ and $T _ { 3 }$ , respectively. We firstly analyze the training epoch number for the second DNN part by varying $T _ { 2 }$ from the range of [0, 10]. The results are illustrated in Figure 3a, from which can find that, with the increasing of $T _ { 2 }$ , the performance of PES first increase and then decrease in all the cases except for $45 \\%$ Pairflip noise on the CIFAR-10 dataset. While the model achieves the best performance with $T _ { 2 }$ as 7 for all types of noisy labels. Then we fix $T _ { 2 }$ as 7, and analyze the impact of the third DNN part by varying $T _ { 3 }$ from the range of [0, 10]. The results are shown in Figure 3b. Although the performance variance for different $T _ { 3 }$ is smaller than that for $T _ { 2 }$ , we can still observe that the best performance can be obtained when $T _ { 3 }$ is set as 5. More importantly, from these two figures, we can get that both $T _ { 2 }$ and $T _ { 3 }$ are robust to the different types of noisy labels. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/1be43f84b04f81deb931ee482ba81d70209b96391a05c3c3cca2b69977f03a7a.jpg",
+        "table_caption": [
+            "Table 6: Training time comparison for baselines on CIFAR-10 with $50 \\%$ Symmetric label noise. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>CE</td><td rowspan=1 colspan=1>Co-teaching</td><td rowspan=1 colspan=1>CDR</td><td rowspan=1 colspan=1>T-revision</td><td rowspan=1 colspan=1>ELR+</td><td rowspan=1 colspan=1>DivideMix</td><td rowspan=1 colspan=1>Ours</td><td rowspan=1 colspan=1>Ours (Semi)</td></tr><tr><td rowspan=1 colspan=1>0.9h</td><td rowspan=1 colspan=1>1.5h</td><td rowspan=1 colspan=1>3.0h</td><td rowspan=1 colspan=1>3.5h</td><td rowspan=1 colspan=1>2.2h</td><td rowspan=1 colspan=1>5.5h</td><td rowspan=1 colspan=1>1.0h</td><td rowspan=1 colspan=1>3.1h</td></tr></table>",
+        "bbox": [
+            225,
+            117,
+            763,
+            151
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            161,
+            825,
+            260
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.5 Training Time Comparison ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            275,
+            401,
+            290
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section, we compare the training time of our method and other state-of-the-art baselines. All the experiments are conducted on a server with a single Nvidia V100 GPU. The training times for all the methods are reported in Table 6, from which we can get that our algorithm with cross-entropy loss achieves the fastest speed across all baselines, only about 1 hour. Our method combining with MixMatch [4] is also fast, only a little more than half of the training time of DivideMix. The time of $\\mathrm { E L R + }$ [16] shows superior, but $\\mathrm { E L R + }$ trains the network with fewer epochs, with 200 epochs compared with ours for 300 epochs. ",
+        "bbox": [
+            174,
+            300,
+            825,
+            397
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            416,
+            316,
+            433
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Learning with noisy data has been well studied [17, 6, 21, 27, 20]. Current works can be mainly categorized into two groups: model-based and model-free methods. In this section, we briefly review some closely related works. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The first type models the relationship between clean labels and noisy labels by estimating the noise transition matrix and build a loss function to correct the loss [24, 30, 35, 28]. [24] first combines algorithms for estimating the noise rates and loss correction techniques together and introduces two alternative procedures for loss correction. It also proves that both of the two procedures enjoy formal robustness guarantees w.r.t. the clean data distribution. DMI [34] proposes an information-theoretic loss function, which utilizes Shannon’s mutual information and is robustness to different kinds of label noise. T-revision [31] estimates the noise transition matrix without anchor points by adding a fine-tuned slack variables. Although these methods have made certain progress, they are usually fragile to estimate the noise transition matrix for heavy noisy data and are also hard to handle a large number of classes. Therefore, in this paper, we mainly focus on the model-free methods. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            633
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The second strand mainly counteracts noisy labels by exploiting the memorization effect that deep networks tend to first memorize and fit majority (clean) patterns and then overfit minority (noisy) patterns [2]. To exploit this property, Co-teaching [9] employs two networks with different initialization and uses small loss to select confident examples. M-correction [1] uses two Gaussian Mixture Models to identify confident examples, instead of using networks themselves. DivideMix [15] extends Co-teaching [9] and employs two Beta Mixture Model to select confident examples. MixMatch [4] is then adopted to leverage unconfident examples with a semi-supervised learning framework. All the above methods exploit the memorization effect by considering the adopted network as a whole. Recently, [14] shows that networks training with noisy labels can produce good representations, if the structure of networks suits the targeted tasks. Our method further explains that noisy labels have different impacts for different layers in a DNN. And latter layers will receive earlier and more severe impact than their former counterparts. Therefore, by considering a DNN as a composition of several layers and training different layers with different epochs, our method is able to better exploit the memorization effect and achieve superior performance. ",
+        "bbox": [
+            173,
+            640,
+            826,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            852,
+            299,
+            869
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we provide a progressive early stopping (PES) method to better exploit the memorization effect of deep neural networks (DNN) for noisy-label learning. We first find that the impact of noisy labels for former layers in a DNN is much less and later than that for latter DNN layers, and then build upon this insight to propose the PES method, which separates a DNN into different parts and progressively train each part to counteract the different impacts of noisy labels for different DNN layers. To show that PES can boost the performance of state-of-the-art methods, we conduct extensive experiments across multiple synthetic and real-world noisy datasets and demonstrate that the proposed PES can help to obtain substantial performance improvements compared to current state-of-the-art baselines. The main limitation of our method lies in that, by splitting a DNN into different parts, PES introduces several additional hyper-parameters that need to be tuned carefully. In the future, we will extend the work in the following aspects. First, we will study other mechanisms that distinguishing desired and undesired memorization rather than early stopping, e.g., the gradient ascent trick [8]. Second, we are interested in combining PES with interesting ideas from semi-supervised learning and unsupervised learning. ",
+        "bbox": [
+            173,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            257
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            276,
+            553,
+            294
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "YB was partially supported by Agriculture Consultant and Smart Management. BH was supported by the RGC Early Career Scheme No. 22200720, NSFC Young Scientists Fund No. 62006202 and HKBU CSD Departmental Incentive Grant. YY was partially supported by Key Research and Development Program of Shaanxi (ProgramNo. 2021ZDLGY01-03). GN was supported by JST AIP Acceleration Research Grant Number JPMJCR20U3, Japan. TL was partially supported by Australian Research Council Projects DE-190101473 and IC-190100031. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            391
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Eric Arazo, Diego Ortego, Paul Albert, Noel E. O’Connor, and Kevin McGuinness. Unsupervised label noise modeling and loss correction. In ICML, pages 312–321, 2019.   \n[2] Devansh Arpit, Stanislaw Jastrzebski, Nicolas Ballas, David Krueger, Emmanuel Bengio, Maxinder S. Kanwal, Tegan Maharaj, Asja Fischer, Aaron C. Courville, Yoshua Bengio, and Simon Lacoste-Julien. A closer look at memorization in deep networks. In ICML, pages 233–242, 2017.   \n[3] Mikhail Belkin, Daniel Hsu, Siyuan Ma, and Soumik Mandal. Reconciling modern machine-learning practice and the classical bias–variance trade-off. Proceedings of the National Academy of Sciences, 116(32):15849–15854, 2019.   \n[4] David Berthelot, Nicholas Carlini, Ian J. Goodfellow, Nicolas Papernot, Avital Oliver, and Colin Raffel. Mixmatch: A holistic approach to semi-supervised learning. In NeurIPS, pages 5050–5060, 2019.   \n[5] Youngchul Cha and Junghoo Cho. Social-network analysis using topic models. In SIGIR, pages 565–574, 2012.   \n[6] Jacob Goldberger and Ehud Ben-Reuven. Training deep neural-networks using a noise adaptation layer. In ICLR, 2017.   \n[7] Ian Goodfellow, Yoshua Bengio, Aaron Courville, and Yoshua Bengio. Deep learning. The MIT Press, 2016.   \n[8] Bo Han, Gang Niu, Xingrui Yu, Quanming Yao, Miao Xu, Ivor W. Tsang, and Masashi Sugiyama. SIGUA: forgetting may make learning with noisy labels more robust. In ICML, pages 4006–4016, 2020.   \n[9] Bo Han, Quanming Yao, Xingrui Yu, Gang Niu, Miao Xu, Weihua Hu, Ivor Tsang, and Masashi Sugiyama. Co-teaching: Robust training of deep neural networks with extremely noisy labels. In NeurIPS, pages 8527–8537, 2018.   \n[10] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pages 770–778, 2016.   \n[11] Takashi Ishida, Ikko Yamane, Tomoya Sakai, Gang Niu, and Masashi Sugiyama. Do we need zero training loss after achieving zero training error? In ICML, pages 4604–4614, 2020.   \n[12] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, 2009.   \n[13] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NeurIPS, pages 1097–1105, 2012.   \n[14] Jingling Li, Mozhi Zhang, Keyulu Xu, John P. Dickerson, and Jimmy Ba. Noisy labels can induce good representations. arXiv preprint arXiv:2012.12896, 2020.   \n[15] Junnan Li, Richard Socher, and Steven C. H. Hoi. Dividemix: Learning with noisy labels as semi-supervised learning. In ICLR, 2020.   \n[16] Sheng Liu, Jonathan Niles-Weed, Narges Razavian, and Carlos Fernandez-Granda. Early-learning regularization prevents memorization of noisy labels. In NeurIPS, pages 20331–20342, 2020.   \n[17] Tongliang Liu and Dacheng Tao. Classification with noisy labels by importance reweighting. IEEE Transactions on pattern analysis and machine intelligence, 38(3):447–461, 2016.   \n[18] Wei Liu, Yu-Gang Jiang, Jiebo Luo, and Shih-Fu Chang. Noise resistant graph ranking for improved web image search. In CVPR, pages 849–856, 2011.   \n[19] Ilya Loshchilov and Frank Hutter. SGDR: stochastic gradient descent with warm restarts. In ICLR, 2017.   \n[20] Xingjun Ma, Hanxun Huang, Yisen Wang, Simone Romano, Sarah M. Erfani, and James Bailey. Normalized loss functions for deep learning with noisy labels. In ICML, pages 6543–6553, 2020.   \n[21] Xingjun Ma, Yisen Wang, Michael E. Houle, Shuo Zhou, Sarah M. Erfani, Shu-Tao Xia, Sudanthi N. R. Wijewickrema, and James Bailey. Dimensionality-driven learning with noisy labels. In ICML, pages 3361–3370, 2018.   \n[22] Preetum Nakkiran, Gal Kaplun, Yamini Bansal, Tristan Yang, Boaz Barak, and Ilya Sutskever. Deep double descent: Where bigger models and more data hurt. In ICLR, 2020.   \n[23] Duc Tam Nguyen, Chaithanya Kumar Mummadi, Thi-Phuong-Nhung Ngo, Thi Hoai Phuong Nguyen, Laura Beggel, and Thomas Brox. SELF: learning to filter noisy labels with self-ensembling. In ICLR, 2020.   \n[24] Giorgio Patrini, Alessandro Rozza, Aditya Krishna Menon, Richard Nock, and Lizhen Qu. Making deep neural networks robust to label noise: A loss correction approach. In CVPR, pages 2233–2241, 2017.   \n[25] Daiki Tanaka, Daiki Ikami, Toshihiko Yamasaki, and Kiyoharu Aizawa. Joint optimization framework for learning with noisy labels. In CVPR, pages 5552–5560, 2018.   \n[26] Yisen Wang, Weiyang Liu, Xingjun Ma, James Bailey, Hongyuan Zha, Le Song, and Shu-Tao Xia. Iterative learning with open-set noisy labels. In CVPR, pages 8688–8696, 2018.   \n[27] Yisen Wang, Xingjun Ma, Zaiyi Chen, Yuan Luo, Jinfeng Yi, and James Bailey. Symmetric cross entropy for robust learning with noisy labels. In ICCV, pages 322–330, 2019.   \n[28] Songhua Wu, Xiaobo Xia, Tongliang Liu, Bo Han, Mingming Gong, Nannan Wang, Haifeng Liu, and Gang Niu. Class2simi: A noise reduction perspective on learning with noisy labels. In ICML, pages 11285–11295, 2021.   \n[29] Xiaobo Xia, Tongliang Liu, Bo Han, Chen Gong, Nannan Wang, Zongyuan Ge, and Yi Chang. Robust early-learning: Hindering the memorization of noisy labels. In ICLR, 2021.   \n[30] Xiaobo Xia, Tongliang Liu, Bo Han, Nannan Wang, Mingming Gong, Haifeng Liu, Gang Niu, Dacheng Tao, and Masashi Sugiyama. Part-dependent label noise: Towards instance-dependent label noise. In NeurIPS, pages 7597–7610, 2020.   \n[31] Xiaobo Xia, Tongliang Liu, Nannan Wang, Bo Han, Chen Gong, Gang Niu, and Masashi Sugiyama. Are anchor points really indispensable in label-noise learning? In NeurIPS, pages 6835–6846, 2019.   \n[32] Tong Xiao, Tian Xia, Yi Yang, Chang Huang, and Xiaogang Wang. Learning from massive noisy labeled data for image classification. In CVPR, pages 2691–2699, 2015.   \n[33] Qizhe Xie, Zihang Dai, Eduard H. Hovy, Thang Luong, and Quoc Le. Unsupervised data augmentation for consistency training. In NeurIPS, pages 6256–6268, 2020.   \n[34] Yilun Xu, Peng Cao, Yuqing Kong, and Yizhou Wang. L_dmi: A novel information-theoretic loss function for training deep nets robust to label noise. In NeurIPS, pages 6222–6233, 2019.   \n[35] Yu Yao, Tongliang Liu, Bo Han, Mingming Gong, Jiankang Deng, Gang Niu, and Masashi Sugiyama. Dual T: reducing estimation error for transition matrix in label-noise learning. In NeurIPS, pages 7260–7271, 2020.   \n[36] Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In ICLR, 2016.   \n[37] Hongyi Zhang, Moustapha Cissé, Yann N. Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In ICLR, 2018. ",
+        "bbox": [
+            171,
+            88,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            89,
+            826,
+            670
+        ],
+        "page_idx": 11
+    }
+]

parse/train/SJeS16EKPr/SJeS16EKPr.md

@@ -0,0 +1,668 @@
+# LEARNING RELEVANT FEATURES FOR STATISTICAL INFERENCE
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Given two views of data, we consider the problem of finding the features of one view which can be most faithfully inferred from the other. We find that these are also the most correlated variables in the sense of deep canonical correlation analysis (DCCA). Moreover, we show that these variables can be used to construct a non-parametric representation of the implied joint probability distribution. This representation can be used to compute the expectations of functions over one view of data conditioned on the other, such as Bayesian estimators and their standard deviations. We test the approach using inference on occluded MNIST images, and show that our representation contains multiple modes. Surprisingly, when applied to supervised learning (one dataset consists of labels), this approach automatically provides regularization and faster convergence compared to the cross-entropy objective. We also explore using this approach to discover salient independent variables of a single dataset.
+
+# 1 INTRODUCTION
+
+Given samples $( x _ { 1 } , y _ { 1 } ) , \dotsc , ( x _ { n } , y _ { n } )$ from an unknown joint probability distribution $p ( x , y )$ , we want to construct a useful representation of the conditional probabilities $p ( x | y )$ and $p ( y | x )$ , so that we that we can infer one view from the other on new data.
+
+For instance, $x$ and $y$ could be past and future histories of dynamical data, visual and auditory inputs, actions and their effects, etc.
+
+Following the approach introduced in Beny & Osborne (2013; 2015b) in the context of quantum ´ information theory, we look at the problem as follows: the conditional distributions $p ( y | x )$ can be thought of as representing a noisy communication channel (stochastic map). This channel is a linear map between spaces of typically ludicrously large dimensions (the spaces of all probability distributions over $x$ or $y$ ). We want a pair of small subspaces which best represent the channel. Specifically, we look for those vectors representing probability distributions over $x$ which lose least distinguishability under the channel, where the distinguishability is measured by the $\chi ^ { 2 }$ divergence.
+
+We show in Section 3 that this is equivalent to performing a certain singular value decomposition of the channel (seen as an operator in Hilbert space) and keep only the components with the largest singular values. Moreover, the full singular value decomposition is equivalent to the decomposition in terms of canonical variables introduced in Lancaster (1958), namely,
+
+$$
+p ( \boldsymbol { y } | \boldsymbol { x } ) = p ( \boldsymbol { y } ) \sum _ { i = 1 } ^ { D } \eta _ { i } u _ { i } ( \boldsymbol { x } ) v _ { i } ( \boldsymbol { y } ) ,
+$$
+
+where $u _ { i }$ and $u _ { j }$ are real non-linear functions such that $\mathbb { E } ( u _ { i } u _ { j } ) = \delta _ { i j }$ , $\mathbb { E } ( v _ { i } v _ { j } ) = \delta _ { i j }$ , and $0 ~ <$ $\eta _ { D } \leq \cdot \cdot \cdot \leq \eta _ { 1 } \leq \eta _ { 0 } = 1$ are the singular values.
+
+The practical advantage of this representation for inference (or prediction) is that it reduces the evaluation of conditional expectations to that of empirical averages over the (unconditional) marginal $p ( y )$ .
+
+As observed in Michaeli et al. (2016), the span of the first $k$ canonical variables $u _ { i } , \ v _ { j }$ is what is learned by the deep canonical correlation analysis (DCCA) (Andrew et al., 2013). Indeed, these
+
+variables are those which maximize the correlations $\mathbb { E } ( u _ { i } v _ { i } )$ subject to the same constraints as above.   
+(This reduces to CCA (Hotelling, 1936) when $u _ { i }$ , $v _ { j }$ are linear maps).
+
+In this work, besides establishing this new information-theoretical interpretation of canonical variables and DCCA, we experiment with using this representation for performing inference on new data. Moreover, we propose a strategy for extracting disentangled variables from the canonical variables, inspired by analytical solutions.
+
+# 2 RELATED WORK
+
+This general problem (of building an effective representation of the conditional probability distributions implied by joint samples) covers many existing approaches in different contexts. For instance, if the variables $y$ has few possible states, then it reduces to a classification problem, usually solved by minimizing the crossentropy between a predicted distribution and the one-hot encoding of the classes.
+
+When $y$ has a large number of states, or is fundamentally continuous, existing approaches usually do not model the whole conditional distribution, but either provide the average (regression), or approximately sample from it.
+
+The main class of methods which allows for sampling from the conditional distributions are variational: a deterministic neural networks produces the parameters of analytical classes of probabilities.   
+This includes variational autoencoders Kingma & Welling (2013) (e.g., Iten et al. (2018); Wang et al.   
+(2016)), and approaches based on the minimum description length principle such as Gregor et al.   
+(2013).
+
+Alternatively, it may also be possible to use adversarial training Goodfellow et al. (2014), by using a conditional Mirza & Osindero (2014) version of an energy-based GAN Zhao et al. (2016).
+
+By contrast, our approach doesn’t require the training of a generative model. Instead, conditional expectations are constructed as linear combinations of unconditional empirical averages over the training data.
+
+Previous approaches to equipping CCA or DCCA with an information-theoretic interpretation have explored different directions. For instance, in Wang et al. (2016), the authors generalize a probabilistic interpretation for CCA in terms of gaussian distributions, which leads to a variational approach. In Painsky et al. (2018), additional constraints on the mutual information between the data and the learned variables are added to the optimizations.
+
+A previous attempt at designing a numerical solution for our singular value problem can be found in Beny (2018b). In that work, the relevant variables were represented through a PCA kernel produced ´ by Monte Carlo sampling, but wasn’t practical.
+
+# 3 THEORY
+
+We formalize the problem by assuming that our data was sampled from an unknown joint distribution $p ( x , y )$ over two random variables $X$ and $Y$ .
+
+Let $V _ { X }$ and $V _ { Y }$ denote the linear spaces spanned by all probability distributions over $X$ and $Y$ respectively. Here we assume that $X$ and $Y$ take finitely many values for simplicity, but this formalism can be straightforwardly extended to infinite-dimensional vector spaces.
+
+We will need inner products on $V _ { X }$ and $V _ { Y }$ , to make them into real Hilbert spaces. We use the Fisher information metrics evaluated at the points $p ( x )$ and $p ( y )$ respectively (marginals of $p ( x , y ) \mathrm { . }$ ), that is,
+
+$$
+\langle \mu , \mu ^ { \prime } \rangle _ { X } : = \sum _ { x } { \frac { \mu ( x ) \mu ^ { \prime } ( x ) } { p ( x ) } } \quad { \mathrm { a n d } } \quad \langle \nu , \nu ^ { \prime } \rangle _ { Y } : = \sum _ { y } { \frac { \nu ( y ) \nu ^ { \prime } ( y ) } { p ( y ) } }
+$$
+
+for any vectors $\mu , \mu ^ { \prime } \in V _ { X }$ and $\nu , \nu ^ { \prime } \in V _ { Y }$ .
+
+Below we also call the marginals $p _ { X }$ and $p _ { Y }$ respectively when omitting their arguments $( p _ { X } ( x ) \equiv$ $p ( x )$ and $p _ { Y } ( y ) \equiv p ( y ) \rangle$ .
+
+These inner products allow us to define the $\chi ^ { 2 }$ divergence:
+
+$$
+\chi ^ { 2 } ( q , p _ { X } ) = \langle q - p _ { X } , q - p _ { X } \rangle _ { X } ,
+$$
+
+which a measures of statistical distinguishability between $q$ and $p _ { X }$ . Specifically, it quantifies how easy it is to reject the null hypothesis that the state is $p _ { X }$ when it is actually $q$ , based on the empirical distribution obtained from independent samples. It is also the lowest order approximation of the Kullback-Leibler divergence.
+
+The joint distribution $p ( x , y )$ yields conditional distributions $p ( y | x )$ and $p ( x | y )$ . These can be understood as the components (or kernels) of stochastic maps $\mathcal { N } : V _ { X }  V _ { Y }$ and $\mathcal { N ^ { * } } : V _ { X }  V _ { Y }$ respectively. Explicitely, if $\mu \in V _ { X }$ and $\nu \in V _ { Y }$ , then the images $\mathcal { N } ( \mu ) \in V _ { Y }$ and $\mathcal { N } ^ { * } ( \nu ) \in V _ { X }$ are defined by
+
+$$
+{ \mathcal { N } } ( \mu ) ( y ) = \sum _ { x } p ( y | x ) \mu ( x ) \quad { \mathrm { a n d } } \quad { \mathcal { N } } ^ { * } ( \nu ) ( x ) = \sum _ { y } p ( x | y ) \nu ( y ) .
+$$
+
+These stochastic maps $\mathcal { N }$ and $\mathcal { N } ^ { * }$ perform inference of one variable given some (possibly imperfect) knowledge about the other, with priors given by the marginals $p ( x )$ or $p ( y )$ of $p ( x , y )$ depending on the direction of the inference. Importantly, $\mathcal { N } ^ { * }$ is the transpose of $\mathcal { N }$ in terms of the inner products defined above:
+
+$$
+\langle \nu , \mathcal { N } ( \mu ) \rangle _ { Y } = \langle \mathcal { N } ^ { * } ( \nu ) , \mu \rangle _ { X } .
+$$
+
+We now have the tools to address the problem mentioned in the introduction. The distinguishability between $q \in V _ { X }$ and $p _ { X }$ after the action of the channel $\mathcal { N }$ is $\chi ^ { 2 } ( \mathcal { N } ( q ) , p _ { Y } )$ since $p _ { Y } = \mathcal { N } ( p _ { X } )$ . Hence we want to find the distributions $p$ which maximize the relevance Beny & Osborne (2013). ´
+
+$$
+\eta ( q ) = \frac { \chi ^ { 2 } ( \mathcal { N } ( q ) , p _ { Y } ) } { \chi ^ { 2 } ( q , p _ { X } ) } = \frac { \langle \mathcal { N } ( \mu ) , \mathcal { N } ( \mu ) \rangle _ { Y } } { \langle \mu , \mu \rangle _ { X } } ,
+$$
+
+where $\mu = q - p _ { X }$ . The inner-product formulation makes it clear that this amounts to finding the eigenvector with largest eigenvalue for the symmetric map $\mathcal { N } ^ { * } \mathcal { N }$ , which is also the singular vector with largest singular value for $\mathcal { N }$ . On can then go on to find the eigenvector with next largest eigenvalue and so on, which are automatically orthogonal.
+
+In practice, the inner products are more tractable to compute if we express elements $\mu \in V _ { X }$ and $\nu \in V _ { Y }$ in terms of variables $f$ and $g$ as $\mu = p _ { X } f$ and $\nu = p _ { Y } g$ , or
+
+$$
+\mu ( x ) = p ( x ) f ( x ) \quad { \mathrm { a n d } } \quad \nu ( y ) = p ( y ) g ( y )
+$$
+
+for all $x , y$ . Indeed, this yields simply
+
+$$
+\langle \mu , \mu ^ { \prime } \rangle _ { X } = \operatorname { \mathbb { E } } ( f f ^ { \prime } ) \quad { \mathrm { a n d } } \quad \langle \nu , \nu ^ { \prime } \rangle _ { Y } = \operatorname { \mathbb { E } } ( g g ^ { \prime } ) .
+$$
+
+We are now in measure to make the connection with DCCA Andrew et al. (2013). Indeed, the aims of DCCA is to maximize the correlations $\operatorname { c o r r } ( f , g ) = \mathbb { E } ( f g )$ over function $f ( x )$ and $g ( y )$ such that $\mathbb { E } ( f ^ { 2 } ) = \mathbb { E } ( g ^ { 2 } ) = 1$ . But, using $\mu = p _ { X } f$ and $\nu = p _ { Y } g$ , we have
+
+$$
+\mathbb { E } ( f g ) = \langle \nu , \mathcal { N } ( \mu ) \rangle _ { Y } ,
+$$
+
+which is maximized by the left- and right- singular vectors $\mu$ and $\nu$ of $\mathcal { N }$ with largest singular value.
+
+Given all the singular vectors $\mu _ { i } = p _ { X } f _ { i }$ and $\nu _ { i } = p _ { Y } g _ { i }$ with singular values $\eta _ { i }$ , we obtain the representation
+
+$$
+\mathcal { N } ( \mu ) = \sum _ { i } \eta _ { i } \nu _ { i } \langle \mu _ { i } , \mu \rangle _ { X } ,
+$$
+
+which, using a more standard notation and the Kronecker delta $\delta _ { x }$ , yields Eq. 1:
+
+$$
+p ( y | x ) = { \mathcal { N } } ( \delta _ { x } ) ( y ) = { \frac { 1 } { p ( x ) } } \sum _ { i } \eta _ { i } \nu _ { i } ( y ) \mu _ { i } ( x ) = p ( y ) \sum _ { i } \eta _ { i } v _ { i } ( y ) u _ { i } ( x ) ,
+$$
+
+where $\mu _ { i } = p _ { X } u _ { i }$ and $\nu _ { i } = p _ { Y } v _ { i }$ .
+
+For the purpose of the optimization and inference, we do not need to full diagonal decomposition, but just functions $f _ { i } = \mu _ { i } / p _ { X }$ and $g _ { j } = \nu _ { j } / p _ { Y } , i , j = 1 , \ldots , k _ { 0 }$ , which have the same span as the canonical variables $u _ { i }$ and $v _ { j }$ respectively for $i , j = 1 , \ldots , k _ { 0 }$ (assuming that $\eta _ { 1 } , \ldots , \eta _ { k _ { 0 } }$ are the largest singular vector). Below we refer to $f _ { i }$ and $g _ { j }$ as the $k _ { 0 }$ most relevant variables.
+
+Because these functions may not be orthogonal, we need the covariance matrices
+
+$$
+K _ { i j } = \langle \mu _ { i } , \mu _ { j } \rangle _ { X } = \mathbb { E } ( f _ { i } f _ { j } ) , \quad L _ { i j } = \langle \nu _ { i } , \nu _ { j } \rangle _ { X } = \mathbb { E } ( g _ { i } g _ { j } ) , \quad A _ { i j } = \langle \nu _ { i } , N ( \mu _ { j } ) \rangle _ { Y } = \mathbb { E } ( g _ { i } f _ { j } ) .
+$$
+
+If $N _ { i j }$ denote the components of $\mathcal { N }$ in the sense that $\begin{array} { r } { \mathcal { N } ( p _ { X } f _ { j } ) = \sum _ { i } N _ { i j } p _ { Y } g _ { i } } \end{array}$ , then, using our inner products to isolate $N _ { i j }$ , we obtain $N = L ^ { - 1 } A$ . Similarly, the components of $\mathcal { N } ^ { * }$ are $N _ { i j } ^ { * } =$ $K ^ { - 1 } A ^ { \top }$ . This implies that the sum of the square of the singular values of $\mathcal { N }$ restricted to the spans of the vectors $p _ { X } f _ { i }$ and $p _ { Y } g _ { j }$ for all $i , j$ , which is what we want to maximize, is just given by
+
+$$
+\sum _ { i = 1 } ^ { k _ { 0 } } \eta _ { i } ^ { 2 } = \mathrm { T r } \left( N ^ { \ast } N \right) = \mathrm { T r } ( K ^ { - 1 } A ^ { \top } L ^ { - 1 } A ) .
+$$
+
+This is the DCCA objective. Below we use the objective function $C = k _ { 0 } - \mathrm { T r } \left( N ^ { \ast } N \right)$ , for the cosmetic reason that its optimal value is zero.
+
+Moreover, the corresponding truncated representation of the conditional distribution is
+
+$$
+p ( \boldsymbol { y } | \boldsymbol { x } ) = \mathcal { N } ( \delta _ { \boldsymbol { x } } ) ( \boldsymbol { y } ) \simeq p ( \boldsymbol { y } ) \sum _ { i , j = 1 } ^ { k _ { 0 } } ( L ^ { - 1 } A K ^ { - 1 } ) _ { i j } g _ { i } ( \boldsymbol { y } ) f _ { j } ( \boldsymbol { x } ) ,
+$$
+
+where we used the fact that the components of $\delta _ { x }$ are $\begin{array} { r } { \delta _ { j } = \sum _ { i } K _ { j i } ^ { - 1 } f _ { i } ( x ) } \end{array}$ .
+
+Of course, This approach can produce a faithful representation of the correlations only if $\mathcal { N }$ is actually close to being of rank $k _ { 0 }$ (see Appendix $\mathbf { B }$ for a more precise statement). If we interpret the relevant subspace as a space of probability over latent variable, this means that our latent variables have at most $k _ { 0 }$ discrete states.
+
+However, even if the rank $k _ { 0 }$ corner of $\mathcal { N }$ is a not a good approximation, this strategy allows us to nevertheless do the correct inference on certain random variables, namely those which are in the span of the canonical variables!
+
+Indeed, the exact conditional expectation of $g _ { k }$ is (assuming $D$ is the actual rank of $\mathcal { N }$ ),
+
+$$
+\begin{array} { l } { { \displaystyle \sum _ { y } g _ { k } ( y ) p ( y | x ) = \sum _ { i , j = 1 } ^ { D } ( L ^ { - 1 } A K ^ { - 1 } ) _ { i j } \mathbb { E } ( g _ { k } g _ { i } ) f _ { j } ( x ) } } \\ { { \displaystyle \qquad = \sum _ { j = 1 } ^ { D } ( A K ^ { - 1 } ) _ { k j } f _ { j } ( x ) = \sum _ { j = 1 } ^ { k _ { 0 } } ( A K ^ { - 1 } ) _ { k j } f _ { j } ( x ) } , } \end{array}
+$$
+
+where the last truncation is exact if $k \leq k _ { 0 }$ due to the assumption that the basis $f _ { i }$ and $g _ { j }$ have the same span as the $k _ { 0 }$ largest right and left singular vectors of $\mathcal { N }$ respectively.
+
+For instance, if $p ( x , y )$ is Gaussian, the canonical variables can be computed analytically, as in Lancaster (1958) or Beny (2018a) in the multivariate case. Solutions for other distributions were ´ also computed in Eagleson (1964).
+
+Notably, for any two dimensional Gaussian, the space of $k$ most relevant variables is simply spanned by the moments $f _ { n } ( x ) = x ^ { n }$ and $g _ { n } ( y ) = y ^ { n }$ for $n = 0 , \ldots , k - 1$ . Hence, in this case the first $k$ moments can be inferred exactly using only the $k + 1$ most relevant variables (See Appendix C).
+
+# 4 ALGORITHM
+
+Let us explicit the algorithm resulting from the above analysis.
+
+We assume that we are given independent samples $( x _ { 1 } , y _ { 1 } ) , ( x _ { 1 } , y _ { 2 } ) , . . .$ from the otherwise unknown joint distribution $p ( x , y )$ .
+
+We first perform DCCA (Andrew et al., 2013). That is, we need two independent deterministic feedforward neural networks. The first maps $x$ to a set of $k _ { 0 }$ real-valued variables $f _ { 1 } ( x ) , \ldots , f _ { k _ { 0 } } ( x )$ . The second maps $y$ to a different set of $k _ { 0 }$ variables $g _ { 1 } ( y ) , \ldots , g _ { k _ { 0 } } ( y )$ .
+
+The parameters of the neural networks are to be set to minimize the objective function
+
+$$
+C = k _ { 0 } - \operatorname { T r } { \left( K ^ { - 1 } A ^ { \top } L ^ { - 1 } A \right) } ,
+$$
+
+where the matrices $K , L , A$ can be approximated over a mini-batch $( x _ { n } , y _ { n } )$ , $n = 1 , \ldots , N$ via
+
+$$
+K _ { i j } = { \frac { 1 } { N } } \sum _ { n = 1 } ^ { N } f _ { i } ( x _ { n } ) f _ { j } ( x _ { n } ) , \quad L _ { i j } = { \frac { 1 } { N } } \sum _ { n = 1 } ^ { N } g _ { i } ( y _ { n } ) g _ { j } ( y _ { n } ) , \quad A _ { i j } = { \frac { 1 } { N } } \sum _ { n = 1 } ^ { N } g _ { i } ( y _ { n } ) f _ { j } ( x _ { n } ) .
+$$
+
+We found that, provided the batch size is sufficiently large compared to $k _ { 0 }$ (about 10 times in our experience), this can be minimized using ADAM or direct gradient descent. However, to guarantee stability when using large $k _ { 0 }$ , we needed to explicit the gradient of the objective function in order to force the use of the Moore-Penrose pseudo-inverses for $K ^ { - 1 }$ and $L ^ { - 1 }$ in both the forward and backward passes, in addition to using 64 bits floats in these computations.
+
+Once the relevant variables have been learned, we still need to use the training data in a second step. Indeed, suppose that we wish to use our model to infer the value of some function $\Theta ( x )$ , i.e., to compute its approximate expectation value in terms of the conditional distribution $x \mapsto p ( x | y )$ . Then we need to store, for each variable $j = 1 , \ldots , k _ { 0 }$ , the quantities
+
+$$
+\Theta _ { j } = \frac { 1 } { N _ { \mathrm { f u l l } } } \sum _ { n = 1 } ^ { N _ { \mathrm { f u l l } } } \Theta ( x _ { n } ) f _ { j } ( x _ { n } ) ,
+$$
+
+where the average is to be taken on the full training batch (of size $N _ { \mathrm { f u l l } } ,$ . The same can be done exchanging $x$ with $y$ and $f _ { j }$ with $g _ { j }$ for the reverse inference.
+
+For instance, if a data point $x$ is composed of real components $x ^ { a }$ —such as pixel color components for an image—and we are interested in the estimator which minimize the expected $l ^ { 2 }$ distance to the predicted values of these components, then we need the expectation values of the components $\Theta ( x ) = x ^ { a }$ for all $a$ , and possibly higher moments to gain more knowledge about the shape of the posterior distribution, such as the second moments $\Theta ^ { \prime } ( \bar { x } ) = x ^ { 2 }$ , etc.
+
+Inference can then be performed with new data using
+
+$$
+\overline { { { \Theta } } } = \sum _ { x } p ( x | y ) \Theta ( x ) \approx \sum _ { i , j = 1 } ^ { k _ { 0 } } ( K ^ { - 1 } A ^ { \top } L ^ { - 1 } ) _ { j i } \Theta _ { j } g _ { i } ( y ) .
+$$
+
+Moreover, the accuracy of thof the relevant variables, i.e., t depend on, for which $k _ { 0 }$ $\Theta$ taken in the span. $\begin{array} { r } { \Theta ( x ) = \sum _ { i = 1 } ^ { k } c _ { i } f _ { i } ( x ) } \end{array}$ $\begin{array} { r } { \Theta _ { j } = \sum _ { i = 1 } ^ { k _ { 0 } } c _ { i } K _ { i j } } \end{array}$
+
+The reverse inference formulas are obtained simply by the exchanges $K  L$ , $A  A ^ { \top }$ , and $g _ { i }  f _ { i }$ .
+
+# 5 EXPERIMENTS
+
+In all our experiments, we used the ADAM optimizer with learning rate 0.001. We used the Flux package (Innes, 2018) for Julia, as well as Tensorflow.
+
+As usual the data is divided into a training set and a testing set. No aspect of the testing set is used during training. The loss function refers to Eq. (7). In order to monitor overfitting, we compute a “test loss” and a “training loss”. The test loss is computed from the trained variables using only the test data, and accordingly, the training loss is computed purely using the training data.
+
+Moreover, when performing inference on test data using Eq. (10), we use the covariances $A , L , K$ and expectations $\Theta _ { j }$ (Equ. (9)) built from the training data only.
+
+# 5.1 INFERENCE ON OCCLUDED MNIST
+
+In this experiment, we use the left and right halves of the MNIST digit images as correlated variables $X$ and $Y$ . The goal is to obtain the expected left halves given the right halves, or vice versa.
+
+The training set was augmented by random small rotations and displacements to make the task more ambiguous, as we want to explore the uncertainty in the prediction.
+
+The relevant variables were represented by two convolutional neural networks of identical architecture. They are composed of four convolutional layers and one fully connected layer, an architecture that performs well for supervised learning on this dataset. For ease of implementation, these CNN have the whole image as input, but with either half zeroed (same value as black pixels). Half-width CNNs with proper padding at the cut perform similarly.
+
+After training, we used the training dataset to also compute the expected pixel gray value as well as their covariance for each relevant variable using Eq. (9).
+
+These were used into Eq. (10) to compute the mean pixel gray values and their covariances over the conditional probability of $X$ given $Y$ on test data. This mean is the Bayesian estimator for the $l ^ { 2 }$ distance between half images, i.e., it should minimize the expected distance $d _ { l ^ { 2 } }$ over the conditional distribution, where $\begin{array} { r } { d _ { l ^ { 2 } } ^ { 2 } ( x , \overline { { y } } ) = \sum _ { i } ( x _ { i } - y _ { i } ) ^ { 2 } } \end{array}$ , where $x _ { i } \in [ 0 , 1 ]$ is the value of the $\mathrm { i } ^ { t h }$ pixel. (This is equivalent to minimizing the mean square error).
+
+The results on a randomly selected subset of test digits is shown in Fig. 1. For each example, we also computed the images obtained by adding plus or minus one standard deviation along the direction of greatest variance in the space of relevant variables. This reveals the main ambiguities (such as between 8 and 3 or 7 and 9 which share a similar right half).
+
+The graph of the singular values shows that the rank cutoff of 200 is too low to capture all of the relevant variables (the sudden drop at the end is not robust to an increase in the cutoff), but the results are reasonable nevertheless. This shows that our representation of the conditional distributions contains valuable information besides the simple mean.
+
+# 5.2 SUPERVISED LEARNING
+
+In the context of a supervised classification task, one of the dataset (the labels) is of sufficiently low dimensionality that we can use a complete basis over its probability space as our relevant variables, such as the standard one-hot encoding of labels. This serves as a good first sanity test for our approach. Surprisingly, we find that it converges faster than standard approaches, and without the need for regularization.
+
+Let the variable $Y$ stands for the labels, with values in $\{ 1 , \ldots , k \}$ . The probability space consists of vectors with $k$ real components. The canonical basis corresponds to the one-hot encoding $g _ { i } ( j ) =$ $\delta _ { i j }$ (Kronecker delta). All we need is a neural network to encode $k$ variables $f _ { 1 } , \ldots , f _ { k }$ on $X$ . After learning the most relevant variables $f _ { i }$ , we apply the reverse of Eq. (10) for function $\Theta ( y ) = y$ , and use the maximum component of expected value $\overline { y }$ to infer the labels from the data.
+
+Let us refer to this procedure as DCCI (Deep Canonical Correlations based Inference).
+
+We tested this approach on the MNIST and CIFAR10 datasets, and compared the results to the standard cross-entropy objective (Fig. 2).
+
+We plotted the accuracy as function of the epoch rather than clock time which would depend on many factors. But the time per epoch is roughly the same for each approaches in the above experiments. Indeed, the training time is dominated by the forward and backward evaluations of the neural networks which are identical. (However, the time it takes to evaluate our objective can become significant for much larger number of labels $k$ , since it involves the inversion of matrices of dimension $k$ . This is in addition to the fact that a greater dimension would require also larger batches.)
+
+We found that, without regularization, simply changing the objective from cross-entropy to DCCI provided a large improvement both of convergence speed and final accuracy for both models.
+
+![](images/201f3ce00c47dbafcb9ef33dbcddfe321ec4b0f6d68f48039079f27a17681d75.jpg)  
+Figure 1: Left mosaic: the left halves of the MNIST digits in a random sample from the test set are inferred from the right half, with cutoff $k _ { 0 } = 2 0 0$ . Three images are shown for each digit. Within each triplet, the middle image represents the mean over pixel intensity of the inferred condition distribution, while left and right images corresponds to a plus and minus one standard deviation from the mean in the direction of largest covariance (in the space of half-images). A particularly interesting example is highlighted. Top-right: loss per epoch for $k _ { 0 } ~ = ~ 2 0 0$ . Bottom-right: the singular values for different values of the cutoff $k _ { 0 }$ , after 150 epochs in each case.
+
+![](images/f1a73e5112ee1b5d1d1b809be05b2c39b82dfe510aa9cbf963a2647ac4f9eb88.jpg)  
+Figure 2: Loss and inaccuracy (error rate) on test sets for two classification tasks. The models were trained either using the cross-entropy (CE) or our approach (DCCI), with or without regularization layers. On the MNIST dataset, we used an “all CNN” network, and for the CIFAR10 dataset we used a short VGG variation with 10 convolutions and 3 fully connected layers. In the regularized form, post-activation Batchnorm layers were placed after each convolutional layers on the VGG network. What is shown is the mean over 10 independent runs for MNIST and 5 runs for CIFAR10. The shaded area spans the standard deviation. ADAM with default parameters was used in all cases. No data augmentation was used except for horizontal flips for CIFAR10 (resulting in epochs of 100,000 images).
+
+![](images/03b9882c59b4695eeffc013e7377800c0cf409c81087a146cf7fe4fc6b062c90.jpg)  
+Figure 3: Top-left: First 20 relevant variables (on $X$ ) determined by DCCA for a system where $X$ consists of two coordinates uniformly sampled over a circle and a surrounding ring, and $Y$ consists of the same points but shifted by a small normally distributed vector. The variables are arranged from left-to-right and top-to-bottom in order of decreasing relevance. Top-right: the same variables multiplied by the marginal $p _ { X }$ . Bottom row: introducing a gap in the ring allows for a monotonous function of the angle to serve as second most relevant variable (instead of the sine/cosine couple). Hence the angle is automatically “disentangled” from the other variables. (Mid-gray represents the value 0).
+
+On MNIST, DCCI alone also outperformed cross-entropy with dropout. (Dropout did not yield any improvement in conjunction with DCCI). However, adding batch-normalization layers on the CIFAR example, erased any distinction between DCCI and cross-entropy.
+
+# 5.3 STRUCTURE OF THE RELEVANT VARIABLES
+
+We mentioned in Section 3 that if $p ( x , y )$ is a two-dimensional Gaussian distribution with zero mean, then the $n$ most relevant variables of $X$ are the first $n$ powers of $X$ itself, independently of the covariance matrix. This implies that the canonical variables are the Hermite polynomials in $X$ (which results from applying the Gram-Schmidt procedure to the basis $\{ 1 , x , x ^ { 2 } , \bar { . . . } \bar  \} \}$ .
+
+A similar property holds for multivariate Gaussians, namely, the less relevant singular values are polynomials in the more relevant ones. If this is true more generally, it should be possible to further compress and organize the latent space extracted with DCCA by finding a minimal set of generators, which ought to also be in the span of the most relevant variables.
+
+We applied DCCA to a synthetic dataset to explore this idea, shown in Fig. 3. In this case, we actually performed a final SVD to obtain the unique uncorrelated canonical variables, and ordered them by decreasing relevance (their respective singular values).
+
+Here, $X$ consists of two real numbers, distributed uniformly within a ring and a disk. The variable $Y$ is obtained by adding a random Gaussian shift to $X$ with a small standard deviation. The more relevant variables ought to be those which are more robust to such small random displacement. This formalizes the idea that we are interested in extracting “large-scale” variables Beny (2018b). ´
+
+We would expect the relevant independent variables to be: the binary variable indicating whether the point is in the disk or the ring and the angle around the ring, followed by the radial component in the ring, and finally the Cartesian coordinates inside the disk. This is precisely what we see in Fig. 3.
+
+Indeed—if we put aside for now the fact that the angle itself is not directly represented—besides the constant function, the two most relevant variables are the sine and cosine of the angle, followed by the binary variable separating the disk from the ring.
+
+But these variables ought to span the space of probabilities over the relevant variables, not just the variables themselves. Hence the next six variables are sines and cosines of smaller wavelength, which can encode probability distributions which are increasingly more precisely localized, down to a precision (wavelength) comparable with the diameter of the inner disk. Accordingly, the next two most relevant variables are the Cartesian coordinates inside the disk. This is followed by additional moments of the angle, down to a wavelength equal to the ring’s thickness, at which point we see the radius in the ring appear.
+
+![](images/139ed066324617d38572ae37b20db57c2963cbc5f2e6fcfe36fcf651198597fd.jpg)  
+Figure 4: Left: Best mean squared error for images reconstructed from the $k$ most relevant variables, as a function of $k$ (the latent dimension). This logarithmic plot shows that improvements stop once the dimension reaches 19 (where the two lines cross). Right: images produced by the generator from latent variables sampled according to the best Gaussian fit in latent space, for feature subspaces of dimensions 2, 8 and 19.
+
+As mentioned, we see that the angle itself is not represented, likely because it is discontinuous. However, as shown also in Fig. 3, creating a gap in the ring allows for the angle to emerge as most relevant variable. This suggests that this approach may be able to automatically learn intrinsic coordinates of the latent variable manifold.
+
+# 5.4 INDEPENDENT VARIABLES AND GENERATIVE MODEL
+
+If we postulate that the independent (or disentangled) relevant latent variables can be found in the linear span of the relevant variables, we can attempt to extract them by optimizing a neural network composed of two parts. Firstly, a linear layer maps the relevant variables to a small number of outputs (equal to the latent dimension). The purpose of this linear layer is to find the independent variables. These latent variables are then processed by an arbitrarily complex generative network to produce a possible value of the variable $X$ . As objective function, we may us an appropriate measure of similarity between the output and the data element from which the variables were obtained.
+
+We tested this idea as follows. We took $X$ to consist of the MNIST digits, and produced $Y$ by randomly permuting neighboring pixels in the image, until the mean displacement per pixel is of order 1. In addition, we added independent Gaussian noise to the pixel values. (Hence the noise map $\mathcal { N }$ simulates the coarse-graining channel introduced in Beny & Osborne (2015a)). ´
+
+As in the previous experiment, we do so to implement our intuition that the more relevant variables ought to be the ones which are of larger scale, or more robust to local perturbations.
+
+The relevant variables of the clean images were produced by the same convolutional neural network as in Section 5.2, while the variables of the coarse-grained images were extracted by a network of the same geometry, but with half the number of filters and neurons.
+
+We extracted the 1000 most relevant out of 1200 learned variables in this way. (The least relevant variables in this system happen to be highly dependent on the total number of variables and hence cannot be trusted to be correct). As a second step, we trained a linear layer coupled to a network composed of 5 fully-connected layers of 800 hidden neurons each. We refer to the number of output neurons in the first linear layer as the latent dimension.
+
+As input, this network received the variables extracted from MNIST images using the above convolutional neural net (after it was fully trained using DCCA), and was trained to minimize the mean square error between its output and the original MNIST digit.
+
+The resulting best mean square errors are shown in Fig. 4, as function of the latent dimension. Here we see a distinct change of polynomial scaling law at dimension 19. Increasing the dimension further provides no improvement. This behaviour is compatible with our hypothesis that the extra variables are just functions of those first twenty variables (functions which are effectively re-implemented by the generative network).
+
+Images generated by sampling from a Gaussian approximation of the latent distribution for different latent dimensions are shown in Fig. 4. Below dimension 20, most generated image can be recognized as a specific digit.
+
+# 6 OUTLOOK
+
+We studied the classical (non-quantum) form of the theory introduced in Beny & Osborne (2013), ´ and found that the relevant observables of that theory are just the most correlated canonical variables in the sense of DCCA Andrew et al. (2013), and can be learned effectively using standard machine learning methods.
+
+This point of views on DCCA provided us with several new insights. The first is that the learned relevant variables provide a useful representation of a joint probability distribution. We showed that performing inference using this representation can outperform crossentropy in predicting classes. Our experiments on halves of MNIST also show that the conditional distribution we obtain can effectively represent the uncertainty in the prediction of high-dimensional data.
+
+A second insight relates to the interpretation of the canonical variables as spanning directions in the space of probability distributions. As suggested by the gaussian solutions and our experiment on synthetic data, we postulate that the canonical variables are functions of a small number of independent generators contained in their span. This hypothesis is supported by our experiment on MNIST, but further work is required to find a way to cleanly extract these variables.
+
+We have yet to explore the potential applications of one of the salient aspect of this approach to inference, the fact that the canonical variables learned using DCCA are also those which can be most reliably predicted, irrespective of the value of the cutoff. To see why this is potentially significant, we observe that a central feature of scientific exploration is that we are not so concerned with making predictions about some given variables, as much as we are with discovering variables which can be predicted.
+
+Another important feature of this approach is the fact that the resulting model allows for the direct evaluation of the expectation values in the posterior distribution without sampling. In particular this allows for the evaluation of credible intervals. Hence it should be especially suited to scientific applications where the ability to quantify uncertainty is essential.
+
+Finally, the relationship that we established with theory of quantum origin points towards a potential quantum generalization of DCCA that would apply to quantum data, or classical measurements of quantum systems.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Joel B ¨ eny and Raban Iten for helpful suggestions. We are also in- ´ debted to an anonymous ICLR2020 referee for pointing out the connection between our approach and DCCA. This work was supported by the National Research Foundation of Korea (NRF2018R1D1A1A02048436).
+
+# REFERENCES
+
+Galen Andrew, Raman Arora, Jeff Bilmes, and Karen Livescu. Deep canonical correlation analysis. In International conference on machine learning, pp. 1247–1255, 2013.
+
+C. Beny and T. J. Osborne. Information geometric approach to the renormalisation group. ´ Phys. Rev. A, 92:022330, 2015a. doi: 10.1103/PhysRevA.92.022330. (arXiv:1206.7004).   
+Cedric B ´ eny. Coarse-grained distinguishability of field interactions. ´ Quantum, 2:67, 2018a. (arXiv:1509.03249).   
+Cedric B ´ eny. Inferring relevant features: from qft to pca. ´ International Journal of Quantum Information, 16:1840012, 2018b. (arXiv:1802.05756).   
+Cedric B ´ eny and Tobias J Osborne. Renormalisation as an inference problem. ´ (arXiv:1310.3188), 2013.   
+Cedric B ´ eny and Tobias J Osborne. The renormalisation group via statistical inference. ´ New J. Phys., 17:083005, 2015b. doi: 10.1088/1367-2630/17/8/083005. (arXiv:1402.4949).   
+GK Eagleson. Polynomial expansions of bivariate distributions. The Annals of Mathematical Statistics, 35(3):1208–1215, 1964.   
+Carl Eckart and Gale Young. The approximation of one matrix by another of lower rank. Psychometrika, 1(3):211–218, 1936.   
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.   
+Karol Gregor, Ivo Danihelka, Andriy Mnih, Charles Blundell, and Daan Wierstra. Deep autoregressive networks. arXiv preprint arXiv:1310.8499, 2013.   
+Harold Hotelling. Relations between two sets of variates. Biometrika, 28(3/4):321–377, 1936.   
+Mike Innes. Flux: Elegant machine learning with julia. Journal of Open Source Software, 2018. doi: 10.21105/joss.00602.   
+Raban Iten, Tony Metger, Henrik Wilming, L´ıdia Del Rio, and Renato Renner. Discovering physical concepts with neural networks. (arXiv:1807.10300), 2018.   
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. (arXiv:1312.6114), 2013.   
+HO Lancaster. The structure of bivariate distributions. The Annals of Mathematical Statistics, 29 (3):719–736, 1958.   
+Tomer Michaeli, Weiran Wang, and Karen Livescu. Nonparametric canonical correlation analysis. In International Conference on Machine Learning, pp. 1967–1976, 2016.   
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint arXiv:1411.1784, 2014.   
+M. Ohya and D. Petz. Quantum entropy and its use. Springer Verlag, 2004.   
+Amichai Painsky, Meir Feder, and Naftali Tishby. An information-theoretic framework for nonlinear canonical correlation analysis. arXiv preprint arXiv:1810.13259, 2018.   
+Weiran Wang, Xinchen Yan, Honglak Lee, and Karen Livescu. Deep variational canonical correlation analysis. arXiv preprint arXiv:1610.03454, 2016.   
+Junbo Zhao, Michael Mathieu, and Yann LeCun. Energy-based generative adversarial network. arXiv preprint arXiv:1609.03126, 2016.
+
+# A EXTRA INFORMATION ABOUT THE ALGORITHM
+
+# A.1 ALTERNATIVE INTERPRETATION OF THE OBJECTIVE
+
+If we write $F _ { i j } : = f _ { j } ( x _ { i } )$ and $G _ { i j } : = g _ { j } ( y _ { i } )$ for the value of our variables on the dataset, then $\begin{array} { r } { K = \frac { 1 } { N } F ^ { \top } F } \end{array}$ , $\begin{array} { r } { L = \frac { 1 } { N } G ^ { \top } G } \end{array}$ and $\begin{array} { r } { A = \frac { 1 } { N } G ^ { \top } F } \end{array}$ . The DCCA objective can then be written as
+
+$$
+\operatorname { T r } \left( K ^ { - 1 } A ^ { \top } L ^ { - 1 } A \right) = \operatorname { T r } \left( P Q \right)
+$$
+
+where $P = F ( F ^ { \top } F ) ^ { - 1 } F ^ { \top }$ and $Q = G ( G ^ { \top } G ) ^ { - 1 } G ^ { \top }$ are the projectors on the ranges of $F$ and $G$ respectively. Hence, we are maximizing the overlap between those ranges (which represent possible linear combinations of datapoints, respectively determined from variables of one or the other correlated views.)
+
+# A.2 HEURISTIC
+
+Batch size—In our experiments, we observed that the batch size during training needs to be an order of magnitude larger than the number of variables (rank cutoff). When the batch size was too small, learning seemed to converge normally in terms of training and test loss, but resulted in variables which yield dramatically different losses when evaluated on larger batches, and yield spurious predictions.
+
+Constant variables—The loss function $C$ takes value between 0 and $k _ { 0 } - 1$ because the constant variable always has relevance 1. The constant variable could be enforced a priori rather than learned, which, due to the objective, automatically forces the learned variables to have zero expectation values (be orthogonal to the constant variable). This might have advantages in certain circumstances, but in our experiments we found that this sometime hindered convergence.
+
+Invertibility issues—The covariance matrices $K$ and $L$ can be ill-conditioned, potentially causing the gradient to “explode” because of the inverses $K ^ { - 1 }$ et $L ^ { - 1 }$ involved in the loss function. This can be avoided either by using the Moore-Penrose pseudo-inverse, or by replacing $K ^ { - 1 }$ by $( K + \epsilon { \bf 1 } ) ^ { - 1 }$ in the loss for some small positive number $\epsilon$ , and likewise for $L ^ { - 1 }$ .
+
+Symmetries in the loss function—The loss $C$ only depends on the span of the variables $f _ { i }$ and $g _ { j }$ , hence it has a very large group of symmetries. In particular, it is invariant under a change of the norm of each variable independently from each other. Because of that, it is preferable not to have a linear last layer. Using a hyperbolic tangent as last nonlinearity worked in our experiments.
+
+Regularization—In all our tests, dropout had no beneficial effect. In fact, our objective seems to already provide a form of regularization, as shown in Section 5.2.
+
+# B THEORY IN MORE DETAILS
+
+We consider two correlated random variables $X$ and $Y$ with a joint probability distribution $p ( x , y )$ . We assume that we are able to numerically evaluate expectations with respect to this distribution, for instance because we can sample from it. We want to use this ability in order to compute expectations with respect to the conditional distributions $p _ { X | Y } ( x | y ) \ : = \ : \dot { p } ( x , y ) / p _ { X } ( x )$ and $p _ { Y | X } ( y | x ) ~ = ~ p ( x , y ) / p _ { Y } ( y )$ , where $\begin{array} { r } { p _ { X } ( x ) \ = \ \sum _ { y } p ( x , y ) } \end{array}$ and $\begin{array} { r } { p _ { Y } ( y ) \ = \ \sum _ { x } p ( x , y ) } \end{array}$ are the marginals of $p$ . Below we sometime remove the subscripts $X , X | Y$ or $Y | X$ if there is no ambiguity.
+
+For instance, suppose we generated samples of $y$ given $x$ , through explicit knowledge of $p _ { Y \mid X }$ . Then the evaluation of expectations with respect to $p _ { X | Y }$ is the subject of Bayesian inference. However, this is generally done in a context where the variable $X$ has low dimensionality and parameterizes a hand-crafted model. Our approach, however, is free of such a model and the variable $X$ can be of very high dimensionality.
+
+# B.1 INNER PRODUCT ON PROBABILITY VECTORS
+
+In order to define our strategy, we need to equip the spaces of probability distributions for $X$ and $Y$ with an inner product structure. Let us focus on $X$ , and assume that it takes discrete values to avoid unnecessary technicalities. The set of probability vectors is a convex subset of the real linear space $V _ { X } = \mathbb { R } ^ { n }$ . Let us equip this space with the product
+
+$$
+\langle \mu , \mu ^ { \prime } \rangle _ { X } : = \sum _ { x } { \frac { \mu ( x ) \mu ^ { \prime } ( x ) } { p _ { X } ( x ) } }
+$$
+
+for any $\mu , \mu ^ { \prime } \in V _ { X }$ . We also write $\| \mu \| _ { X } ^ { 2 } = \langle \mu , \mu \rangle _ { X }$ . Importantly, this depends explicitly on the fixed probability vector $p _ { X } ( x )$ , which we took to be the marginal of $p ( x , y )$ . If $p _ { X }$ has full support, this makes $V _ { X }$ into a real inner product space. The same can be done for the variable $Y$ , yielding the inner product $\langle \nu , \nu ^ { \prime } \rangle _ { Y }$ for $\nu , \nu ^ { \prime } \in V _ { Y }$ .
+
+Had we interpreted $\mu$ and $\mu ^ { \prime }$ as tangent vectors to $V _ { X }$ , considered as a manifold, this would be the Fisher information (Riemannian) metric, as in Beny & Osborne (2015b). But this quantity is also ´ meaningful for finite vectors: the induced norm distance between $p _ { X }$ and any probability vector $q$ is the $\chi ^ { 2 }$ -divergence:
+
+$$
+\chi ^ { 2 } ( q , p _ { X } ) = \langle q - p _ { X } , q - p _ { X } \rangle _ { X } .
+$$
+
+The set of conditional probability distributions $p _ { Y \mid X }$ form a stochastic map, i.e., a linear map $\mathcal { N }$ $V _ { X } \to V _ { Y }$ , $\mu \mapsto { \mathcal { N } } ( \mu )$ , where
+
+$$
+\mathcal { N } ( \mu ) ( y ) = \sum _ { x } p _ { Y | X } ( y | x ) \mu ( x )
+$$
+
+for any $\mu \in V _ { X }$ .
+
+It is straightforward to check that the stochastic map $\mathcal { N } ^ { * }$ defined by
+
+$$
+\mathcal { N ^ { * } } ( \nu ) ( x ) = \sum _ { x } p _ { X | Y } ( x | y ) \nu ( x )
+$$
+
+is the transpose $\mathcal { N } ^ { * }$ of $\mathcal { N }$ with respect to the inner products we defined (Ohya & Petz, 2004), i.e., for all $\nu \in V _ { Y }$ and $\mu \in V _ { X }$ ,
+
+$$
+\langle \nu , \mathcal { N } ( \mu ) \rangle _ { Y } = \langle \mathcal { N } ^ { * } ( \nu ) , \mu \rangle _ { X } .
+$$
+
+Also, we observe that $\mathcal { N } ( p _ { X } ) = p _ { Y }$ and $\mathcal { N } ^ { * } ( p _ { Y } ) = p _ { X }$ .
+
+# B.2 EIGEN-RELEVANCE DECOMPOSITION
+
+We can use the inner products on $V _ { X }$ and $V _ { Y }$ to define a singular value decomposition of the stochastic map $\mathcal { N }$ . That is, there is an orthonormal family $u _ { 1 } , \ldots , u _ { k }$ of $V _ { X }$ and an orthonormal family $v _ { 1 } , \ldots , v _ { k }$ of $V _ { Y }$ , such that
+
+$$
+\begin{array} { r } { \mathcal { N } ( u _ { j } ) = \eta _ { j } v _ { j } , } \end{array}
+$$
+
+for $j = 1 , \dotsc , k$ . For each $j , \eta _ { j }$ is a singular value of $\mathcal { N }$ , whose square we call the relevance of the vector $v _ { j }$ . Moreover $\eta _ { j } \in [ 0 , 1 ]$ since the $\chi ^ { 2 }$ divergence is contractive under any stochastic map. Given that ${ \ddot { \mathcal { N } } } ^ { * }$ is the transpose of $\mathcal { N }$ :
+
+$$
+\begin{array} { r } { \mathcal { N } ^ { * } ( v _ { j } ) = \eta _ { j } u _ { j } . } \end{array}
+$$
+
+Equivalently, $u _ { j }$ is an eigenvector of $\mathcal { N } ^ { \ast } \circ \mathcal { N }$ and $v _ { j }$ is an eigenvectors of $\mathcal { N } \circ \mathcal { N } ^ { \ast }$ , both with eigenvalue $\eta _ { j } ^ { 2 }$ .
+
+Because $\mathcal { N }$ maps $p _ { X }$ to $p _ { Y }$ , we always have the dual eigenvectors $u _ { 0 } ~ = ~ p _ { X }$ and $v _ { 0 } = p _ { Y }$ with eigenvalue 1.
+
+# B.3 LOW-RANK APPROXIMATION
+
+Typically, the dimension $k$ of the space of probabilities is more than astronomically large. For instance, if the values of $X$ consists of small 256 gray level images of $2 8 \times 2 8$ pixels, then $k =$
+
+$2 5 6 ^ { 2 8 ^ { 2 } } \simeq 1 0 ^ { 1 8 8 8 }$ . However, in many case, only very few of these dimensions may be relevant for the purpose of inferring other variables.
+
+The core of our approach is to approximate $\mathcal { N }$ and $\mathcal { N } ^ { * }$ by restricting them to the span of the first $k _ { 0 }$ eigenvectors $u _ { j }$ and $v _ { j }$ with largest singular values $\eta _ { j }$ . That is, if we order the singular values $\eta _ { j }$ , $j = 1 , \dots , k$ in decreasing order, we propose to use the approximations
+
+$$
+\begin{array} { l } { { \displaystyle \mathcal { N } _ { 0 } ( \mu ) = \sum _ { j \leq k _ { 0 } } \eta _ { j } \langle u _ { j } , \mu \rangle _ { X } v _ { j } } } \\ { { \displaystyle \mathcal { N } _ { 0 } ^ { * } ( \nu ) = \sum _ { j \leq k _ { 0 } } \eta _ { j } \langle v _ { j } , \nu \rangle _ { Y } u _ { j } } } \end{array}
+$$
+
+to $\mathcal { N }$ and $\mathcal { N } ^ { * }$ respectively, for some $k _ { 0 }$ typically much smaller than $k$ , and any $\mu \in V _ { X }$ , $\nu \in V _ { Y }$ .
+
+We denote the components of $\mathcal { N } _ { 0 }$ and $\mathcal { N } _ { 0 } ^ { \ast }$ by $q ( y | x )$ and $q ( x | y )$ , e.g.,
+
+$$
+{ \mathcal { N } } _ { 0 } ( \mu ) ( y ) = \sum _ { x } q ( y | x ) \mu ( x ) .
+$$
+
+Since $\mathcal { N } _ { 0 }$ and $\mathcal { N } _ { 0 } ^ { \ast }$ are adjoint, we can define $q ( x , y ) = q ( x | y ) p _ { Y } ( y ) = q ( y | x ) p _ { X } ( x )$ . Although the marginals of $\dot { \boldsymbol { q } } ( \boldsymbol { x } , \boldsymbol { y } )$ are the probability distributions $p _ { X }$ and $p _ { Y }$ , the numbers $q ( x , y )$ are not necessarily positive.
+
+The quality of this approximation for a given $k _ { 0 }$ does not directly depend on the dimensionality of $X$ and $Y$ , but only on the amount of correlations between the two variables. Our aim is to use a $k _ { 0 }$ small enough that the components of $\mathcal { N } _ { 0 }$ and $\mathcal { N } _ { 0 } ^ { \ast }$ can be computed explicitly.
+
+Theorem 1. $\mathcal { N } _ { 0 }$ is the map of rank $k _ { 0 }$ which minimizes the average distance
+
+$$
+\sum _ { x } p ( x ) \| \mathcal { N } _ { 0 } ( \delta _ { x } ) - \mathcal { N } ( \delta _ { x } ) \| _ { Y } ^ { 2 } = \sum _ { x y } \frac { ( q ( x , y ) - p ( x , y ) ) ^ { 2 } } { p ( x ) p ( y ) } .
+$$
+
+Proof. The low rank approximation $\mathcal { N } _ { 0 }$ minimizes the distance $\| \mathcal { N } _ { 0 } - \mathcal { N } \| _ { \mathrm { F } }$ where
+
+$$
+\| \mathcal { M } \| _ { F } ^ { 2 } = \mathrm { T r } \left( \mathcal { M } ^ { * } \mathcal { M } \right)
+$$
+
+is the Hilbert-Schmidt (or Frobenius) norm (Eckart & Young, 1936). This follows from the fact that this is also the $l ^ { 2 }$ -norm of the vector of singular values of $\mathcal { M }$ . Let us find the explicit form of the trace. Each possible value $x$ of the variable $X$ is associated with a probability distribution $\delta _ { x } ( y ) = 1$ when $x = y$ and zero otherwise. These distributions form an orthogonal basis of $V _ { X }$ , and have norms $\langle \delta _ { x } , \delta _ { x } \rangle = 1 / p _ { X } ( x )$ . Therefore,
+
+$$
+\begin{array} { l } { \displaystyle \operatorname { T r } \left( \mathcal { M ^ { * } M } \right) = \sum _ { x } p _ { X } ( x ) \langle \delta _ { x } , \mathcal { M ^ { * } M } ( \delta _ { x } ) \rangle _ { Y } } \\ { \displaystyle \quad = \sum _ { x } p _ { X } ( x ) \| \mathcal { M } ( \delta _ { x } ) \| _ { Y } ^ { 2 } } \end{array}
+$$
+
+# B.4 RELEVANT VARIABLES
+
+We express the elements $\mu \in \ V _ { X }$ and $\nu \in \ V _ { Y }$ in terms of the marginals $p _ { X }$ and $p _ { Y }$ as simple products:
+
+$$
+\mu ( x ) = p _ { X } ( x ) f ( x ) \quad { \mathrm { a n d } } \quad \nu ( y ) = p _ { Y } ( y ) g ( y )
+$$
+
+for all $x , y$ , where $f$ and $g$ are real functions of $x$ and $y$ .
+
+The inner products then simply become correlations among variables. Using also $\mu ^ { \prime } = p _ { X } f ^ { \prime }$ and $\nu ^ { \prime } = p _ { Y } g ^ { \prime }$ , we obtain
+
+$$
+\begin{array} { l } { { \langle \mu , \mu ^ { \prime } \rangle _ { X } = \displaystyle \sum _ { x } p _ { X } ( x ) f ( x ) f ^ { \prime } ( x ) = \overline { { { f f ^ { \prime } } } } , } } \\ { { \langle \nu , \nu ^ { \prime } \rangle _ { Y } = \displaystyle \sum _ { y } p _ { Y } ( y ) g ( y ) g ^ { \prime } ( y ) = \overline { { { g g ^ { \prime } } } } . } } \end{array}
+$$
+
+These are simple expectation values with respect to $p$ , which we assumed is the type of quantity we can evaluate for arbitrary functions $f , f ^ { \prime } , g , \bar { g ^ { \prime } }$ .
+
+Since $\mathcal { N } ^ { * } \mathcal { N }$ is self-adjoint in terms of this inner product, its eigenvectors $u _ { i }$ are orthogonal, and hence the corresponding variables $a _ { i }$ defined by ${ u } _ { i } \bar { ( x ) } = p _ { X } ( x ) \bar { a _ { i } } ( x )$ are uncorrelated. Indeed,
+
+$$
+\overline { { a _ { i } a _ { j } } } = \langle u _ { i } , u _ { j } \rangle _ { X } = 0 ,
+$$
+
+for all $i , j$ . Moreover, accounting for the eigenvector $u _ { 0 } = p _ { X }$ (corresponding to the constant feature $a _ { 0 } ( x ) = 1$ for all $x$ ),
+
+$$
+\overline { { a } } _ { i } = 0
+$$
+
+for all $i \neq 0$ . Hence we trivially have
+
+$$
+\overline { { a _ { i } a _ { j } } } = \overline { { a } } _ { i } \overline { { a } } _ { j }
+$$
+
+for all $i , j \neq 0$ .
+
+Likewise for the eigenvectors of $\mathcal { N N } ^ { * }$ . If $v _ { i } ( y ) = p _ { Y } ( y ) b _ { i } ( y )$ :
+
+$$
+\overline { { b _ { i } b _ { j } } } = \langle v _ { i } , v _ { j } \rangle _ { Y } = 0 = \overline { { b } } _ { i } \overline { { b } } _ { j } .
+$$
+
+for all $i , j \neq 0$ .
+
+Importantly, this does not mean that the variables $u _ { 1 } , u _ { 2 } , \ldots$ nor $v _ { 1 } , v _ { 2 } , \ldots$ are “disentangled”, i.e., they are not statistically independent. These variables represent components in the space of probability vectors, rather than the “sample” space. They should be understood as spanning a subspace of the space of functions over the relevant independent variables. We discuss this in more detail in Section 5.3.
+
+# B.5 CORNERS OF $\mathcal { N }$ AND LOSS FUNCTION
+
+The final piece of puzzle we need, is the ability to express the components (corners) of $\mathcal { N }$ and $\mathcal { N } ^ { * }$ in the span of possible non-orthogonal families of variables.
+
+Let us therefore consider two arbitrary families $f _ { 1 } , \ldots , f _ { k _ { 0 } }$ and $g _ { 1 } , \ldots , g _ { k _ { 0 } }$ of variables, which respectively represent the vectors $p _ { X } f _ { j } \in V _ { X }$ and $p _ { Y } g _ { j } \in V _ { Y }$ .
+
+Firstly, we need matrices representing the components of the inner products on $V _ { X }$ and $V _ { Y }$ . Those are the symmetric matrices
+
+$$
+\begin{array} { r } { K _ { i j } = \langle p _ { X } f _ { i } , p _ { X } f _ { j } \rangle _ { X } = \overline { { f _ { i } f _ { j } } } , } \\ { L _ { i j } = \langle p _ { Y } g _ { i } , p _ { Y } g _ { j } \rangle _ { Y } = \overline { { g _ { i } g _ { j } } } . } \end{array}
+$$
+
+The components $N _ { i j }$ of $\mathcal { N }$ are defined by
+
+$$
+\mathcal { N } ( p _ { X } f _ { j } ) = \sum _ { i } N _ { i j } p _ { Y } g _ { i } .
+$$
+
+Taking the inner product with $p _ { Y } g _ { k }$ , we obtain
+
+$$
+\langle p _ { Y } g _ { k } , \mathcal { N } ( p _ { X } f _ { j } ) \rangle = \sum _ { i } N _ { i j } L _ { k i } .
+$$
+
+The left-hand side can be computed using Equ. 13. It is the matrix
+
+$$
+\begin{array} { l } { { \displaystyle { \cal A } _ { k j } = \langle p _ { Y } g _ { k } , { \cal N } ( p _ { X } f _ { j } ) \rangle } } \\ { { \displaystyle ~ = \sum _ { x , y } \frac { p _ { Y } ( y ) g _ { k } ( y ) p _ { Y | X } ( y | x ) p _ { X } ( x ) f _ { j } ( x ) } { p _ { Y } ( y ) } } } \\ { { \displaystyle ~ = \sum _ { x , y } p ( x , y ) g _ { k } ( y ) f _ { j } ( x ) = \overline { { g _ { k } f _ { j } } } . } } \end{array}
+$$
+
+Therefore, in matrix notation, Equ. (34) is $A = L N$ , or
+
+$$
+N = L ^ { - 1 } A .
+$$
+
+The components $N _ { i j } ^ { * }$ of $\mathcal { N } ^ { * }$ are obtained by just swapping $X$ and $Y$ , yielding
+
+$$
+N ^ { * } = K ^ { - 1 } A ^ { \top } .
+$$
+
+Hence the singular values of the corner of $\mathcal { N }$ defined by the variables $f _ { j }$ and $g _ { j }$ are just the squareroot of the eigenvalues of the matrix $N ^ { * } N = K ^ { - 1 } A ^ { \top } L ^ { - 1 } A$ . In order to find the variables $f _ { j }$ and $g _ { j }$ with the same span as the first $k _ { 0 }$ eigenvectors $u _ { j } , v _ { j }$ , we just need to maximize all the eigenvalues of $N ^ { * } N$ . A simple way to do this is to use (minus) the trace of $N ^ { * } N$ as loss function, since it is the sum of the square of the singular values. We call $\mathrm { T r } \left( N ^ { * } N \right)$ the relevance of the subspaces defines by the variables $f _ { j }$ ad $g _ { i }$ for all $i , j$ . This yields the loss/cost function:
+
+$$
+C = k _ { 0 } - \operatorname { T r } \left( N ^ { \ast } N \right) = k _ { 0 } - \operatorname { T r } \left( K ^ { - 1 } A ^ { \top } L ^ { - 1 } A \right) .
+$$
+
+Once optimal variables have been found, one can obtain the components of the eigenvectors in the span of $f _ { 1 } , \ldots , f _ { k _ { 0 } }$ through standard numerical diagonalization of $N ^ { * } N$ .
+
+# B.6 INFERENCE
+
+The variables minimizing $C$ can be used to infer one variable from the other. For instance, given $y$ , the inferred probability distribution over $x$ is given by $p _ { X | Y } ( x | y ) = \mathcal { N } ^ { * } ( \delta _ { y } ) ( x )$ , where $\delta _ { y } ( \bar { y } ^ { \prime } )$ is 1 when $y = y ^ { \prime }$ and zero otherwise. In order to compute this, we first need the components of the distribution $\delta _ { y }$ in terms of the family $p _ { Y } g _ { 1 } , \ldots , p _ { Y } g _ { k _ { 0 } }$ , i.e., the real numbers $( \delta _ { y } ) _ { j }$ such that
+
+$$
+\delta _ { y } ( y ^ { \prime } ) = p _ { Y } ( y ^ { \prime } ) \sum _ { i = 1 } ^ { k _ { 0 } } ( \delta _ { y } ) _ { i } g _ { i } ( y ^ { \prime } ) + r ( y ^ { \prime } ) ,
+$$
+
+where $\langle r , p _ { Y } \delta _ { i } \rangle _ { Y } = 0$ for all $i$ . Taking the inner product with $p _ { Y } g _ { j }$ , we obtain
+
+$$
+\langle p _ { Y } g _ { j } , \delta _ { y } \rangle _ { Y } = \sum _ { i = 1 } ^ { k _ { 0 } } ( \delta _ { y } ) _ { i } L _ { j i } ,
+$$
+
+where the left hand side is also just
+
+$$
+\langle p _ { Y } g _ { j } , \delta _ { y } \rangle _ { Y } = g _ { j } ( y ) .
+$$
+
+Therefore the components of $\delta _ { y }$ are explicitly
+
+$$
+( \delta _ { y } ) _ { i } = \sum _ { j } ( L ^ { - 1 } ) _ { i j } g _ { j } ( y ) .
+$$
+
+It follows that
+
+$$
+\begin{array} { l } { { \displaystyle p _ { X | Y } ( x | y ) = \mathcal { N } ^ { * } ( \delta _ { y } ) ( x ) \approx \mathcal { N } _ { 0 } ^ { * } ( \delta _ { y } ) ( x ) } } \\ { { \displaystyle ~ = \sum _ { i j k } N _ { k i } ^ { * } ( L ^ { - 1 } ) _ { i j } g _ { j } ( y ) f _ { k } ( x ) . } } \end{array}
+$$
+
+Then, for instance, the expected inferred value of $X$ is
+
+$$
+\overline { { { x } } } = \sum _ { i j k } N _ { k i } ^ { * } ( L ^ { - 1 } ) _ { i j } g _ { j } ( y ) \sum _ { x } p _ { X } ( x ) x f _ { k } ( x ) .
+$$
+
+For the inference of $Y$ from $x$ , we have
+
+$$
+p _ { Y | X } ( y | x ) \approx \sum _ { i j k } N _ { k i } ( K ^ { - 1 } ) _ { i j } f _ { j } ( x ) g _ { k } ( y ) .
+$$
+
+# C ANALYTICAL EXAMPLE
+
+When $p ( x , y )$ is any multivariate Gaussian distribution, everything can be computed analytically. Let us consider here the one-dimensional case. We use $p ( x ) \ \propto \ \exp { \left( - x ^ { 2 } / 2 \tau ^ { 2 } \right) }$ , and the conditional $\underline { { { p } } } ( y | x ) ~ \propto ~ \exp \left( - ( y - x ) ^ { 2 } / 2 \sigma ^ { 2 } \right)$ . That is, $y$ is equal to $x$ but with some added Gaussian noise. This gives
+
+$$
+p _ { X | Y } ( x | y ) \propto \exp \left( - \frac { ( x - \gamma y ) ^ { 2 } } { 2 \tau ^ { 2 } ( 1 - \gamma ) } \right) , \quad \mathrm { w h e r e } \quad \gamma = \frac { \tau ^ { 2 } } { \sigma ^ { 2 } + \tau ^ { 2 } } .
+$$
+
+It was show in Lancaster (1958), that the most relevant subspace of dimension $k _ { 0 }$ on the variable $X$ is simply spanned by the variables
+
+$$
+f _ { n } ( x ) = x ^ { n } ,
+$$
+
+$n = 0 , \ldots , k _ { 0 } - 1$ . Similarly for $Y$ ;
+
+$$
+g _ { n } ( y ) = y ^ { n } .
+$$
+
+This independence of the relevant variables on the detailed parameters of $p$ is a general property of Gaussian joint distributions.
+
+This means, for instance, that the most relevant feature $( n = 1$ ) for predicting the value of $X$ given $Y = y$ is simply $Y$ itself. The higher order variables have to do with inferring extra aspects of the probability distribution over $X$ .
+
+A set of orthogonal variables can be obtain from the Gram-Schmidt procedure, which, if done from small to large $n$ much necessarily yield the eigenvectors $u _ { n }$ and $v _ { n }$ . For illustration purpose, let us work with the non-orthogonal vectors $f _ { n }$ and $g _ { n }$ , keeping only the first $k _ { 0 } = 3$ vectors.
+
+The three matrices (correlators) we need can be easily computed:
+
+$$
+\begin{array} { l c c } { { K = \left( \begin{array} { c c c } { { 1 } } & { { 0 } } & { { \tau ^ { 2 } } } \\ { { 0 } } & { { \tau ^ { 2 } } } & { { 0 } } \\ { { \tau ^ { 2 } } } & { { 0 } } & { { 3 \tau ^ { 4 } } } \end{array} \right) } } & { { L = \left( \begin{array} { c c c } { { 1 } } & { { 0 } } & { { \tau ^ { 2 } + \sigma ^ { 2 } } } \\ { { 0 } } & { { \tau ^ { 2 } + \sigma ^ { 2 } } } & { { 0 } } \\ { { \tau ^ { 2 } + \sigma ^ { 2 } } } & { { 0 } } & { { 3 ( \tau ^ { 2 } + \sigma ^ { 2 } ) ^ { 2 } } } \end{array} \right) } } \\ { { A = \left( \begin{array} { c c c } { { 1 } } & { { 0 } } & { { \tau ^ { 2 } } } \\ { { 0 } } & { { \tau ^ { 2 } } } & { { 0 } } \\ { { \tau ^ { 2 } + \sigma ^ { 2 } } } & { { 0 } } & { { \tau ^ { 2 } ( \sigma ^ { 2 } + 3 \tau ^ { 2 } ) } } \end{array} \right) . } } \end{array}
+$$
+
+We obtain
+
+$$
+M = K ^ { - 1 } A ^ { \top } L ^ { - 1 } A = \left( \begin{array} { c c c } { { 1 } } & { { 0 } } & { { \tau ^ { 2 } ( 1 - \gamma ^ { 2 } ) } } \\ { { 0 } } & { { \gamma } } & { { 0 } } \\ { { 0 } } & { { 0 } } & { { \gamma ^ { 2 } } } \end{array} \right) .
+$$
+
+The eigenvalues of $M$ can be read on the diagonal, and the corresponding eigenvectors are $( 1 , 0 , 0 )$ , $( 0 , 1 , \bar { 0 } )$ and $( - \tau ^ { 2 } , 0 , 1 )$ , which means that the eigenfunctions are in order $\bar { u } _ { 0 } ( x ) = 1$ , $u _ { 1 } ( x ) = x$ and u2(x) = x2 − τ 2.
+
+Because we are working with continuous variables, the true rank of $\mathcal { N }$ is infinite, even for any finite cutoff on the singular values. Nevertheless, it is instructive to see how the approximate inference fares for rank $k _ { 0 } = 3$ . Given the value $y$ for $Y$ , the inferred distribution over $X$ is
+
+$$
+\mathcal { N } _ { 0 } ^ { * } ( \delta _ { y } ) ( x ) = p _ { X } ( x ) p _ { Y } ( y ) \sum _ { j , k = 0 } ^ { 2 } ( K ^ { - 1 } A ^ { \top } L ^ { - 1 } ) _ { k j } y ^ { j } x ^ { k } .
+$$
+
+The approximately inferred first and second moments of $X$ is given by integrating the above times $x$ (resp. $x ^ { 2 }$ ) over $x$ . We obtain
+
+$$
+{ \overline { { x } } } = \gamma y \quad { \mathrm { a n d } } \quad { \overline { { x ^ { 2 } } } } = \gamma ^ { 2 } y ^ { 2 } + ( 1 - \gamma ) \tau ^ { 2 } ,
+$$
+
+which are actually exact: they are equal to the first two moments of $X$ over $p _ { X | Y }$ as given in Eq. (46).
+
+In fact, it is easy to see that this would be true for the first $k _ { 0 } - 1$ moments had we kept the $k _ { 0 }$ most relevant variables.

parse/train/SJx9ngStPH/SJx9ngStPH.md

@@ -0,0 +1,436 @@
+# NAS-BENCH-1SHOT1: BENCHMARKING AND DISSECTING ONE-SHOT NEURAL ARCHITECTURE SEARCH
+
+Arber $\mathbf { Z e l a ^ { 1 * } }$ , Julien Siems1∗, & Frank Hutter1,2 1Department of Computer Science, University of Freiburg 2Bosch Center for Artificial Intelligence {zelaa, siemsj, fh}@cs.uni-freiburg.de
+
+# ABSTRACT
+
+One-shot neural architecture search (NAS) has played a crucial role in making NAS methods computationally feasible in practice. Nevertheless, there is still a lack of understanding on how these weight-sharing algorithms exactly work due to the many factors controlling the dynamics of the process. In order to allow a scientific study of these components, we introduce a general framework for one-shot NAS that can be instantiated to many recently-introduced variants and introduce a general benchmarking framework that draws on the recent large-scale tabular benchmark NAS-Bench-101 for cheap anytime evaluations of one-shot NAS methods. To showcase the framework, we compare several state-of-the-art one-shot NAS methods, examine how sensitive they are to their hyperparameters and how they can be improved by tuning their hyperparameters, and compare their performance to that of blackbox optimizers for NAS-Bench-101.
+
+# 1 INTRODUCTION
+
+While neural architecture search (NAS) has attracted a lot of attention due to the effectiveness in automatically designing state-of-the-art neural networks (Zoph & Le, 2017; Zoph et al., 2018; Real et al., 2017; 2019), the focus has recently shifted to making the search process more efficient (Pham et al., 2018; Elsken et al., 2019; Liu et al., 2019; Xie et al., 2019; Cai et al., 2019; Casale et al., 2019). The most crucial concept which led to a reduction in search costs to the order of a single function evaluation is certainly the weight-sharing paradigm: Training only a single large architecture (the one-shot model) subsuming all the possible architectures in the search space (Brock et al., 2018; Pham et al., 2018).
+
+Despite the great advancements of these methods, the exact results of many NAS papers are often hard to reproduce (Li & Talwalkar, 2019; Yu et al., 2020; Yang et al., 2020). This is a result of several factors, such as unavailable original implementations, differences in the employed search spaces, training or evaluation pipelines, hyperparameter settings, and even pseudorandom number seeds (Lindauer & Hutter, 2019). One solution to guard against these problems would be a common library of NAS methods that provides primitives to construct different algorithm variants, similar to what as RLlib (Liang et al., 2017) offers for the field of reinforcement learning. Our paper makes a first step into this direction.
+
+Furthermore, experiments in NAS can be computationally extremely costly, making it virtually impossible to perform proper scientific evaluations with many repeated runs to draw statistically robust conclusions. To address this issue, Ying et al. (2019) introduced NAS-Bench-101, a large tabular benchmark with $4 2 3 \mathrm { k }$ unique cell architectures, trained and fully evaluated using a one-time extreme amount of compute power (several months on thousands of TPUs), which now allows to cheaply simulate an arbitrary number of runs of NAS methods, even on a laptop. NAS-Bench-101 enabled a comprehensive benchmarking of many discrete NAS optimizers (Zoph & Le, 2017; Real et al., 2019), using the exact same settings. However, the discrete nature of this benchmark does not allow to directly benchmark one-shot NAS optimizers (Pham et al., 2018; Liu et al., 2019; Xie et al., 2019; Cai et al., 2019). In this paper, we introduce the first method for making this possible.
+
+Specifically, after providing some background (Section 2), we make the following contributions:
+
+1. We introduce NAS-Bench-1Shot1, a novel benchmarking framework that allows us to reuse the extreme amount of compute time that went into generating NAS-Bench-101 (Ying et al., 2019) to cheaply benchmark one-shot NAS methods. Our mapping between search space representations is novel to the best of our knowledge and it allows querying the performance of found architectures from one-shot NAS methods, contrary to what is claimed by Ying et al. (2019). Specifically, it allows us to follow the full trajectory of architectures found by arbitrary one-shot NAS methods at each search epoch without the need for retraining them individually, allowing for a careful and statistically sound analysis (Section 3).   
+2. We introduce a general framework for one-shot NAS methods that can be instantiated to many recent one-shot NAS variants, enabling fair head-to-head evaluations based on a single code base (Section 4).   
+3. We use the above to compare several state-of-the-art one-shot NAS methods, assess the correlation between their one-shot model performance and final test performance, examine how sensitive they are to their hyperparameters, and compare their performance to that of black-box optimizers used in NAS-Bench-101 (Section 5).
+
+We provide our open-source implementation1, which we expect will also facilitate the reproducibility and benchmarking of other one-shot NAS methods in the future.
+
+# 2 BACKGROUND AND RELATED WORK
+
+# 2.1 NAS-BENCH-101
+
+NAS-Bench-101 (Ying et al., 2019) is a database of an exhaustive evaluation of all architectures in a constrained cell-structured space on CIFAR-10 (Krizhevsky, 2009). Each cell is represented as a directed acyclic graph (DAG) where the nodes represent operation choices and the edges represent the information flow through the neural network (see also Figure 1 and Section 3.1). To limit the number of architectures in the search space, the authors used the following constraints on the cell: 3 operations in the operation set $\mathcal { O } = \{ 3 \mathrm { x } 3 $ convolution, 1x1 convolution, $3 { \mathrm { x } } 3 { \mathrm { ~ m a x } } { \mathrm { - p o o l } } \}$ , at most 7 nodes (this includes input and output node, therefore 5 choice nodes) and at most 9 edges.
+
+These constraints, and exploiting symmetries, reduced the search space to $4 2 3 \mathrm { k }$ unique valid architectures. Each architecture was trained from scratch three times to also obtain a measure of variance. In addition, each architecture was trained for 4, 12, 36 and 108 epochs; for our analysis, we mainly used the results for models trained for 108 epochs, if not stated otherwise.
+
+# 2.2 NAS-BENCH-102
+
+Concurrently to this work, Dong & Yang (2020) released NAS-Bench-102, which is another NAS benchmark that, differently from NAS-Bench-101, enables the evaluation of weight-sharing NAS methods. Their search space consists of a total of 15,625 architectures, which is exhaustively evaluated on 3 image classification datasets. Similarly to Zela et al. (2020) and this work, Dong & Yang (2020) found that architectural overfitting occurs for DARTS for all their datasets.
+
+While NAS-Bench-102 and this work go towards the same direction, they differ in many ways:
+
+1. They use extensive computation to create a new benchmark (with 15.625 architectures), while we devise a novel reformulation to reuse the even much more extensive computation of the NASBench-101 dataset ( 120 TPU years) to create three new one-shot search spaces with the larges one containing 363.648 architectures. This required zero additional computational cost.   
+2. We show that it is possible to reuse the graph representation in NAS-Bench-101 to run one-shot NAS methods; this requires changes to the one-shot search space, but allows a mapping which can be used for architecture evaluation.
+
+![](images/282ee12d642c910c0d623c37f9afca75b123967986e2ff858c8e7937724695a4.jpg)  
+Figure 1: Overview of the NAS-Bench-1Shot1 analysis strategy. The one-shot model we construct only contains discrete architectures that are elements of NAS-Bench-101 (Ying et al., 2019). The cell architecture chosen is similar to that of Bender et al. (2018), with each choice block containing an operation decision. Note that NAS-Bench-101 does not contain a separate reduction cell type. Plot on the right from Ying et al. (2019) (Best viewed in color).
+
+3. They evaluate their search space on 3 image classification datasets, while we introduce 3 different search spaces (as sub-spaces of NAS-Bench-101) with growing complexity.
+
+# 2.3 ONE-SHOT NEURAL ARCHITECTURE SEARCH
+
+The NAS problem can be defined as searching for the optimal operation (e.g. in terms of validation error of architectures) out of the operation set $\mathcal { O }$ in each node of the DAG and for the best connectivity pattern between these nodes.
+
+Designing architectures for optimized accuracy or to comply with resource constraints led to significant breakthroughs on many standard benchmarks (Pham et al., 2018; Zoph & Le, 2017; Brock et al., 2018; Liu et al., 2019; Cai et al., 2019; Elsken et al., 2019). While early methods were computationally extremely expensive (Zoph & Le, 2017), the weight-sharing paradigm (Brock et al., 2018; Pham et al., 2018) led to a significant increase in search efficiency. Here, the weights of the operations in each architecture are shared in a supermodel (the so-called one-shot model or convolutional neural fabric (Saxena & Verbeek, 2016)), which contains an exponential number of sub-networks, each of which represents a discrete architecture. Architectures whose sub-networks share components (nodes/edges) also share the weights for these components’ operations; therefore, in analogy to DropOut (Srivastava et al., 2014), training one architecture implicitly also trains (parts of) an exponential number of related architectures. There are a variety of methods on how to conduct NAS by means of the one-shot model (Brock et al., 2018; Pham et al., 2018; Bender et al., 2018; Liu et al., 2019; Li & Talwalkar, 2019) (see also Appendix B), but the final problem is to find the optimal sub-network in this one-shot model.
+
+The weight sharing method was used to great effect in DARTS (Liu et al., 2019), where it allows a gradient based optimization of both the architectural and the one-shot weights. Subsequent work on DARTS has addressed further lowering the computational and the memory requirements (Dong & Yang, 2019; Xu et al., 2020; Cai et al., 2019; Casale et al., 2019).
+
+One fundamental drawback of the weight sharing method is the fact that the architecture search typically takes place in a lower fidelity model (e.g., using less cells and/or cheaper operations): the so-called proxy model. After the search, a discrete architecture is derived from the proxy model which is then trained with more parameters — a stage often referred to as architecture evaluation. This poses the question whether the architecture found in the proxy model is also a good architecture in the bigger model, a question studied by several recent works (Bender et al., 2018; Yu et al., 2020).
+
+# 3 A GENERAL FRAMEWORK FOR BENCHMARKING ONE-SHOT NAS
+
+We will now introduce our framework for cheaply benchmarking the anytime performance of oneshot NAS methods. Our main analysis strategy is the following: First, we run the search procedure of various methods and save the architecture weights of the one-shot models for each epoch. Second, we find the discrete architecture at each epoch and query it in NAS-Bench-101. The last step is not trivial due to the different representations of the search space used in NAS-Bench-101 and standard one-shot methods. Ying et al. (2019) state that one-shot methods cannot be directly evaluated on NAS-Bench-101. In the following sections we present a mapping between these different search space representations, which eventually enable us to evaluate one-shot methods on NAS-Bench101. To the best of our knowledge this is a novel contribution of this paper.
+
+# 3.1 SEARCH SPACE REPRESENTATION
+
+In order to carry out the analysis we propose in this work, we had to construct a search space that only contains discrete architectures that are also contained in NAS-Bench-101. This allows us to look up any discrete architectures’ performance in NAS-Bench-101 when the larger model is trained from scratch. Unfortunately, this is non-trivial since the NAS-Bench-101 space does not match the typical space used in one-shot NAS methods. We separately consider the various parts of the search space.
+
+Network-Level Topology. In terms of network-level topology, our search spaces closely resemble the models which were evaluated in NAS-Bench-101. We used the same macro architecture as in NAS-Bench-101, i.e., 3 stacked blocks with a max-pooling operation in-between, where each block consists of 3 stacked cells (see Figure 1). While our final evaluation models exactly follow NAS-Bench-101 in order to be able to reuse its evaluations, our one-shot model only has 16 initial convolution filters, rather than the 128 used in NAS-Bench-101. This is a common practice to accelerate NAS and used similarly in, e.g., Liu et al. (2019).
+
+Cell-Level Topology. The cell-level structure is represented as a DAG, where the input node is the output of a previous cell or the convolutional stem, and the output node is a concatenation of all the previous nodes. In order to have the operation choices still in the intermediate nodes of the DAG, we adapt the choice block motif from Bender et al. (2018) as depicted in Figure 1. The edges connecting input, output nodes and choice blocks represent only the information flow in the graph. To have a large and expressive enough search space(s), we introduce the following architectural weights in the DAG edges:
+
+• $\alpha ^ { i , j }$ to edges connecting nodes $\textit { i } < \textit { j }$ to choice block $j$ . The input of choice block $j$ is then   
+computed as $\begin{array} { r } { I ^ { j } = \sum _ { i < j } \frac { \exp ( \alpha ^ { i , j } ) } { \sum _ { i ^ { \prime } < j } \exp ( \alpha ^ { i ^ { \prime } , j } ) } x ^ { i } } \end{array}$ , where $x ^ { i }$ is the output tensor of node $i$ (either input node or choice block).   
+• $\gamma ^ { j , k }$ to the edges connecting the input node or choice blocks $j < k$ to the output node $k$ of the cell,   
+where the corresponding feature maps are concatenated: Ok = ⊕j<k exp(γj,kP )j0<k exp(γj0,k) x , where $\oplus$ is the concatenation operator.
+
+Note that the non-linearity applied to the edge weights varies depending on the NAS optimizer used; e.g. for GDAS (Dong & Yang, 2019) and SNAS (Xie et al., 2019) it would be a GumbelSoftmax (Eric Jang & Poole, 2017) instead.
+
+Choice Blocks. As in Bender et al. (2018), each choice block inside the cell can select between the operations in the operations set $\mathcal { O }$ of NAS-Bench-101. In order to find the optimal operation in each choice block via gradient-based one-shot NAS methods, we assign an architectural weight $\beta ^ { o }$ to each operation $o \in \mathcal { O }$ inside the choice block. The output of the choice block $j$ is computed by adding element-wise the latent representations coming from the operations outputs:
+
+$$
+x ^ { j } = \sum _ { o \in \mathcal { O } } \frac { \exp ( \beta ^ { o } ) } { \sum _ { o ^ { \prime } \in \mathcal { O } } \exp ( \beta ^ { o ^ { \prime } } ) } o ( I ^ { j } ) ,
+$$
+
+which is basically the so-called MixedOp in DARTS. NASBench cells contain 1x1 projections in front every operation (demonstrated in Figure 1 in (Ying et al., 2019)). The number of output channels of each projection is chosen such that the output has the same number of channels as the
+
+input. This adaptive choice for the number of channels is incompatible with the one-shot model due to the different tensor dimensionality coming from previous choice blocks. We used 1x1 projections with a fixed number of channels instead.
+
+# 3.2 EVALUATION PROCEDURE
+
+By means of these additional weights we do not restrict the possible architectures in the search space to contain only a fixed number of edges per cell, as done for example in Zoph et al. (2018), Pham et al. (2018), Liu et al. (2019), etc. This requirement would have restricted our architectural decisions heavily, leading to only small search spaces.
+
+Table 1 shows the characteristics of each search space. We propose three different search spaces by making different decisions on the number of parents each choice block has. The decisions affect the quality and quantity of the architectures contained in each search space. For all search spaces note that the sum of the number of parents of all nodes in the search space is chosen to be 9, to match the NAS-Bench-101 requirement. Search space 1, 2 and 3 have 6240, 29160 and 363648 architectures with loose ends respectively, making search space 3 the largest investigated search space. To the best of our knowledge search space 3 is currently the largest and only available tabular benchmark for one-shot NAS. For details on each search space see Appendix A.
+
+Table 1: Characteristic information of the search spaces.   
+
+<table><tr><td></td><td></td><td colspan="3">Search space</td></tr><tr><td rowspan="6">No. parents</td><td></td><td>1</td><td>2</td><td>3</td></tr><tr><td>Node 1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>Node 2</td><td>2</td><td>1</td><td>1</td></tr><tr><td>Node 3</td><td>2</td><td>2</td><td>1</td></tr><tr><td>Node 4</td><td>2</td><td>2</td><td>2</td></tr><tr><td>Node 5 Output</td><td>-</td><td>- 3</td><td>2 2</td></tr><tr><td rowspan="2">No.archs.</td><td>w/ loose ends</td><td>2</td><td></td><td></td></tr><tr><td>w/o loose ends</td><td>6240 2487</td><td>29160 3609</td><td>363648 24066</td></tr></table>
+
+Given the architectural weights of the cell shown in Figure 1 we query the test and validation error of the discrete architecture from NAS-Bench-101 as follows.
+
+1. We determine the operation chosen in each choice block by choosing the operation with the highest architectural weight.   
+2. We determine the parents of each choice block and the output by choosing the top- $k$ edges according to Table 1 (e.g. for choice block 4 in search space 3 we would choose the top-2 edges as parents).   
+3. From 1. we construct the operation list and from 2. the adjacency matrix of the cell which we use to query NAS-Bench-101 for the test and validation error.
+
+Each node in the graph chooses its parents during evaluation following e.g. DARTS (Liu et al., 2019). However, because edges model information flow and the output edges are also architectural decisions there is possibility of a node being a loose end. These are nodes whose output does not contribute to the output of the discrete cell, as seen in the upper cell under evaluation of Figure 1. As a result, we can count the number of architectures with or without loose ends. Note, that had we chosen the children of each node we could have invalid architectures where a node has an output but no input.
+
+# 4 A GENERAL FRAMEWORK FOR ONE-SHOT NAS METHODS
+
+Most of the follow-up works of DARTS (Algorithm 1), which focus on making the search even more efficient and effective, started from the original DARTS codebase2, and each of them only change very few components compared to DARTS.
+
+# Algorithm 1 DARTS
+
+# Algorithm 2 PC-DARTS
+
+# Algorithm 3 GDAS
+
+1: $\begin{array} { r } { I ^ { j } = \sum _ { i < j } S ( \alpha ^ { i , j } ) x ^ { i } } \end{array}$   
+2: Ok = ⊕j<kS(γj,k)xj   
+3: xj = Po∈O S(βo)o(Ij )   
+4: m ← DAG(Ij , Ok , xj )   
+5: while not converged do   
+6: 7: 8: m.update(Λ, ∇ΛLvalid) m.update(w, ∇wLtrain) end while Return Λ
+
+1: Ij = Pi<j S(αi,j )xi   
+2: Ok = ⊕j<kS(γj,k)xj   
+3: xj = Po∈O S(βo)o(Mo∗Ij )+(1 − Mo ∗ Ij )   
+4: m ← DAG(Ij , Ok , xj )   
+5: while not converged do   
+6: m.update(Λ, ∇ΛLvalid)   
+7: 8: m.update(w, ∇wLtrain)   
+end while   
+9: Return Λ   
+1: Ij = Pi<j GS(αi,j )xi   
+2: Ok = ⊕j<kGS(γj,k)xj   
+3: xj = Po∈OGS(βo)o(Ij )   
+4: m ← DAG(Ij , Ok , xj )   
+5: while not converged do   
+6: m.update(Λ, ∇ΛLvalid)   
+7: m.update single path(w, ∇wLtrain)   
+8: 9: end while   
+Return Λ
+
+# Algorithm 4 Random NAS with Weight-sharing
+
+# Algorithm 5 ENAS
+
+1: Ij = Pi<j x i   
+2: = ⊕ j<k xj   
+3: o ( I j )   
+4: m ← DAG(Ij , Ok , xj )   
+5: while not converged do   
+6: arch ← sample using controller(m)   
+7: m.update weights of single architecture(arch, w, ∇wLtrain)   
+8: Update RNN controller   
+9: end while   
+10: for i ∈ 1..100 do   
+11: arch samples ← sample using controller(m)   
+12: end for   
+13: Return arch ∈ arch samples with lowest validation error
+
+1: Ij = Pi<j x i 2: k = ⊕j<k xj   
+3: x j = P o ( I j )   
+4: m ← DAG(Ij , Ok , xj )   
+6: 7: 8:9: 5: while not converged do arch sample uniformly at random(m) m.update weights of single architecture(arch, w, ∇wLtrain) end while for i ∈ 1..1000 do   
+11: arch samples sample uniformly at random(m)   
+12: end for   
+13: Return arch $\in$ arch samples with lowest validation error
+
+Algorithm 2 and Algorithm 3 highlight these components (relative to DARTS) for PC-DARTS (Xu et al., 2020) and GDAS (Dong & Yang, 2019), respectively. For example, when comparing PCDARTS and DARTS, the only difference in our benchmark is the partial channel connections (line 3 of Algorithm 2) in the choice blocks, which consists of a channel sampling mask $M ^ { o }$ that drops feature maps coming from $I ^ { j }$ . GDAS, on the other hand, replaces the Softmax (S) function in DARTS by a Gumbel-Softmax $( G S )$ , which applies for every architectural weight in $\Lambda = \{ \alpha , \beta , \gamma \}$ (lines 1-3 in Algorithm 3), and uses this concrete distribution to sample single paths through the cell during search (line 7 in Algorithm 3). Random Search with Weight Sharing (Random WS) (Li & Talwalkar, 2019) (Algorithm 4) and ENAS (Pham et al., 2018) (Algorithm 5) do not need the continuous relaxation in order to conduct the architecture search, instead they sample randomly in RandomWS or from the recurrent neural network controller (line 6 in Algorithm 1) in ENAS, in order to select the sub-network in the one-shot model to train.
+
+These close correspondences between current one-shot NAS variants provide an opportunity to implement all of these variants in the same general code basis. This allows us to (a) automatically guard against any confounding factors when evaluating the strengths and weaknesses of different approaches, and (b) allows us to mix and match the components of different algorithms. We implemented all variants in a single code basis, which we are committed to grow into a flexible library of primitives for one-shot NAS methods, and for which we will gladly accept any help the community wants to provide.
+
+One-shot NAS methods in this code basis inherit all the methods and attributes necessary for building the one-shot computational graph from a base parent class. This encapsulation and modularity ensures that all differences in their performance come from a few lines of code, and that all other confounding factors cannot affect these results. This will also facilitate the incorporation of other one-shot NAS methods and pinpoint the components that differ in them.
+
+Furthermore, the primitives encoding the search spaces presented in Section 3 are defined separately from the NAS optimizers. This encapsulation will allow researchers to study each of these components in isolation, experimenting with one of them while being sure that the other one does not change.
+
+# 5 NAS-BENCH-1SHOT1 AS A BENCHMARK AND ANALYSIS FRAMEWORK
+
+We now demonstrate the use of NAS-Bench-1Shot1 as a benchmark for one-shot NAS. We first evaluate the anytime performance of five different one-shot NAS methods: DARTS (Liu et al., 2019), GDAS (Dong & Yang, 2019), PC-DARTS (Xu et al., 2020), ENAS (Pham et al., 2018) and Random Search with Weight Sharing (Random WS) (Li & Talwalkar, 2019).3 Afterwards, we investigate the robustness of these one-shot NAS optimizers towards their search hyperparameters and show that if these hyperparameters are carefully tuned, the one-shot NAS optimizer can outperform a wide range of other discrete NAS optimizers in our search spaces.
+
+# 5.1 COMPARISON OF DIFFERENT ONE-SHOT NAS OPTIMIZERS
+
+We ran the NAS search for 50 epochs4 using their respective default hyperparameter settings (see Appendix C). If not stated otherwise, all the following results were generated by running each experiment with six random seeds (0 to 5). All plots show the mean and standard deviation of the test regret queried from NAS-Bench-101. Over the three independent trainings contained in NASBench101 for each architecture on each epoch budget we average. The search was done on a single NVIDIA RTX2080Ti using the same python environment. In Figure 2 we report the anytime test regret for each of these methods. Our findings can be summarized as follows:
+
+• While the one-shot validation error converged in all cases (except for GDAS due to the temperature annealing) the queried test error from NAS-Bench-101 of the architectures increased at some point, indicating that the architectural parameters overfit the validation set. This phenomenon occurred frequently for DARTS. The same result was also previously observed by Zela et al. (2020) on subspaces of the standard DARTS space.
+
+• PC-DARTS demonstrated both a stable search and relatively good final performance in all search spaces, notably the best overall performance for search space 3. We attribute this behaviour to the regularization effect present in PC-DARTS via the partial channel connections (see Zela et al. (2020) and Section 5.3).
+
+• Random WS and ENAS mainly explore poor architectures across all three search spaces. This behaviour is a result of the small correlation between the architectures evaluated with the one-shot weights and their true performance during architecture evaluation (as queried from NAS-Bench101 (see Section 5.2)). This correlation directly affects these methods since in the end of search they sample a certain number of architectures (1000 randomly sampled for Random WS and 100 using the learned controller policy for ENAS) and evaluate them using the one-shot model weights in order to select the architecture which is going to be trained from scratch in the final evaluation phase. When running ENAS for 100 epochs in search space 2 (Figure 7 in the appendix) we see that the it performs better than Random WS. ENAS also has a stronger correlation between the sampled architectures and the NAS-Bench-101 architectures for search space 2 (see Section 5.2).
+
+• GDAS performs quite robustly across all 3 benchmarks, however, due to the temperature annealing of the Gumbel Softmax, it might manifest some premature convergence to a sub-optimal local minimum.
+
+# 5.2 CORRELATION ANALYSIS
+
+Many one-shot NAS methods, such as ENAS (Pham et al., 2018), NAONet (Luo et al., 2018) or Random WS (Li & Talwalkar, 2019) select the final architecture by means of the one-shot parameters. In order to assess if this is optimal we computed the correlation between a given architecture’s one-shot test error and its respective NAS-Bench-101 test error, for all 4 available budgets in NASBench-101 on every 10th search epoch. This analysis was performed for all architectures without loose ends in each search space. The only exception is ENAS, for which we decided to evaluate the correlation by sampling 100 architectures (as done by the algorithm after the search has finished to select the one to retrain from scratch) from the controller instead of evaluating every architecture in the search space.
+
+![](images/187f620f20c862a6e167a6a57746ab87c879dfbd0fab69f166fea9f7f0527db4.jpg)  
+Figure 2: Comparison of different one-shot NAS optimizers on the three different search spaces defined on NASBench. The solid lines show the anytime test regret (mean $\pm$ std), while the dashed blurred lines the one-shot validation error (Best viewed in color).
+
+![](images/d93ee4dc46df9c108774edb39099f8dd3f3e24d71798721df90711beb34fdf75.jpg)  
+Figure 3: Correlation between the one-shot validation error and the corresponding NAS-Bench-101 test error for each search space. (Best viewed in color).
+
+As shown in Figure 3, there is almost no correlation between the weight sharing ranking and the true one (Spearman correlation coeff. between -0.25 and 0.3) during search for DARTS, PC-DARTS, GDAS and Random WS. Only ENAS shows some correlation for search space 2 and some anticorrelation for search spaces 1 and 3. These results agree with the ones reported by Yu et al. (2020) (who could only do this evaluationx on a small search space) and explain the poor performance of Random WS and ENAS on our benchmarks, since the architectures sampled during evaluation and ranked according to their one-shot validation error are unlikely to perform well when evaluated independently. To the best of our knowledge this is the first time that an evaluation of this correlation is conducted utilizing such a large number of architectures in the search space, namely 24066 different architectures for search space 3. We added further experiments on the correlation between the lower fidelity proxy model used in architecture search and the final model from architecture evaluation in the Appendix H.
+
+# 5.3 ROBUSTNESS OF ONE-SHOT NAS OPTIMIZERS
+
+As already observed by Zela et al. (2020), DARTS tends to become more robust when the inner objective $\mathcal { L } _ { t r a i n }$ in the bi-level optimization procedure has a relatively strong regularization factor during search. In order to investigate the long term behaviour, for this analysis we chose to run every search for 100 epochs instead of 50 epochs. Similarly to Zela et al. (2020), we find that enabling Cutout (DeVries & Taylor, 2017) or increasing the $L _ { 2 }$ factor for the search model weights, has a substantial effect on the quality of the solutions found by the NAS optimizers. See Figure 4 for the Cutout (CO) results and Figure 11 (in the appendix) for the results with different $L _ { 2 }$ regularization. Based on these results we observe that:
+
+![](images/57b04aa70225b163e317d2600c3537b14cf5e9d4f1b2c96713c74c08aad10c9a.jpg)  
+Figure 4: Illustration of the impact that Cutout has on the test regret on NAS-Bench-101 and the validation error of the one-shot model using DARTS, GDAS and PC-DARTS on search space 3 (Best viewed in color).
+
+• As DARTS overfits to the validation set at the end of search for search space 1 and 3, applying Cutout during search either keeps the solutions to a good local minimum or reduces the overfitting effect, a finding similar as the one in Zela et al. (2020).   
+• Interestingly, while Zela et al. (2020) only showed overfitting behavior for DARTS, it may also occur for GDAS (Figure 13 in the appendix) and PC-DARTS (Figure 14 in the appendix), which indicates that this might be an intrinsic property of these methods due to the local updates in the architecture space.   
+• In PC-DARTS, there is already a strong regularization effect as a result of the partial channel connectivity, which explains the robust behavior of this optimizer and that its results deteriorate on average as we increase $L _ { 2 }$ regularization.
+
+# 5.4 TUNABILITY OF ONE-SHOT NAS HYPERPARAMETERS
+
+Next to the hyperparameters used in the evaluation pipeline, one-shot NAS methods have several hyperparameters of their own, such as the regularization hyperparameters studied in Section 5.3, learning rates, and other hyperparameters of the search phase.
+
+Naively tuning these hyperparameters with the one-shot validation error as the objective would lead to sub-optimal configurations, since, as we saw, this metric is not a good indicator of generalization. In our proposed benchmarks, we can tune these hyperparameters of the NAS optimizer to minimize the validation error queried from NAS-Bench-101. By doing so, we aim to shed more light onto the influence these hyperparameters have during the one-shot search, and to study the sensitivity of the NAS method towards these hyperparameters.
+
+To this end, we constructed 3 configuration spaces of increasing cardinality, CS1,
+
+![](images/88b0b2e4099127118d81a056b6be2e05beeb803856f438ceec5bd2e6d2738124.jpg)  
+Figure 5: Optimizing the hyperparameters of one-shot optimizers with BOHB on search space 3. (best viewed in color). Results for search space 1 and 2 are shown in Figure 16.
+
+CS2 and CS3 (see Appendix F for details), which only include hyperparameters controlling the NAS process. We chose BOHB (Falkner et al. (2018), see Appendix F for details) as the hyperparameter optimization method and DARTS as our NAS method to be tuned across all configuration spaces, since in our benchmarks it was more brittle than PC-DARTS and GDAS. We provide the results in Appendix F.2.
+
+In order to compare the tunability of NAS methods, we used BOHB to optimize all of DARTS, PCDARTS, and GDAS, starting from their respective default hyperparameter settings. Figure 5 shows the anytime test regret of the architectures found by the respective NAS method’s configurations tried by BOHB; as the figure shows, PC-DARTS and GDAS start with much more robust hyperparameter settings, but DARTS can also be tuned to perform as well or better. We note that carrying out this optimization on NAS-Bench-1Shot1 reduced the time for tuning DARTS from a simulated 45 GPU days to 1 day on 16 GPUs.
+
+Figure 5 also provides an evaluation of DARTS, GDAS and PC-DARTS compared to the state-of-art discrete NAS optimizers used by Ying et al. (2019) (such as RL, RE, and HPO methods). Since these one-shot NAS methods are much faster than black-box methods, it is possible to tune them online using BOHB and the resulting BOHB-{DARTS, GDAS, PC-DARTS} typically still yields better performance over time. Note that we never use the validation set split used to evaluate the individual architectures in NAS-Bench-101 during the architecture search. This subset with $1 0 \mathrm { k }$ examples is only used to compute the objective function value that BOHB optimizes. Therefore, the one-shot optimizers use $2 0 \mathrm { k }$ examples for training and $2 0 \mathrm { k }$ for the architectural parameter updates. The x-axis in Figures 5 shows the simulated wall-clock time: $t _ { s i m } = t _ { s e a r c h } + t _ { t r a i n }$ , where tsearch is the time spent during search by each configuration and $t _ { t r a i n }$ is the training time for 108 epochs (queried from NAS-Bench-101) of the architectures selected by the one-shot optimizer. From this experiment, we make the following observations:
+
+• On all search spaces the architectures BOHB-DARTS found outperformed the architectures found by the default DARTS configuration by a factor of 7 to 10.   
+• The found robust configurations did not only avoid overfitting in the architectural level, but they also typically outperformed the architectures found by state-of-art discrete NAS optimizers used by Ying et al. (2019) (such as RL, RE, and HPO methods).   
+• The multi-fidelity in BOHB does not only accelerate the hyperparameter optimization procedure, but in this case also allows to determine the sufficient number of epochs to run the NAS optimizer in order to get an optimal architecture. In fact, the best configuration on each of the incumbents comes usually from the lowest budget, i.e. 25 search epochs.   
+• The most robust configuration on each of the search spaces are typically the ones with a large regularization factor, relative to the default value in Liu et al. (2019) (see Figure 19 in the appendix).
+
+# 6 CONCLUSION AND FUTURE DIRECTIONS
+
+We proposed NAS-Bench-1Shot1, a set of 3 new benchmarks for one-shot neural architecture search which allows to track the trajectory and performance of the found architectures computationally cheaply. Using our analysis framework, we compared state-of-the-art one-shot NAS methods and inspected the robustness of the methods and how they are affected by different hyperparameters. Our framework allows a fair comparison of any one-shot NAS optimizer and discrete NAS optimizers without any confounding factors. We hope that our proposed framework and benchmarks will facilitate the evaluation of existing and new one-shot NAS methods, improve reproducibility of work in the field, and lead to new insights on the underlying mechanisms of one-shot NAS.
+
+# ACKNOWLEDGMENTS
+
+The authors acknowledge funding by the Robert Bosch GmbH, support by the European Research Council (ERC) under the European Unions Horizon 2020 research and innovation program through grant no. 716721, and by BMBF grant DeToL.
+
+# REFERENCES
+
+Gabriel Bender, Pieter-Jan Kindermans, Barret Zoph, Vijay Vasudevan, and Quoc Le. Understanding and simplifying one-shot architecture search. In International Conference on Machine Learning, 2018.
+
+Andrew Brock, Theo Lim, J.M. Ritchie, and Nick Weston. SMASH: One-shot model architecture search through hypernetworks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $=$ rydeCEhs-.
+
+Han Cai, Ligeng Zhu, and Song Han. Proxylessnas: Direct neural architecture search on target task and hardware. In International Conference on Learning Representations, 2019.
+
+Francesco Paolo Casale, Jonathan Gordon, and Nicolo Fusi. Probabilistic neural architecture search. arXiv preprint arXiv:1902.05116, 2019.
+
+Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.
+
+Xuanyi Dong and Yi Yang. Searching for a robust neural architecture in four gpu hours. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1761– 1770, 2019.
+
+Xuanyi Dong and Yi Yang. Nas-bench-102: Extending the scope of reproducible neural architecture search. In International Conference on Learning Representations, 2020. URL https: //openreview.net/forum?id $=$ HJxyZkBKDr.
+
+Thomas Elsken, Jan Hendrik Metzen, and Frank Hutter. Efficient multi-objective neural architecture search via lamarckian evolution. In International Conference on Learning Representations, 2019.
+
+Shixiang Gu Eric Jang and Ben Poole. Categorical reparameterization with gumbel-softmax. In International Conference on Learning Representations, 2017.
+
+Stefan Falkner, Aaron Klein, and Frank Hutter. BOHB: Robust and efficient hyperparameter optimization at scale. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 1437–1446, Stockholmsmassan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL ¨ http://proceedings.mlr.press/v80/falkner18a.html.
+
+F. Hutter, H. Hoos, and K. Leyton-Brown. An efficient approach for assessing hyperparameter importance. In E. Xing and T. Jebara (eds.), Proceedings of the 31th International Conference on Machine Learning, (ICML’14), pp. 754–762. Omnipress, 2014.
+
+K. Jamieson and A. Talwalkar. Non-stochastic best arm identification and hyperparameter optimization. In Proceedings of the Seventeenth International Conference on Artificial Intelligence and Statistics (AISTATS), 2016.
+
+A. Krizhevsky. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.
+
+L. Li, K. Jamieson, G. DeSalvo, A. Rostamizadeh, and A. Talwalkar. Hyperband: Bandit-based configuration evaluation for hyperparameter optimization. In International Conference on Learning Representations, 2017.
+
+Liam Li and Ameet Talwalkar. Random search and reproducibility for neural architecture search. In Proceedings of the Thirty-Fifth Conference on Uncertainty in Artificial Intelligence, UAI 2019, Tel Aviv, Israel, July 22-25, 2019, pp. 129, 2019. URL http://auai.org/uai2019/ proceedings/papers/129.pdf.
+
+Eric Liang, Richard Liaw, Robert Nishihara, Philipp Moritz, Roy Fox, Joseph Gonzalez, Ken Goldberg, and Ion Stoica. Ray rllib: A composable and scalable reinforcement learning library. CoRR, abs/1712.09381, 2017. URL http://arxiv.org/abs/1712.09381.
+
+Marius Lindauer and Frank Hutter. Best practices for scientific research on neural architecture search. arXiv preprint arXiv:1909.02453, 2019.
+
+Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: Differentiable architecture search. In International Conference on Learning Representations, 2019.
+
+Renqian Luo, Fei Tian, Tao Qin, and T. M. Liu. Neural architecture optimization. In NeurIPS, 2018.
+
+Hieu Pham, Melody Y. Guan, Barret Zoph, Quoc V. Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. In International Conference on Machine Learning, 2018.
+
+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 Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 2902–2911, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR. URL http://proceedings.mlr. press/v70/real17a.html.
+
+Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V. Le. Aging Evolution for Image Classifier Architecture Search. In AAAI, 2019.
+
+Shreyas Saxena and Jakob Verbeek. Convolutional neural fabrics. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 4053–4061. Curran Associates, Inc., 2016.
+
+N. Srivastava, G. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15: 1929–1958, 2014.
+
+B. Williams, T. Santner, and W. Notz. Sequential design of computer experiments to minimize integrated response functions. Statistica Sinica, 2000.
+
+Sirui Xie, Hehui Zheng, Chunxiao Liu, and Liang Lin. SNAS: stochastic neural architecture search. In International Conference on Learning Representations, 2019.
+
+Yuhui Xu, Lingxi Xie, Xiaopeng Zhang, Xin Chen, Guo-Jun Qi, Qi Tian, and Hongkai Xiong. Pc-darts: Partial channel connections for memory-efficient architecture search. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum? id $=$ BJlS634tPr.
+
+Antoine Yang, Pedro M. Esperana, and Fabio M. Carlucci. Nas evaluation is frustratingly hard. In International Conference on Learning Representations, 2020. URL https://openreview. net/forum?id ${ . } = { }$ HygrdpVKvr.
+
+Chris Ying, Aaron Klein, Eric Christiansen, Esteban Real, Kevin Murphy, and Frank Hutter. NASbench-101: Towards reproducible neural architecture search. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 7105–7114, Long Beach, California, USA, 09–15 Jun 2019. PMLR. URL http://proceedings.mlr.press/v97/ ying19a.html.
+
+Kaicheng Yu, Christian Sciuto, Martin Jaggi, Claudiu Musat, and Mathieu Salzmann. Evaluating the search phase of neural architecture search. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } }$ H1loF2NFwr.
+
+Arber Zela, Thomas Elsken, Tonmoy Saikia, Yassine Marrakchi, Thomas Brox, and Frank Hutter. Understanding and robustifying differentiable architecture search. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ H1gDNyrKDS.
+
+Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. In International Conference on Learning Representations (ICLR) 2017 Conference Track, 2017.
+
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V. Le. Learning transferable architectures for scalable image recognition. In Conference on Computer Vision and Pattern Recognition, 2018.
+
+# A DETAILS ON SEARCH SPACES
+
+Search space 1 The main characteristic of this search space is that the number of parents for each choice block and output has to be exactly 2 (apart from choice block 1 which is only connected to the input). Because of this requirement one choice block had to be discarded as that would exceed the requirement to have at most 9 edges. The total distribution of test error in shown in Figure 6a. It is the smallest search space discussed in this work.
+
+Search space 2 This search space is related to search space 1 in that it only consists of 4 intermediate nodes, but in contrast the output has three parents and nodes 1 and 2 only one parent. This increases the number of architectures in this space compared to search space 1. The test error distribution is shown in Figure 6b.
+
+Search space 3 All 5 intermediate nodes are used in this search space, making this search space the largest, but also the search space where each node has on average the least number of parents. The test error distribution is shown in Figure 6c.
+
+# B OPTIMIZERS
+
+DARTS (Liu et al., 2019) uses a weighted continuous relaxation over the operations to learn an architecture by solving a bilevel optimization problem. The training dataset is split in two parts, one used for updating the parameters of the operations in the one-shot model, and the other to update the weights appended to operations, that determine the importance of that operation.
+
+For evaluation, we choose the parents of each choice block based on the highest architectural weights and the number of parents for that choice block given by Table 1. We pick the highest weighted operation from the choice block.
+
+GDAS (Dong & Yang, 2019) modifies DARTS, such that individual paths are sampled differentiably through each cell using Gumbel-Softmax (Eric Jang & Poole, 2017) to adapt the architecture weights. This reduces the memory overhead created by DARTS as only the sampled paths have to be evaluated. GDAS uses the same search space and evaluation procedure as DARTS.
+
+PC-DARTS (Xu et al., 2020) reduces the memory overhead by only evaluating a random fraction of the channels with the mixed-ops. The authors argue that this also regularizes the search as it lowers the bias towards weight-free operations such as skip-connect and max-pooling, which are often preferred early on in DARTS search. In addition to partial channel connections, the authors propose edge normalization, which adds additional architectural parameters to the edges connecting to an intermediate node. This is done to compensate for the added fluctuations due to the partial channel connections. These additional weights are already part of the search spaces we proposed in this paper.
+
+Random Search with Weight Sharing (Random WS) (Li & Talwalkar, 2019) randomly samples architectures from the one-shot model for each training mini-batch and trains only the selected subset of the one-shot model on that mini-batch. Differently from DARTS, PC-DARTS and GDAS,
+
+![](images/5da0da750fd00ae77b724fbb9a81f66db85bd72a71421ef63b070db342259b31.jpg)  
+Figure 6: Distribution of test error in the search spaces with loose ends.
+
+Random WS does not require a validation set, since there are no architectural weights that need to be updated. For evaluation Random WS samples 1000 architectures from the search space and evaluates each for only a small number of batches on the validation set using the optimized weights of the one-shot model corresponding to the sub-networks. Then the 5 architectures with the lowest one-shot validation error are chosen and fully evaluated on the validation set. The overall best architecture is returned.
+
+ENAS (Pham et al., 2018) similarly to Random WS samples sub-networks of in the one-shot model, however by means of a recurrent neural network (RNN) controller rather than randomly. As the search progresses the parameters of the RNN controller are updated via REINFORCE (Williams et al., 2000) using the validation error of the sampled architectures as a reward. This way the sampling procedure is handled in a more effective way.
+
+# C HYPERPARAMETERS
+
+If not stated otherwise the following hyperparameters were used for all our experiments. We used a batch size of 96 throughout for DARTS, GDAS and PC-DARTS as the search spaces are small enough to allow it and as this reduces the randomness in the training, which makes the comparison between optimizers easier. Random WS was trained with a batch size of 64. All other hyperparameters were adapted from DARTS (Liu et al., 2019).
+
+# D COMPARISON OF OPTIMIZERS OVER DIFFERENT BUDGETS
+
+![](images/c95165199a1cb9ec2be875a2019b76f4605846f7339da1019f62395df0686174.jpg)  
+Figure 7: Comparison of different One-Shot Neural Architecture optimizers on the three different search spaces defined on NAS-Bench-101 over 100 epochs.
+
+![](images/cdfe73f72ce5f677a5ed70ea5b68970dcb9f744a8b46d397ed44574cfdad8d1c.jpg)  
+Figure 8: Comparison of DARTS first and second order on the three different search spaces defined on NAS-Bench-101 for 25 epochs.
+
+# E REGULARIZATION
+
+# E.1 CUTOUT
+
+Interestingly, for GDAS the validation error of the one-shot model is closer linked to the test regret on NASBench as that is the case for DARTS as shown in Figure 9. This is particularly striking in search space 2 in which the local minimum attained by the one-shot validation error is well aligned with the minimum of the test regret. It is interesting to note that GDAS very quickly overfits on this search space, since the validation error increases usually at around 50 epochs. This may be related to the linearly decreasing temperature schedule for the gumbel-softmax (Eric Jang & Poole, 2017) from 10 to 1 as proposed by Dong & Yang (2019). As the temperature decreases the operations with higher architectural weights will be sampled more often leading to overfitting on the architectural level as demonstrated by the increasing one-shot validation error. Cutout has little impact on the search phase of GDAS (Figure 9).
+
+![](images/54f7005facf4e0485e183119b32844dd0a0fdba949b27e8f4dc77fc6ffb31497.jpg)  
+Figure 9: Comparison of the effect of using Cutout during architecture search on GDAS for search space 1 and 2.
+
+![](images/eef30c999326d6c904c2f614651e1b70407d2fc78a255cd12103ba4d18a0cfb8.jpg)  
+Figure 10: Comparison of the effect of using cutout during architecture search on PC-DARTS for search space 1 and 2.
+
+For PC-DARTS (Figure 10) cutout regularization helped find better architectures in particular in search space 3 and 1. This underlines the fact that strong regularization on the architectural level via partial channel connections can be effectively supported by cutout regularization on the training loss. Second order optimization as proposed by DARTS has no significant benefit for PC-DARTS and often decreases the performance.
+
+# E.2 $L _ { 2 }$ REGULARIZATION
+
+Increasing the $L _ { 2 }$ regularization has a positive effect on the found architectures for GDAS in search space 1 and 2 as shown in Figure 13. However, in search space 3 setting the weight decay to $8 1 e ^ { - 4 }$ has the effect of making the model unstable.
+
+For PC-DARTS lowering the $L _ { 2 }$ regularization had overall a positive effect across all search spaces (Figure 14). However, this made the training also less stable as demonstrated by search space 1 (Figure 14a)
+
+![](images/7c648858f9cde8a1bc190c90b3249f593158fb0f823b41bf856af8e1ce4357f6.jpg)  
+Figure 11: Illustration of the impact that weight decay has on the test regret on NAS-Bench-101 and the validation error of the one-shot model using DARTS, GDAS and PC-DARTS on search space 3 (Best viewed in color).
+
+![](images/a11360e9821fd0a19a9e212b1db34d74af67dcb017d39b89dea19c2db254fd36.jpg)  
+Figure 12: DARTS first order w/o cutout trained with different levels of $L _ { 2 }$ regularization for search space 1 and 2.
+
+![](images/a615cba7fa442542623570d4841ac55ee61f9ee46f736dbf5dc8a9ebb3619d50.jpg)  
+Figure 13: Comparison of the effect of using different values of weight decay during architecture search on GDAS for search space 1 and 2.
+
+![](images/378fde47532e50d1c3a1597fc1e5811328088f6e59dc85c857ff5dc012c4b2ab.jpg)  
+Figure 14: Comparison of the effect of using different values of weight decay during architecture search on PC-DARTS for search space 1 and 2.
+
+# F BOHB DETAILS
+
+BOHB (Falkner et al., 2018) is a combination of Bayesian Optimization (BO) and Hyperband (HB) (Li et al., 2017). Hyperband uses SuccesssiveHalving (SH) (Jamieson & Talwalkar, 2016) to stop poorly performing trainings early. Success Halving starts trainings with an initial budget and advances the top fraction $( 1 / \eta )$ of them to the next stage with $\eta$ higher budget. Hyperband uses this a subroutine to evaluate many uniformly at random sampled configurations on small budgets. The budgets and scaling factors are chosen such that all SuccessiveHalving evaluations take approximately the same time. BOHB combines Hyperband with Bayesian Optimization by using a probabilistic model to guide the search towards better configurations. As a result, BOHB performs as well as Hyperband during early optimization, but samples better configurations once enough samples are available to build a model.
+
+# F.1 SETUP
+
+We ran BOHB for 64 iterations of SuccessiveHalving (Jamieson & Talwalkar, 2016) on 16 parallel workers, resulting in 280 full function evaluations. In our experiments we use the number of epochs that the one-shot NAS optimizers run the search as the fidelity used by BOHB and optimize the validation error after 108 epochs of training queried from NAS-Bench-101. Namely, we use min budget $= 2 5$ epochs, max budge $t = 1 0 0$ epochs and $\eta = 2$ in BOHB. Note that this is only the number of epochs used for the architecture search. Additionally, we never use the validation set split used to evaluate the individual architectures in NAS-Bench-101 during the architecture search. Therefore, each one-shot NAS optimizer will use $2 0 \mathrm { k }$ examples for training and 20k for search. The $\mathbf { X }$ -axis in Figures 15, 16, 17, 18 shows the simulated wall-clock time: $t _ { s i m } = t _ { s e a r c h } + t _ { t r a i n }$ , where $t _ { s e a r c h }$ is the time spent during search by each NAS algorithm configuration and $t _ { t r a i n }$ is the training time for 108 epochs (queried from NAS-Bench-101) of the architectures selected by the NAS optimizers.
+
+We build 3 configuration spaces with different cardinality and which include hyperparameters affecting the architecture search process. The spaces are as follows:
+
+1. $C S 1 = \{ L _ { 2 }$ , CO prob}   
+2. $C S 2 = \{ L _ { 2 } , C O _ { - } p r o b , l r \}$   
+3. $C S 3 = \{ L _ { 2 }$ , $C O$ prob, lr, moment, CO len, batch size, grad clip, arch lr, arch L2}
+
+# F.2 RESULTS
+
+![](images/fdb0bf4f2e614ade0c8bacba691331bb4d43c68275a4deaf9c75bd2cab7ff488.jpg)  
+Figure 15: Test regret of architectures found with DARTS (1st order) configurations sampled by BOHB on CS1. All the lines except the BOHB-DARTS one show the mean±std of the best architecture from 500 search repetitions (Best viewed in color).
+
+Interestingly, optimizing on CS2 led to not only a more robust configuration of DARTS, but also in outperforming a state-of-the-art discrete NAS optimizer such as Regularized Evolution (RE) (Real et al., 2019). The found solutions by BOHB also outperform every other one-shot optimizer used throughout this paper with their default settings. Including the learning rate in the configuration space was crucial to achieve such a performance. Figure 16 shows the results when running BOHB with the same settings on CS1. Note that none of the sampled configurations outperforms RE. On the other hand, increasing the cardinality of the configuration space requires many more samples to build a good model. Figure 17 shows the results when optimizing with BOHB on CS3. Even though the learning rate was inside this space, again none of the sampled configurations is better than the discrete NAS optimizers.
+
+![](images/7fb2fc011a18adf1ef62c6025a5eb70ca0ef25003426a3ac51ee1329ec03cd4d.jpg)  
+Figure 16: Test regret of architectures found with DARTS, GDAS and PC-DARTS (1st order) configurations sampled by BOHB on CS2. All the lines except BOHB-DARTS, BOHB-GDAS and BOHB-PC-DARTS show the mean±std of the best architecture from 500 search repetitions (Best viewed in color).
+
+![](images/f987a2e0c1420f1f0d906b52a2cdec78f80804478291d2c4c50d931517887ed1.jpg)  
+Figure 17: Analogous to Figure 15, with the only difference being that here we optimize on CS3.
+
+![](images/ec48288c47e1f5ca8df1810e2b910c900eb30a5e199d9f09a193f920fe93b327.jpg)  
+Figure 18: Test regret of architectures found with DARTS, GDAS and PC-DARTS (2nd order) configurations sampled by BOHB on CS2.
+
+# F.3 TRANSFERABILITY BETWEEN SPACES.
+
+The following Table 2 shows the performance of the best found configuration on search space 3 for 50 epochs by BOHB when transferred to search spaces 1 and 2. The results show the mean and standard deviation of the architectures found by 6 independent search runs with the respective optimizers. We can see that there is no clear pattern on what is transferable where.
+
+# G HYPERPARAMETER IMPORTANCE
+
+To better understand the configuration space which we evaluated with BOHB we use functional analysis of variance (fANOVA) (Hutter et al., 2014). The idea is to assess the importance of individual hyperparameters by marginalizing performances over all possible values other hyperparameters could have taken. The marginalization estimates are determined by a random forest model which was trained on all configurations belonging to specific budgets during the BOHB optimization procedure.
+
+Table 2: Results of architectures found on search space 1 and 2 with the best found configuration for 50 epochs by BOHB on search space 3.   
+
+<table><tr><td rowspan="2">Optimizer</td><td colspan="2">Test regret</td></tr><tr><td>Search space 1</td><td>Search Space 2</td></tr><tr><td rowspan="2">DARTS</td><td>Default config.</td><td>1.252e-2 ± 0.0 0.864e-2 ± 0.023e-2</td></tr><tr><td>Transferred config. 1.045e-2 ± 0.171e-2</td><td>0.992e-2 ± 0.211e-2</td></tr><tr><td rowspan="2">GDAS</td><td>Default config.</td><td>1.252e-2 ± 0.0 0.871e-2 ± 0.0</td></tr><tr><td>Transferred config. 3.093e-2 ± 3.975e-2</td><td>0.831e-2 ± 0.045e-2</td></tr><tr><td rowspan="2">PC-DARTS</td><td>Default config.</td><td>1.104e-2 ± 0.088e-2 1.133e-2 ± 0.404e-2</td></tr><tr><td>Transferred config. 5.843e-2 ± 4.118e-2</td><td>0.992e-2 ± 0.087e-2</td></tr></table>
+
+Figure 19 shows the interaction between the Cutout (CO) and $L _ { 2 }$ factor when optimizing on CS2, DARTS 1st order, for search space 1, 2 and 3. It should be noted that the best found configuration involves at least one relatively high value of one of the regularizers in CS2.
+
+![](images/0fa3c20d8d35b26e8f9dddb8adea3e24e09fcef0af9ac544ad16f7d02ec7a7c7.jpg)  
+Figure 19: Parameter importance for two hyperparameters, Cutout (CO) and $L _ { 2 }$ regularization (CS2) across different training epochs and search spaces (SS).
+
+# H CORRELATION BETWEEN THE ARCHITECTURE SEARCH MODEL AND THE ARCHITECTURE EVALUATION MODEL
+
+As a further experiment we wanted to test how strongly the validation error of the models used in architectures search and architecture evaluation are correlated. For this we sampled 150 architectures from search space 3 and trained this architecture in the proxy model. During training we compute the Spearman rank correlation between the validation error of the proxy model and the full architecture evaluation as queried from NAS-Bench-101. The results are shown in Figure 20. Note that 9 cells in the proxy was used for all of our previous experiments as it is also used by the NAS-Bench-101 models.
+
+For 9 cells (Figure 20c) in the proxy model, we find that increasing the total number of channels leads to stronger correlation between the proxy model and the full architecture. However, increasing it beyond 16 channels leads to a decrease in correlation. For 3 cells (Figure 20a) the strongest anytime correlation was interestingly found using only 2 initial channels, with more channels leading to worse performance at the beginning and no better final performance. The results suggest that there exists a set of good combinations between the number of cells and the initial number of channels to get the maximum correlation between the search and evaluation model. As a future work we plan to investigate this relationship, which could eventually lead to a more effective bandit-based NAS method.
+
+![](images/9eeb51d8a400b4c88d9e404eccca67fd3f7bd8a3ca37da9e0c5b70cd829ea444.jpg)  
+Figure 20: In this experiment we varied the total number of cells within [3, 6, 9] and the number of initial channels of the proxy model within [2, 4, 8, 16, 36].

parse/train/SJx9ngStPH/SJx9ngStPH_content_list.json

@@ -0,0 +1,2166 @@
+[
+    {
+        "type": "text",
+        "text": "NAS-BENCH-1SHOT1: BENCHMARKING AND DISSECTING ONE-SHOT NEURAL ARCHITECTURE SEARCH ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            723,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Arber $\\mathbf { Z e l a ^ { 1 * } }$ , Julien Siems1∗, & Frank Hutter1,2 1Department of Computer Science, University of Freiburg 2Bosch Center for Artificial Intelligence {zelaa, siemsj, fh}@cs.uni-freiburg.de ",
+        "bbox": [
+            184,
+            194,
+            565,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            289,
+            544,
+            304
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One-shot neural architecture search (NAS) has played a crucial role in making NAS methods computationally feasible in practice. Nevertheless, there is still a lack of understanding on how these weight-sharing algorithms exactly work due to the many factors controlling the dynamics of the process. In order to allow a scientific study of these components, we introduce a general framework for one-shot NAS that can be instantiated to many recently-introduced variants and introduce a general benchmarking framework that draws on the recent large-scale tabular benchmark NAS-Bench-101 for cheap anytime evaluations of one-shot NAS methods. To showcase the framework, we compare several state-of-the-art one-shot NAS methods, examine how sensitive they are to their hyperparameters and how they can be improved by tuning their hyperparameters, and compare their performance to that of blackbox optimizers for NAS-Bench-101. ",
+        "bbox": [
+            233,
+            321,
+            764,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            517,
+            336,
+            534
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While neural architecture search (NAS) has attracted a lot of attention due to the effectiveness in automatically designing state-of-the-art neural networks (Zoph & Le, 2017; Zoph et al., 2018; Real et al., 2017; 2019), the focus has recently shifted to making the search process more efficient (Pham et al., 2018; Elsken et al., 2019; Liu et al., 2019; Xie et al., 2019; Cai et al., 2019; Casale et al., 2019). The most crucial concept which led to a reduction in search costs to the order of a single function evaluation is certainly the weight-sharing paradigm: Training only a single large architecture (the one-shot model) subsuming all the possible architectures in the search space (Brock et al., 2018; Pham et al., 2018). ",
+        "bbox": [
+            174,
+            550,
+            825,
+            661
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite the great advancements of these methods, the exact results of many NAS papers are often hard to reproduce (Li & Talwalkar, 2019; Yu et al., 2020; Yang et al., 2020). This is a result of several factors, such as unavailable original implementations, differences in the employed search spaces, training or evaluation pipelines, hyperparameter settings, and even pseudorandom number seeds (Lindauer & Hutter, 2019). One solution to guard against these problems would be a common library of NAS methods that provides primitives to construct different algorithm variants, similar to what as RLlib (Liang et al., 2017) offers for the field of reinforcement learning. Our paper makes a first step into this direction. ",
+        "bbox": [
+            174,
+            669,
+            825,
+            780
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, experiments in NAS can be computationally extremely costly, making it virtually impossible to perform proper scientific evaluations with many repeated runs to draw statistically robust conclusions. To address this issue, Ying et al. (2019) introduced NAS-Bench-101, a large tabular benchmark with $4 2 3 \\mathrm { k }$ unique cell architectures, trained and fully evaluated using a one-time extreme amount of compute power (several months on thousands of TPUs), which now allows to cheaply simulate an arbitrary number of runs of NAS methods, even on a laptop. NAS-Bench-101 enabled a comprehensive benchmarking of many discrete NAS optimizers (Zoph & Le, 2017; Real et al., 2019), using the exact same settings. However, the discrete nature of this benchmark does not allow to directly benchmark one-shot NAS optimizers (Pham et al., 2018; Liu et al., 2019; Xie et al., 2019; Cai et al., 2019). In this paper, we introduce the first method for making this possible. ",
+        "bbox": [
+            174,
+            786,
+            823,
+            898
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Specifically, after providing some background (Section 2), we make the following contributions: ",
+        "bbox": [
+            171,
+            138,
+            803,
+            154
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We introduce NAS-Bench-1Shot1, a novel benchmarking framework that allows us to reuse the extreme amount of compute time that went into generating NAS-Bench-101 (Ying et al., 2019) to cheaply benchmark one-shot NAS methods. Our mapping between search space representations is novel to the best of our knowledge and it allows querying the performance of found architectures from one-shot NAS methods, contrary to what is claimed by Ying et al. (2019). Specifically, it allows us to follow the full trajectory of architectures found by arbitrary one-shot NAS methods at each search epoch without the need for retraining them individually, allowing for a careful and statistically sound analysis (Section 3).   \n2. We introduce a general framework for one-shot NAS methods that can be instantiated to many recent one-shot NAS variants, enabling fair head-to-head evaluations based on a single code base (Section 4).   \n3. We use the above to compare several state-of-the-art one-shot NAS methods, assess the correlation between their one-shot model performance and final test performance, examine how sensitive they are to their hyperparameters, and compare their performance to that of black-box optimizers used in NAS-Bench-101 (Section 5). ",
+        "bbox": [
+            173,
+            162,
+            825,
+            381
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We provide our open-source implementation1, which we expect will also facilitate the reproducibility and benchmarking of other one-shot NAS methods in the future. ",
+        "bbox": [
+            173,
+            392,
+            821,
+            421
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND AND RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            440,
+            511,
+            457
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 NAS-BENCH-101 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            472,
+            338,
+            486
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "NAS-Bench-101 (Ying et al., 2019) is a database of an exhaustive evaluation of all architectures in a constrained cell-structured space on CIFAR-10 (Krizhevsky, 2009). Each cell is represented as a directed acyclic graph (DAG) where the nodes represent operation choices and the edges represent the information flow through the neural network (see also Figure 1 and Section 3.1). To limit the number of architectures in the search space, the authors used the following constraints on the cell: 3 operations in the operation set $\\mathcal { O } = \\{ 3 \\mathrm { x } 3 $ convolution, 1x1 convolution, $3 { \\mathrm { x } } 3 { \\mathrm { ~ m a x } } { \\mathrm { - p o o l } } \\}$ , at most 7 nodes (this includes input and output node, therefore 5 choice nodes) and at most 9 edges. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            594
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "These constraints, and exploiting symmetries, reduced the search space to $4 2 3 \\mathrm { k }$ unique valid architectures. Each architecture was trained from scratch three times to also obtain a measure of variance. In addition, each architecture was trained for 4, 12, 36 and 108 epochs; for our analysis, we mainly used the results for models trained for 108 epochs, if not stated otherwise. ",
+        "bbox": [
+            174,
+            602,
+            823,
+            657
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 NAS-BENCH-102 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            674,
+            339,
+            688
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Concurrently to this work, Dong & Yang (2020) released NAS-Bench-102, which is another NAS benchmark that, differently from NAS-Bench-101, enables the evaluation of weight-sharing NAS methods. Their search space consists of a total of 15,625 architectures, which is exhaustively evaluated on 3 image classification datasets. Similarly to Zela et al. (2020) and this work, Dong & Yang (2020) found that architectural overfitting occurs for DARTS for all their datasets. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            770
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While NAS-Bench-102 and this work go towards the same direction, they differ in many ways: ",
+        "bbox": [
+            171,
+            777,
+            795,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. They use extensive computation to create a new benchmark (with 15.625 architectures), while we devise a novel reformulation to reuse the even much more extensive computation of the NASBench-101 dataset ( 120 TPU years) to create three new one-shot search spaces with the larges one containing 363.648 architectures. This required zero additional computational cost.   \n2. We show that it is possible to reuse the graph representation in NAS-Bench-101 to run one-shot NAS methods; this requires changes to the one-shot search space, but allows a mapping which can be used for architecture evaluation. ",
+        "bbox": [
+            173,
+            801,
+            826,
+            904
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/282ee12d642c910c0d623c37f9afca75b123967986e2ff858c8e7937724695a4.jpg",
+        "image_caption": [
+            "Figure 1: Overview of the NAS-Bench-1Shot1 analysis strategy. The one-shot model we construct only contains discrete architectures that are elements of NAS-Bench-101 (Ying et al., 2019). The cell architecture chosen is similar to that of Bender et al. (2018), with each choice block containing an operation decision. Note that NAS-Bench-101 does not contain a separate reduction cell type. Plot on the right from Ying et al. (2019) (Best viewed in color). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            99,
+            823,
+            287
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3. They evaluate their search space on 3 image classification datasets, while we introduce 3 different search spaces (as sub-spaces of NAS-Bench-101) with growing complexity. ",
+        "bbox": [
+            173,
+            417,
+            823,
+            446
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 ONE-SHOT NEURAL ARCHITECTURE SEARCH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            489,
+            531,
+            505
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The NAS problem can be defined as searching for the optimal operation (e.g. in terms of validation error of architectures) out of the operation set $\\mathcal { O }$ in each node of the DAG and for the best connectivity pattern between these nodes. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            568
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Designing architectures for optimized accuracy or to comply with resource constraints led to significant breakthroughs on many standard benchmarks (Pham et al., 2018; Zoph & Le, 2017; Brock et al., 2018; Liu et al., 2019; Cai et al., 2019; Elsken et al., 2019). While early methods were computationally extremely expensive (Zoph & Le, 2017), the weight-sharing paradigm (Brock et al., 2018; Pham et al., 2018) led to a significant increase in search efficiency. Here, the weights of the operations in each architecture are shared in a supermodel (the so-called one-shot model or convolutional neural fabric (Saxena & Verbeek, 2016)), which contains an exponential number of sub-networks, each of which represents a discrete architecture. Architectures whose sub-networks share components (nodes/edges) also share the weights for these components’ operations; therefore, in analogy to DropOut (Srivastava et al., 2014), training one architecture implicitly also trains (parts of) an exponential number of related architectures. There are a variety of methods on how to conduct NAS by means of the one-shot model (Brock et al., 2018; Pham et al., 2018; Bender et al., 2018; Liu et al., 2019; Li & Talwalkar, 2019) (see also Appendix B), but the final problem is to find the optimal sub-network in this one-shot model. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            770
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The weight sharing method was used to great effect in DARTS (Liu et al., 2019), where it allows a gradient based optimization of both the architectural and the one-shot weights. Subsequent work on DARTS has addressed further lowering the computational and the memory requirements (Dong & Yang, 2019; Xu et al., 2020; Cai et al., 2019; Casale et al., 2019). ",
+        "bbox": [
+            176,
+            777,
+            823,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One fundamental drawback of the weight sharing method is the fact that the architecture search typically takes place in a lower fidelity model (e.g., using less cells and/or cheaper operations): the so-called proxy model. After the search, a discrete architecture is derived from the proxy model which is then trained with more parameters — a stage often referred to as architecture evaluation. This poses the question whether the architecture found in the proxy model is also a good architecture in the bigger model, a question studied by several recent works (Bender et al., 2018; Yu et al., 2020). ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 A GENERAL FRAMEWORK FOR BENCHMARKING ONE-SHOT NAS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            740,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We will now introduce our framework for cheaply benchmarking the anytime performance of oneshot NAS methods. Our main analysis strategy is the following: First, we run the search procedure of various methods and save the architecture weights of the one-shot models for each epoch. Second, we find the discrete architecture at each epoch and query it in NAS-Bench-101. The last step is not trivial due to the different representations of the search space used in NAS-Bench-101 and standard one-shot methods. Ying et al. (2019) state that one-shot methods cannot be directly evaluated on NAS-Bench-101. In the following sections we present a mapping between these different search space representations, which eventually enable us to evaluate one-shot methods on NAS-Bench101. To the best of our knowledge this is a novel contribution of this paper. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            258
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 SEARCH SPACE REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            275,
+            446,
+            290
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to carry out the analysis we propose in this work, we had to construct a search space that only contains discrete architectures that are also contained in NAS-Bench-101. This allows us to look up any discrete architectures’ performance in NAS-Bench-101 when the larger model is trained from scratch. Unfortunately, this is non-trivial since the NAS-Bench-101 space does not match the typical space used in one-shot NAS methods. We separately consider the various parts of the search space. ",
+        "bbox": [
+            174,
+            301,
+            825,
+            371
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Network-Level Topology. In terms of network-level topology, our search spaces closely resemble the models which were evaluated in NAS-Bench-101. We used the same macro architecture as in NAS-Bench-101, i.e., 3 stacked blocks with a max-pooling operation in-between, where each block consists of 3 stacked cells (see Figure 1). While our final evaluation models exactly follow NAS-Bench-101 in order to be able to reuse its evaluations, our one-shot model only has 16 initial convolution filters, rather than the 128 used in NAS-Bench-101. This is a common practice to accelerate NAS and used similarly in, e.g., Liu et al. (2019). ",
+        "bbox": [
+            173,
+            377,
+            825,
+            477
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Cell-Level Topology. The cell-level structure is represented as a DAG, where the input node is the output of a previous cell or the convolutional stem, and the output node is a concatenation of all the previous nodes. In order to have the operation choices still in the intermediate nodes of the DAG, we adapt the choice block motif from Bender et al. (2018) as depicted in Figure 1. The edges connecting input, output nodes and choice blocks represent only the information flow in the graph. To have a large and expressive enough search space(s), we introduce the following architectural weights in the DAG edges: ",
+        "bbox": [
+            173,
+            482,
+            825,
+            580
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• $\\alpha ^ { i , j }$ to edges connecting nodes $\\textit { i } < \\textit { j }$ to choice block $j$ . The input of choice block $j$ is then   \ncomputed as $\\begin{array} { r } { I ^ { j } = \\sum _ { i < j } \\frac { \\exp ( \\alpha ^ { i , j } ) } { \\sum _ { i ^ { \\prime } < j } \\exp ( \\alpha ^ { i ^ { \\prime } , j } ) } x ^ { i } } \\end{array}$ , where $x ^ { i }$ is the output tensor of node $i$ (either input node or choice block).   \n• $\\gamma ^ { j , k }$ to the edges connecting the input node or choice blocks $j < k$ to the output node $k$ of the cell,   \nwhere the corresponding feature maps are concatenated: Ok = ⊕j<k exp(γj,kP )j0<k exp(γj0,k) x , where $\\oplus$ is the concatenation operator. ",
+        "bbox": [
+            173,
+            590,
+            825,
+            702
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that the non-linearity applied to the edge weights varies depending on the NAS optimizer used; e.g. for GDAS (Dong & Yang, 2019) and SNAS (Xie et al., 2019) it would be a GumbelSoftmax (Eric Jang & Poole, 2017) instead. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            753
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Choice Blocks. As in Bender et al. (2018), each choice block inside the cell can select between the operations in the operations set $\\mathcal { O }$ of NAS-Bench-101. In order to find the optimal operation in each choice block via gradient-based one-shot NAS methods, we assign an architectural weight $\\beta ^ { o }$ to each operation $o \\in \\mathcal { O }$ inside the choice block. The output of the choice block $j$ is computed by adding element-wise the latent representations coming from the operations outputs: ",
+        "bbox": [
+            174,
+            761,
+            823,
+            830
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8749e5d48276432487645c3694179abf27458bafa3066bcfec0745bb3877db20.jpg",
+        "text": "$$\nx ^ { j } = \\sum _ { o \\in \\mathcal { O } } \\frac { \\exp ( \\beta ^ { o } ) } { \\sum _ { o ^ { \\prime } \\in \\mathcal { O } } \\exp ( \\beta ^ { o ^ { \\prime } } ) } o ( I ^ { j } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            837,
+            611,
+            876
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which is basically the so-called MixedOp in DARTS. NASBench cells contain 1x1 projections in front every operation (demonstrated in Figure 1 in (Ying et al., 2019)). The number of output channels of each projection is chosen such that the output has the same number of channels as the ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "input. This adaptive choice for the number of channels is incompatible with the one-shot model due to the different tensor dimensionality coming from previous choice blocks. We used 1x1 projections with a fixed number of channels instead. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 EVALUATION PROCEDURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            174,
+            393,
+            188
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "By means of these additional weights we do not restrict the possible architectures in the search space to contain only a fixed number of edges per cell, as done for example in Zoph et al. (2018), Pham et al. (2018), Liu et al. (2019), etc. This requirement would have restricted our architectural decisions heavily, leading to only small search spaces. ",
+        "bbox": [
+            174,
+            204,
+            825,
+            261
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows the characteristics of each search space. We propose three different search spaces by making different decisions on the number of parents each choice block has. The decisions affect the quality and quantity of the architectures contained in each search space. For all search spaces note that the sum of the number of parents of all nodes in the search space is chosen to be 9, to match the NAS-Bench-101 requirement. Search space 1, 2 and 3 have 6240, 29160 and 363648 architectures with loose ends respectively, making search space 3 the largest investigated search space. To the best of our knowledge search space 3 is currently the largest and only available tabular benchmark for one-shot NAS. For details on each search space see Appendix A. ",
+        "bbox": [
+            174,
+            267,
+            516,
+            448
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/dac3da73efd354eb0f2a3c37ef91f090e87952c73b9d80bd91ab521c04c2573b.jpg",
+        "table_caption": [
+            "Table 1: Characteristic information of the search spaces. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"3\">Search space</td></tr><tr><td rowspan=\"6\">No. parents</td><td></td><td>1</td><td>2</td><td>3</td></tr><tr><td>Node 1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>Node 2</td><td>2</td><td>1</td><td>1</td></tr><tr><td>Node 3</td><td>2</td><td>2</td><td>1</td></tr><tr><td>Node 4</td><td>2</td><td>2</td><td>2</td></tr><tr><td>Node 5 Output</td><td>-</td><td>- 3</td><td>2 2</td></tr><tr><td rowspan=\"2\">No.archs.</td><td>w/ loose ends</td><td>2</td><td></td><td></td></tr><tr><td>w/o loose ends</td><td>6240 2487</td><td>29160 3609</td><td>363648 24066</td></tr></table>",
+        "bbox": [
+            529,
+            306,
+            821,
+            436
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            446,
+            821,
+            474
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given the architectural weights of the cell shown in Figure 1 we query the test and validation error of the discrete architecture from NAS-Bench-101 as follows. ",
+        "bbox": [
+            173,
+            482,
+            820,
+            510
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1. We determine the operation chosen in each choice block by choosing the operation with the highest architectural weight.   \n2. We determine the parents of each choice block and the output by choosing the top- $k$ edges according to Table 1 (e.g. for choice block 4 in search space 3 we would choose the top-2 edges as parents).   \n3. From 1. we construct the operation list and from 2. the adjacency matrix of the cell which we use to query NAS-Bench-101 for the test and validation error. ",
+        "bbox": [
+            173,
+            526,
+            825,
+            654
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Each node in the graph chooses its parents during evaluation following e.g. DARTS (Liu et al., 2019). However, because edges model information flow and the output edges are also architectural decisions there is possibility of a node being a loose end. These are nodes whose output does not contribute to the output of the discrete cell, as seen in the upper cell under evaluation of Figure 1. As a result, we can count the number of architectures with or without loose ends. Note, that had we chosen the children of each node we could have invalid architectures where a node has an output but no input. ",
+        "bbox": [
+            173,
+            671,
+            825,
+            768
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 A GENERAL FRAMEWORK FOR ONE-SHOT NAS METHODS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            799,
+            694,
+            816
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Most of the follow-up works of DARTS (Algorithm 1), which focus on making the search even more efficient and effective, started from the original DARTS codebase2, and each of them only change very few components compared to DARTS. ",
+        "bbox": [
+            174,
+            838,
+            823,
+            880
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 DARTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            118,
+            316,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 PC-DARTS ",
+        "text_level": 1,
+        "bbox": [
+            341,
+            118,
+            508,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3 GDAS ",
+        "text_level": 1,
+        "bbox": [
+            614,
+            118,
+            750,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1: $\\begin{array} { r } { I ^ { j } = \\sum _ { i < j } S ( \\alpha ^ { i , j } ) x ^ { i } } \\end{array}$   \n2: Ok = ⊕j<kS(γj,k)xj   \n3: xj = Po∈O S(βo)o(Ij )   \n4: m ← DAG(Ij , Ok , xj )   \n5: while not converged do   \n6: 7: 8: m.update(Λ, ∇ΛLvalid) m.update(w, ∇wLtrain) end while Return Λ ",
+        "bbox": [
+            178,
+            138,
+            328,
+            239
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1: Ij = Pi<j S(αi,j )xi   \n2: Ok = ⊕j<kS(γj,k)xj   \n3: xj = Po∈O S(βo)o(Mo∗Ij )+(1 − Mo ∗ Ij )   \n4: m ← DAG(Ij , Ok , xj )   \n5: while not converged do   \n6: m.update(Λ, ∇ΛLvalid)   \n7: 8: m.update(w, ∇wLtrain)   \nend while   \n9: Return Λ   \n1: Ij = Pi<j GS(αi,j )xi   \n2: Ok = ⊕j<kGS(γj,k)xj   \n3: xj = Po∈OGS(βo)o(Ij )   \n4: m ← DAG(Ij , Ok , xj )   \n5: while not converged do   \n6: m.update(Λ, ∇ΛLvalid)   \n7: m.update single path(w, ∇wLtrain)   \n8: 9: end while   \nReturn Λ ",
+        "bbox": [
+            344,
+            138,
+            599,
+            241
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            619,
+            138,
+            816,
+            239
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 4 Random NAS with Weight-sharing ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            268,
+            490,
+            282
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 5 ENAS ",
+        "text_level": 1,
+        "bbox": [
+            504,
+            267,
+            637,
+            281
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1: Ij = Pi<j x i   \n2: = ⊕ j<k xj   \n3: o ( I j )   \n4: m ← DAG(Ij , Ok , xj )   \n5: while not converged do   \n6: arch ← sample using controller(m)   \n7: m.update weights of single architecture(arch, w, ∇wLtrain)   \n8: Update RNN controller   \n9: end while   \n10: for i ∈ 1..100 do   \n11: arch samples ← sample using controller(m)   \n12: end for   \n13: Return arch ∈ arch samples with lowest validation error ",
+        "bbox": [
+            508,
+            286,
+            805,
+            433
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1: Ij = Pi<j x i 2: k = ⊕j<k xj   \n3: x j = P o ( I j )   \n4: m ← DAG(Ij , Ok , xj )   \n6: 7: 8:9: 5: while not converged do arch sample uniformly at random(m) m.update weights of single architecture(arch, w, ∇wLtrain) end while for i ∈ 1..1000 do   \n11: arch samples sample uniformly at random(m)   \n12: end for   \n13: Return arch $\\in$ arch samples with lowest validation error ",
+        "bbox": [
+            178,
+            287,
+            475,
+            431
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 and Algorithm 3 highlight these components (relative to DARTS) for PC-DARTS (Xu et al., 2020) and GDAS (Dong & Yang, 2019), respectively. For example, when comparing PCDARTS and DARTS, the only difference in our benchmark is the partial channel connections (line 3 of Algorithm 2) in the choice blocks, which consists of a channel sampling mask $M ^ { o }$ that drops feature maps coming from $I ^ { j }$ . GDAS, on the other hand, replaces the Softmax (S) function in DARTS by a Gumbel-Softmax $( G S )$ , which applies for every architectural weight in $\\Lambda = \\{ \\alpha , \\beta , \\gamma \\}$ (lines 1-3 in Algorithm 3), and uses this concrete distribution to sample single paths through the cell during search (line 7 in Algorithm 3). Random Search with Weight Sharing (Random WS) (Li & Talwalkar, 2019) (Algorithm 4) and ENAS (Pham et al., 2018) (Algorithm 5) do not need the continuous relaxation in order to conduct the architecture search, instead they sample randomly in RandomWS or from the recurrent neural network controller (line 6 in Algorithm 1) in ENAS, in order to select the sub-network in the one-shot model to train. ",
+        "bbox": [
+            173,
+            444,
+            825,
+            609
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "These close correspondences between current one-shot NAS variants provide an opportunity to implement all of these variants in the same general code basis. This allows us to (a) automatically guard against any confounding factors when evaluating the strengths and weaknesses of different approaches, and (b) allows us to mix and match the components of different algorithms. We implemented all variants in a single code basis, which we are committed to grow into a flexible library of primitives for one-shot NAS methods, and for which we will gladly accept any help the community wants to provide. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            714
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "One-shot NAS methods in this code basis inherit all the methods and attributes necessary for building the one-shot computational graph from a base parent class. This encapsulation and modularity ensures that all differences in their performance come from a few lines of code, and that all other confounding factors cannot affect these results. This will also facilitate the incorporation of other one-shot NAS methods and pinpoint the components that differ in them. ",
+        "bbox": [
+            174,
+            720,
+            823,
+            791
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, the primitives encoding the search spaces presented in Section 3 are defined separately from the NAS optimizers. This encapsulation will allow researchers to study each of these components in isolation, experimenting with one of them while being sure that the other one does not change. ",
+        "bbox": [
+            173,
+            797,
+            823,
+            854
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 NAS-BENCH-1SHOT1 AS A BENCHMARK AND ANALYSIS FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            103,
+            792,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now demonstrate the use of NAS-Bench-1Shot1 as a benchmark for one-shot NAS. We first evaluate the anytime performance of five different one-shot NAS methods: DARTS (Liu et al., 2019), GDAS (Dong & Yang, 2019), PC-DARTS (Xu et al., 2020), ENAS (Pham et al., 2018) and Random Search with Weight Sharing (Random WS) (Li & Talwalkar, 2019).3 Afterwards, we investigate the robustness of these one-shot NAS optimizers towards their search hyperparameters and show that if these hyperparameters are carefully tuned, the one-shot NAS optimizer can outperform a wide range of other discrete NAS optimizers in our search spaces. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            231
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 COMPARISON OF DIFFERENT ONE-SHOT NAS OPTIMIZERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            247,
+            617,
+            261
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We ran the NAS search for 50 epochs4 using their respective default hyperparameter settings (see Appendix C). If not stated otherwise, all the following results were generated by running each experiment with six random seeds (0 to 5). All plots show the mean and standard deviation of the test regret queried from NAS-Bench-101. Over the three independent trainings contained in NASBench101 for each architecture on each epoch budget we average. The search was done on a single NVIDIA RTX2080Ti using the same python environment. In Figure 2 we report the anytime test regret for each of these methods. Our findings can be summarized as follows: ",
+        "bbox": [
+            174,
+            272,
+            825,
+            371
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• While the one-shot validation error converged in all cases (except for GDAS due to the temperature annealing) the queried test error from NAS-Bench-101 of the architectures increased at some point, indicating that the architectural parameters overfit the validation set. This phenomenon occurred frequently for DARTS. The same result was also previously observed by Zela et al. (2020) on subspaces of the standard DARTS space. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            452
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• PC-DARTS demonstrated both a stable search and relatively good final performance in all search spaces, notably the best overall performance for search space 3. We attribute this behaviour to the regularization effect present in PC-DARTS via the partial channel connections (see Zela et al. (2020) and Section 5.3). ",
+        "bbox": [
+            176,
+            457,
+            821,
+            512
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• Random WS and ENAS mainly explore poor architectures across all three search spaces. This behaviour is a result of the small correlation between the architectures evaluated with the one-shot weights and their true performance during architecture evaluation (as queried from NAS-Bench101 (see Section 5.2)). This correlation directly affects these methods since in the end of search they sample a certain number of architectures (1000 randomly sampled for Random WS and 100 using the learned controller policy for ENAS) and evaluate them using the one-shot model weights in order to select the architecture which is going to be trained from scratch in the final evaluation phase. When running ENAS for 100 epochs in search space 2 (Figure 7 in the appendix) we see that the it performs better than Random WS. ENAS also has a stronger correlation between the sampled architectures and the NAS-Bench-101 architectures for search space 2 (see Section 5.2). ",
+        "bbox": [
+            174,
+            517,
+            825,
+            655
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• GDAS performs quite robustly across all 3 benchmarks, however, due to the temperature annealing of the Gumbel Softmax, it might manifest some premature convergence to a sub-optimal local minimum. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            702
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 CORRELATION ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            390,
+            737
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Many one-shot NAS methods, such as ENAS (Pham et al., 2018), NAONet (Luo et al., 2018) or Random WS (Li & Talwalkar, 2019) select the final architecture by means of the one-shot parameters. In order to assess if this is optimal we computed the correlation between a given architecture’s one-shot test error and its respective NAS-Bench-101 test error, for all 4 available budgets in NASBench-101 on every 10th search epoch. This analysis was performed for all architectures without loose ends in each search space. The only exception is ENAS, for which we decided to evaluate the correlation by sampling 100 architectures (as done by the algorithm after the search has finished to select the one to retrain from scratch) from the controller instead of evaluating every architecture in the search space. ",
+        "bbox": [
+            173,
+            748,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/187f620f20c862a6e167a6a57746ab87c879dfbd0fab69f166fea9f7f0527db4.jpg",
+        "image_caption": [
+            "Figure 2: Comparison of different one-shot NAS optimizers on the three different search spaces defined on NASBench. The solid lines show the anytime test regret (mean $\\pm$ std), while the dashed blurred lines the one-shot validation error (Best viewed in color). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            102,
+            820,
+            247
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/d93ee4dc46df9c108774edb39099f8dd3f3e24d71798721df90711beb34fdf75.jpg",
+        "image_caption": [
+            "Figure 3: Correlation between the one-shot validation error and the corresponding NAS-Bench-101 test error for each search space. (Best viewed in color). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            316,
+            820,
+            614
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 3, there is almost no correlation between the weight sharing ranking and the true one (Spearman correlation coeff. between -0.25 and 0.3) during search for DARTS, PC-DARTS, GDAS and Random WS. Only ENAS shows some correlation for search space 2 and some anticorrelation for search spaces 1 and 3. These results agree with the ones reported by Yu et al. (2020) (who could only do this evaluationx on a small search space) and explain the poor performance of Random WS and ENAS on our benchmarks, since the architectures sampled during evaluation and ranked according to their one-shot validation error are unlikely to perform well when evaluated independently. To the best of our knowledge this is the first time that an evaluation of this correlation is conducted utilizing such a large number of architectures in the search space, namely 24066 different architectures for search space 3. We added further experiments on the correlation between the lower fidelity proxy model used in architecture search and the final model from architecture evaluation in the Appendix H. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            849
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 ROBUSTNESS OF ONE-SHOT NAS OPTIMIZERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            868,
+            537,
+            882
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As already observed by Zela et al. (2020), DARTS tends to become more robust when the inner objective $\\mathcal { L } _ { t r a i n }$ in the bi-level optimization procedure has a relatively strong regularization factor during search. In order to investigate the long term behaviour, for this analysis we chose to run every search for 100 epochs instead of 50 epochs. Similarly to Zela et al. (2020), we find that enabling Cutout (DeVries & Taylor, 2017) or increasing the $L _ { 2 }$ factor for the search model weights, has a substantial effect on the quality of the solutions found by the NAS optimizers. See Figure 4 for the Cutout (CO) results and Figure 11 (in the appendix) for the results with different $L _ { 2 }$ regularization. Based on these results we observe that: ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/57b04aa70225b163e317d2600c3537b14cf5e9d4f1b2c96713c74c08aad10c9a.jpg",
+        "image_caption": [
+            "Figure 4: Illustration of the impact that Cutout has on the test regret on NAS-Bench-101 and the validation error of the one-shot model using DARTS, GDAS and PC-DARTS on search space 3 (Best viewed in color). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            820,
+            246
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            327,
+            825,
+            411
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• As DARTS overfits to the validation set at the end of search for search space 1 and 3, applying Cutout during search either keeps the solutions to a good local minimum or reduces the overfitting effect, a finding similar as the one in Zela et al. (2020).   \n• Interestingly, while Zela et al. (2020) only showed overfitting behavior for DARTS, it may also occur for GDAS (Figure 13 in the appendix) and PC-DARTS (Figure 14 in the appendix), which indicates that this might be an intrinsic property of these methods due to the local updates in the architecture space.   \n• In PC-DARTS, there is already a strong regularization effect as a result of the partial channel connectivity, which explains the robust behavior of this optimizer and that its results deteriorate on average as we increase $L _ { 2 }$ regularization. ",
+        "bbox": [
+            173,
+            424,
+            826,
+            574
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 TUNABILITY OF ONE-SHOT NAS HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            590,
+            589,
+            606
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Next to the hyperparameters used in the evaluation pipeline, one-shot NAS methods have several hyperparameters of their own, such as the regularization hyperparameters studied in Section 5.3, learning rates, and other hyperparameters of the search phase. ",
+        "bbox": [
+            176,
+            617,
+            825,
+            660
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Naively tuning these hyperparameters with the one-shot validation error as the objective would lead to sub-optimal configurations, since, as we saw, this metric is not a good indicator of generalization. In our proposed benchmarks, we can tune these hyperparameters of the NAS optimizer to minimize the validation error queried from NAS-Bench-101. By doing so, we aim to shed more light onto the influence these hyperparameters have during the one-shot search, and to study the sensitivity of the NAS method towards these hyperparameters. ",
+        "bbox": [
+            174,
+            666,
+            450,
+            861
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To this end, we constructed 3 configuration spaces of increasing cardinality, CS1, ",
+        "bbox": [
+            173,
+            868,
+            450,
+            896
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/88b0b2e4099127118d81a056b6be2e05beeb803856f438ceec5bd2e6d2738124.jpg",
+        "image_caption": [
+            "Figure 5: Optimizing the hyperparameters of one-shot optimizers with BOHB on search space 3. (best viewed in color). Results for search space 1 and 2 are shown in Figure 16. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            470,
+            667,
+            815,
+            813
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "CS2 and CS3 (see Appendix F for details), which only include hyperparameters controlling the NAS process. We chose BOHB (Falkner et al. (2018), see Appendix F for details) as the hyperparameter optimization method and DARTS as our NAS method to be tuned across all configuration spaces, since in our benchmarks it was more brittle than PC-DARTS and GDAS. We provide the results in Appendix F.2. ",
+        "bbox": [
+            173,
+            896,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            821,
+            145
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In order to compare the tunability of NAS methods, we used BOHB to optimize all of DARTS, PCDARTS, and GDAS, starting from their respective default hyperparameter settings. Figure 5 shows the anytime test regret of the architectures found by the respective NAS method’s configurations tried by BOHB; as the figure shows, PC-DARTS and GDAS start with much more robust hyperparameter settings, but DARTS can also be tuned to perform as well or better. We note that carrying out this optimization on NAS-Bench-1Shot1 reduced the time for tuning DARTS from a simulated 45 GPU days to 1 day on 16 GPUs. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            250
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 also provides an evaluation of DARTS, GDAS and PC-DARTS compared to the state-of-art discrete NAS optimizers used by Ying et al. (2019) (such as RL, RE, and HPO methods). Since these one-shot NAS methods are much faster than black-box methods, it is possible to tune them online using BOHB and the resulting BOHB-{DARTS, GDAS, PC-DARTS} typically still yields better performance over time. Note that we never use the validation set split used to evaluate the individual architectures in NAS-Bench-101 during the architecture search. This subset with $1 0 \\mathrm { k }$ examples is only used to compute the objective function value that BOHB optimizes. Therefore, the one-shot optimizers use $2 0 \\mathrm { k }$ examples for training and $2 0 \\mathrm { k }$ for the architectural parameter updates. The x-axis in Figures 5 shows the simulated wall-clock time: $t _ { s i m } = t _ { s e a r c h } + t _ { t r a i n }$ , where tsearch is the time spent during search by each configuration and $t _ { t r a i n }$ is the training time for 108 epochs (queried from NAS-Bench-101) of the architectures selected by the one-shot optimizer. From this experiment, we make the following observations: ",
+        "bbox": [
+            174,
+            257,
+            825,
+            424
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "• On all search spaces the architectures BOHB-DARTS found outperformed the architectures found by the default DARTS configuration by a factor of 7 to 10.   \n• The found robust configurations did not only avoid overfitting in the architectural level, but they also typically outperformed the architectures found by state-of-art discrete NAS optimizers used by Ying et al. (2019) (such as RL, RE, and HPO methods).   \n• The multi-fidelity in BOHB does not only accelerate the hyperparameter optimization procedure, but in this case also allows to determine the sufficient number of epochs to run the NAS optimizer in order to get an optimal architecture. In fact, the best configuration on each of the incumbents comes usually from the lowest budget, i.e. 25 search epochs.   \n• The most robust configuration on each of the search spaces are typically the ones with a large regularization factor, relative to the default value in Liu et al. (2019) (see Figure 19 in the appendix). ",
+        "bbox": [
+            173,
+            435,
+            826,
+            603
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION AND FUTURE DIRECTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            625,
+            545,
+            640
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We proposed NAS-Bench-1Shot1, a set of 3 new benchmarks for one-shot neural architecture search which allows to track the trajectory and performance of the found architectures computationally cheaply. Using our analysis framework, we compared state-of-the-art one-shot NAS methods and inspected the robustness of the methods and how they are affected by different hyperparameters. Our framework allows a fair comparison of any one-shot NAS optimizer and discrete NAS optimizers without any confounding factors. We hope that our proposed framework and benchmarks will facilitate the evaluation of existing and new one-shot NAS methods, improve reproducibility of work in the field, and lead to new insights on the underlying mechanisms of one-shot NAS. ",
+        "bbox": [
+            173,
+            655,
+            825,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            789,
+            356,
+            803
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors acknowledge funding by the Robert Bosch GmbH, support by the European Research Council (ERC) under the European Unions Horizon 2020 research and innovation program through grant no. 716721, and by BMBF grant DeToL. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            861
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Bender, Pieter-Jan Kindermans, Barret Zoph, Vijay Vasudevan, and Quoc Le. Understanding and simplifying one-shot architecture search. In International Conference on Machine Learning, 2018. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            169
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew Brock, Theo Lim, J.M. Ritchie, and Nick Weston. SMASH: One-shot model architecture search through hypernetworks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id $=$ rydeCEhs-. ",
+        "bbox": [
+            176,
+            179,
+            821,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Han Cai, Ligeng Zhu, and Song Han. Proxylessnas: Direct neural architecture search on target task and hardware. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            232,
+            820,
+            261
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Francesco Paolo Casale, Jonathan Gordon, and Nicolo Fusi. Probabilistic neural architecture search. arXiv preprint arXiv:1902.05116, 2019. ",
+        "bbox": [
+            173,
+            271,
+            821,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017. ",
+        "bbox": [
+            173,
+            310,
+            825,
+            340
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xuanyi Dong and Yi Yang. Searching for a robust neural architecture in four gpu hours. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1761– 1770, 2019. ",
+        "bbox": [
+            173,
+            349,
+            826,
+            392
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xuanyi Dong and Yi Yang. Nas-bench-102: Extending the scope of reproducible neural architecture search. In International Conference on Learning Representations, 2020. URL https: //openreview.net/forum?id $=$ HJxyZkBKDr. ",
+        "bbox": [
+            176,
+            402,
+            821,
+            446
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thomas Elsken, Jan Hendrik Metzen, and Frank Hutter. Efficient multi-objective neural architecture search via lamarckian evolution. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            455,
+            821,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shixiang Gu Eric Jang and Ben Poole. Categorical reparameterization with gumbel-softmax. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            174,
+            494,
+            821,
+            525
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stefan Falkner, Aaron Klein, and Frank Hutter. BOHB: Robust and efficient hyperparameter optimization at scale. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 1437–1446, Stockholmsmassan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL ¨ http://proceedings.mlr.press/v80/falkner18a.html. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            606
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "F. Hutter, H. Hoos, and K. Leyton-Brown. An efficient approach for assessing hyperparameter importance. In E. Xing and T. Jebara (eds.), Proceedings of the 31th International Conference on Machine Learning, (ICML’14), pp. 754–762. Omnipress, 2014. ",
+        "bbox": [
+            178,
+            614,
+            823,
+            659
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "K. Jamieson and A. Talwalkar. Non-stochastic best arm identification and hyperparameter optimization. In Proceedings of the Seventeenth International Conference on Artificial Intelligence and Statistics (AISTATS), 2016. ",
+        "bbox": [
+            174,
+            667,
+            826,
+            712
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A. Krizhevsky. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009. ",
+        "bbox": [
+            173,
+            722,
+            823,
+            751
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "L. Li, K. Jamieson, G. DeSalvo, A. Rostamizadeh, and A. Talwalkar. Hyperband: Bandit-based configuration evaluation for hyperparameter optimization. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            173,
+            761,
+            825,
+            804
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Liam Li and Ameet Talwalkar. Random search and reproducibility for neural architecture search. In Proceedings of the Thirty-Fifth Conference on Uncertainty in Artificial Intelligence, UAI 2019, Tel Aviv, Israel, July 22-25, 2019, pp. 129, 2019. URL http://auai.org/uai2019/ proceedings/papers/129.pdf. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eric Liang, Richard Liaw, Robert Nishihara, Philipp Moritz, Roy Fox, Joseph Gonzalez, Ken Goldberg, and Ion Stoica. Ray rllib: A composable and scalable reinforcement learning library. CoRR, abs/1712.09381, 2017. URL http://arxiv.org/abs/1712.09381. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marius Lindauer and Frank Hutter. Best practices for scientific research on neural architecture search. arXiv preprint arXiv:1909.02453, 2019. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: Differentiable architecture search. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            169
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Renqian Luo, Fei Tian, Tao Qin, and T. M. Liu. Neural architecture optimization. In NeurIPS, 2018. ",
+        "bbox": [
+            173,
+            176,
+            821,
+            191
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hieu Pham, Melody Y. Guan, Barret Zoph, Quoc V. Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. In International Conference on Machine Learning, 2018. ",
+        "bbox": [
+            173,
+            199,
+            823,
+            228
+        ],
+        "page_idx": 11
+    },
+    {
+        "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 Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 2902–2911, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR. URL http://proceedings.mlr. press/v70/real17a.html. ",
+        "bbox": [
+            173,
+            234,
+            825,
+            319
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V. Le. Aging Evolution for Image Classifier Architecture Search. In AAAI, 2019. ",
+        "bbox": [
+            171,
+            327,
+            823,
+            356
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shreyas Saxena and Jakob Verbeek. Convolutional neural fabrics. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 4053–4061. Curran Associates, Inc., 2016. ",
+        "bbox": [
+            176,
+            363,
+            825,
+            406
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "N. Srivastava, G. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15: 1929–1958, 2014. ",
+        "bbox": [
+            173,
+            414,
+            825,
+            457
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B. Williams, T. Santner, and W. Notz. Sequential design of computer experiments to minimize integrated response functions. Statistica Sinica, 2000. ",
+        "bbox": [
+            173,
+            464,
+            823,
+            493
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sirui Xie, Hehui Zheng, Chunxiao Liu, and Liang Lin. SNAS: stochastic neural architecture search. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            501,
+            823,
+            530
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yuhui Xu, Lingxi Xie, Xiaopeng Zhang, Xin Chen, Guo-Jun Qi, Qi Tian, and Hongkai Xiong. Pc-darts: Partial channel connections for memory-efficient architecture search. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum? id $=$ BJlS634tPr. ",
+        "bbox": [
+            176,
+            537,
+            825,
+            593
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Antoine Yang, Pedro M. Esperana, and Fabio M. Carlucci. Nas evaluation is frustratingly hard. In International Conference on Learning Representations, 2020. URL https://openreview. net/forum?id ${ . } = { }$ HygrdpVKvr. ",
+        "bbox": [
+            174,
+            602,
+            821,
+            645
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chris Ying, Aaron Klein, Eric Christiansen, Esteban Real, Kevin Murphy, and Frank Hutter. NASbench-101: Towards reproducible neural architecture search. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 7105–7114, Long Beach, California, USA, 09–15 Jun 2019. PMLR. URL http://proceedings.mlr.press/v97/ ying19a.html. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            737
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaicheng Yu, Christian Sciuto, Martin Jaggi, Claudiu Musat, and Mathieu Salzmann. Evaluating the search phase of neural architecture search. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } }$ H1loF2NFwr. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            787
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Arber Zela, Thomas Elsken, Tonmoy Saikia, Yassine Marrakchi, Thomas Brox, and Frank Hutter. Understanding and robustifying differentiable architecture search. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ H1gDNyrKDS. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            851
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. In International Conference on Learning Representations (ICLR) 2017 Conference Track, 2017. ",
+        "bbox": [
+            173,
+            858,
+            821,
+            887
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V. Le. Learning transferable architectures for scalable image recognition. In Conference on Computer Vision and Pattern Recognition, 2018. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A DETAILS ON SEARCH SPACES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            102,
+            450,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Search space 1 The main characteristic of this search space is that the number of parents for each choice block and output has to be exactly 2 (apart from choice block 1 which is only connected to the input). Because of this requirement one choice block had to be discarded as that would exceed the requirement to have at most 9 edges. The total distribution of test error in shown in Figure 6a. It is the smallest search space discussed in this work. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Search space 2 This search space is related to search space 1 in that it only consists of 4 intermediate nodes, but in contrast the output has three parents and nodes 1 and 2 only one parent. This increases the number of architectures in this space compared to search space 1. The test error distribution is shown in Figure 6b. ",
+        "bbox": [
+            174,
+            220,
+            825,
+            276
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Search space 3 All 5 intermediate nodes are used in this search space, making this search space the largest, but also the search space where each node has on average the least number of parents. The test error distribution is shown in Figure 6c. ",
+        "bbox": [
+            174,
+            292,
+            825,
+            335
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B OPTIMIZERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            357,
+            313,
+            373
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "DARTS (Liu et al., 2019) uses a weighted continuous relaxation over the operations to learn an architecture by solving a bilevel optimization problem. The training dataset is split in two parts, one used for updating the parameters of the operations in the one-shot model, and the other to update the weights appended to operations, that determine the importance of that operation. ",
+        "bbox": [
+            174,
+            388,
+            825,
+            445
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For evaluation, we choose the parents of each choice block based on the highest architectural weights and the number of parents for that choice block given by Table 1. We pick the highest weighted operation from the choice block. ",
+        "bbox": [
+            176,
+            452,
+            821,
+            494
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "GDAS (Dong & Yang, 2019) modifies DARTS, such that individual paths are sampled differentiably through each cell using Gumbel-Softmax (Eric Jang & Poole, 2017) to adapt the architecture weights. This reduces the memory overhead created by DARTS as only the sampled paths have to be evaluated. GDAS uses the same search space and evaluation procedure as DARTS. ",
+        "bbox": [
+            174,
+            501,
+            825,
+            556
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "PC-DARTS (Xu et al., 2020) reduces the memory overhead by only evaluating a random fraction of the channels with the mixed-ops. The authors argue that this also regularizes the search as it lowers the bias towards weight-free operations such as skip-connect and max-pooling, which are often preferred early on in DARTS search. In addition to partial channel connections, the authors propose edge normalization, which adds additional architectural parameters to the edges connecting to an intermediate node. This is done to compensate for the added fluctuations due to the partial channel connections. These additional weights are already part of the search spaces we proposed in this paper. ",
+        "bbox": [
+            173,
+            564,
+            825,
+            675
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Random Search with Weight Sharing (Random WS) (Li & Talwalkar, 2019) randomly samples architectures from the one-shot model for each training mini-batch and trains only the selected subset of the one-shot model on that mini-batch. Differently from DARTS, PC-DARTS and GDAS, ",
+        "bbox": [
+            174,
+            683,
+            825,
+            724
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/5da0da750fd00ae77b724fbb9a81f66db85bd72a71421ef63b070db342259b31.jpg",
+        "image_caption": [
+            "Figure 6: Distribution of test error in the search spaces with loose ends. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            750,
+            818,
+            895
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Random WS does not require a validation set, since there are no architectural weights that need to be updated. For evaluation Random WS samples 1000 architectures from the search space and evaluates each for only a small number of batches on the validation set using the optimized weights of the one-shot model corresponding to the sub-networks. Then the 5 architectures with the lowest one-shot validation error are chosen and fully evaluated on the validation set. The overall best architecture is returned. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "ENAS (Pham et al., 2018) similarly to Random WS samples sub-networks of in the one-shot model, however by means of a recurrent neural network (RNN) controller rather than randomly. As the search progresses the parameters of the RNN controller are updated via REINFORCE (Williams et al., 2000) using the validation error of the sampled architectures as a reward. This way the sampling procedure is handled in a more effective way. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            263
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            296,
+            379,
+            313
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "If not stated otherwise the following hyperparameters were used for all our experiments. We used a batch size of 96 throughout for DARTS, GDAS and PC-DARTS as the search spaces are small enough to allow it and as this reduces the randomness in the training, which makes the comparison between optimizers easier. Random WS was trained with a batch size of 64. All other hyperparameters were adapted from DARTS (Liu et al., 2019). ",
+        "bbox": [
+            174,
+            335,
+            825,
+            405
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D COMPARISON OF OPTIMIZERS OVER DIFFERENT BUDGETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            439,
+            687,
+            454
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/c95165199a1cb9ec2be875a2019b76f4605846f7339da1019f62395df0686174.jpg",
+        "image_caption": [
+            "Figure 7: Comparison of different One-Shot Neural Architecture optimizers on the three different search spaces defined on NAS-Bench-101 over 100 epochs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            492,
+            816,
+            636
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/cdfe73f72ce5f677a5ed70ea5b68970dcb9f744a8b46d397ed44574cfdad8d1c.jpg",
+        "image_caption": [
+            "Figure 8: Comparison of DARTS first and second order on the three different search spaces defined on NAS-Bench-101 for 25 epochs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            718,
+            818,
+            862
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E REGULARIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            359,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "E.1 CUTOUT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            276,
+            147
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, for GDAS the validation error of the one-shot model is closer linked to the test regret on NASBench as that is the case for DARTS as shown in Figure 9. This is particularly striking in search space 2 in which the local minimum attained by the one-shot validation error is well aligned with the minimum of the test regret. It is interesting to note that GDAS very quickly overfits on this search space, since the validation error increases usually at around 50 epochs. This may be related to the linearly decreasing temperature schedule for the gumbel-softmax (Eric Jang & Poole, 2017) from 10 to 1 as proposed by Dong & Yang (2019). As the temperature decreases the operations with higher architectural weights will be sampled more often leading to overfitting on the architectural level as demonstrated by the increasing one-shot validation error. Cutout has little impact on the search phase of GDAS (Figure 9). ",
+        "bbox": [
+            173,
+            159,
+            825,
+            299
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/54f7005facf4e0485e183119b32844dd0a0fdba949b27e8f4dc77fc6ffb31497.jpg",
+        "image_caption": [
+            "Figure 9: Comparison of the effect of using Cutout during architecture search on GDAS for search space 1 and 2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            314,
+            709,
+            455
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/eef30c999326d6c904c2f614651e1b70407d2fc78a255cd12103ba4d18a0cfb8.jpg",
+        "image_caption": [
+            "Figure 10: Comparison of the effect of using cutout during architecture search on PC-DARTS for search space 1 and 2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            518,
+            709,
+            661
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For PC-DARTS (Figure 10) cutout regularization helped find better architectures in particular in search space 3 and 1. This underlines the fact that strong regularization on the architectural level via partial channel connections can be effectively supported by cutout regularization on the training loss. Second order optimization as proposed by DARTS has no significant benefit for PC-DARTS and often decreases the performance. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            786
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "E.2 $L _ { 2 }$ REGULARIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            803,
+            362,
+            818
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Increasing the $L _ { 2 }$ regularization has a positive effect on the found architectures for GDAS in search space 1 and 2 as shown in Figure 13. However, in search space 3 setting the weight decay to $8 1 e ^ { - 4 }$ has the effect of making the model unstable. ",
+        "bbox": [
+            174,
+            829,
+            823,
+            871
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For PC-DARTS lowering the $L _ { 2 }$ regularization had overall a positive effect across all search spaces (Figure 14). However, this made the training also less stable as demonstrated by search space 1 (Figure 14a) ",
+        "bbox": [
+            174,
+            877,
+            823,
+            920
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c648858f9cde8a1bc190c90b3249f593158fb0f823b41bf856af8e1ce4357f6.jpg",
+        "image_caption": [
+            "Figure 11: Illustration of the impact that weight decay has on the test regret on NAS-Bench-101 and the validation error of the one-shot model using DARTS, GDAS and PC-DARTS on search space 3 (Best viewed in color). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            108,
+            820,
+            250
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/a11360e9821fd0a19a9e212b1db34d74af67dcb017d39b89dea19c2db254fd36.jpg",
+        "image_caption": [
+            "Figure 12: DARTS first order w/o cutout trained with different levels of $L _ { 2 }$ regularization for search space 1 and 2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            289,
+            325,
+            709,
+            468
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/a615cba7fa442542623570d4841ac55ee61f9ee46f736dbf5dc8a9ebb3619d50.jpg",
+        "image_caption": [
+            "Figure 13: Comparison of the effect of using different values of weight decay during architecture search on GDAS for search space 1 and 2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            289,
+            529,
+            709,
+            671
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/378fde47532e50d1c3a1597fc1e5811328088f6e59dc85c857ff5dc012c4b2ab.jpg",
+        "image_caption": [
+            "Figure 14: Comparison of the effect of using different values of weight decay during architecture search on PC-DARTS for search space 1 and 2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            289,
+            733,
+            709,
+            875
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "F BOHB DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            339,
+            117
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "BOHB (Falkner et al., 2018) is a combination of Bayesian Optimization (BO) and Hyperband (HB) (Li et al., 2017). Hyperband uses SuccesssiveHalving (SH) (Jamieson & Talwalkar, 2016) to stop poorly performing trainings early. Success Halving starts trainings with an initial budget and advances the top fraction $( 1 / \\eta )$ of them to the next stage with $\\eta$ higher budget. Hyperband uses this a subroutine to evaluate many uniformly at random sampled configurations on small budgets. The budgets and scaling factors are chosen such that all SuccessiveHalving evaluations take approximately the same time. BOHB combines Hyperband with Bayesian Optimization by using a probabilistic model to guide the search towards better configurations. As a result, BOHB performs as well as Hyperband during early optimization, but samples better configurations once enough samples are available to build a model. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            272
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "F.1 SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            290,
+            261,
+            303
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We ran BOHB for 64 iterations of SuccessiveHalving (Jamieson & Talwalkar, 2016) on 16 parallel workers, resulting in 280 full function evaluations. In our experiments we use the number of epochs that the one-shot NAS optimizers run the search as the fidelity used by BOHB and optimize the validation error after 108 epochs of training queried from NAS-Bench-101. Namely, we use min budget $= 2 5$ epochs, max budge $t = 1 0 0$ epochs and $\\eta = 2$ in BOHB. Note that this is only the number of epochs used for the architecture search. Additionally, we never use the validation set split used to evaluate the individual architectures in NAS-Bench-101 during the architecture search. Therefore, each one-shot NAS optimizer will use $2 0 \\mathrm { k }$ examples for training and 20k for search. The $\\mathbf { X }$ -axis in Figures 15, 16, 17, 18 shows the simulated wall-clock time: $t _ { s i m } = t _ { s e a r c h } + t _ { t r a i n }$ , where $t _ { s e a r c h }$ is the time spent during search by each NAS algorithm configuration and $t _ { t r a i n }$ is the training time for 108 epochs (queried from NAS-Bench-101) of the architectures selected by the NAS optimizers. ",
+        "bbox": [
+            173,
+            315,
+            825,
+            481
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We build 3 configuration spaces with different cardinality and which include hyperparameters affecting the architecture search process. The spaces are as follows: ",
+        "bbox": [
+            173,
+            489,
+            821,
+            517
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "1. $C S 1 = \\{ L _ { 2 }$ , CO prob}   \n2. $C S 2 = \\{ L _ { 2 } , C O _ { - } p r o b , l r \\}$   \n3. $C S 3 = \\{ L _ { 2 }$ , $C O$ prob, lr, moment, CO len, batch size, grad clip, arch lr, arch L2} ",
+        "bbox": [
+            173,
+            529,
+            812,
+            583
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "F.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            598,
+            277,
+            612
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/fdb0bf4f2e614ade0c8bacba691331bb4d43c68275a4deaf9c75bd2cab7ff488.jpg",
+        "image_caption": [
+            "Figure 15: Test regret of architectures found with DARTS (1st order) configurations sampled by BOHB on CS1. All the lines except the BOHB-DARTS one show the mean±std of the best architecture from 500 search repetitions (Best viewed in color). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            627,
+            818,
+            741
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, optimizing on CS2 led to not only a more robust configuration of DARTS, but also in outperforming a state-of-the-art discrete NAS optimizer such as Regularized Evolution (RE) (Real et al., 2019). The found solutions by BOHB also outperform every other one-shot optimizer used throughout this paper with their default settings. Including the learning rate in the configuration space was crucial to achieve such a performance. Figure 16 shows the results when running BOHB with the same settings on CS1. Note that none of the sampled configurations outperforms RE. On the other hand, increasing the cardinality of the configuration space requires many more samples to build a good model. Figure 17 shows the results when optimizing with BOHB on CS3. Even though the learning rate was inside this space, again none of the sampled configurations is better than the discrete NAS optimizers. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/7fb2fc011a18adf1ef62c6025a5eb70ca0ef25003426a3ac51ee1329ec03cd4d.jpg",
+        "image_caption": [
+            "Figure 16: Test regret of architectures found with DARTS, GDAS and PC-DARTS (1st order) configurations sampled by BOHB on CS2. All the lines except BOHB-DARTS, BOHB-GDAS and BOHB-PC-DARTS show the mean±std of the best architecture from 500 search repetitions (Best viewed in color). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            150,
+            816,
+            306
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/f987a2e0c1420f1f0d906b52a2cdec78f80804478291d2c4c50d931517887ed1.jpg",
+        "image_caption": [
+            "Figure 17: Analogous to Figure 15, with the only difference being that here we optimize on CS3. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            396,
+            818,
+            508
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/ec48288c47e1f5ca8df1810e2b910c900eb30a5e199d9f09a193f920fe93b327.jpg",
+        "image_caption": [
+            "Figure 18: Test regret of architectures found with DARTS, GDAS and PC-DARTS (2nd order) configurations sampled by BOHB on CS2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            558,
+            818,
+            670
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "F.3 TRANSFERABILITY BETWEEN SPACES. ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            734,
+            478,
+            748
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "The following Table 2 shows the performance of the best found configuration on search space 3 for 50 epochs by BOHB when transferred to search spaces 1 and 2. The results show the mean and standard deviation of the architectures found by 6 independent search runs with the respective optimizers. We can see that there is no clear pattern on what is transferable where. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            815
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "G HYPERPARAMETER IMPORTANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            837,
+            483,
+            852
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "To better understand the configuration space which we evaluated with BOHB we use functional analysis of variance (fANOVA) (Hutter et al., 2014). The idea is to assess the importance of individual hyperparameters by marginalizing performances over all possible values other hyperparameters could have taken. The marginalization estimates are determined by a random forest model which was trained on all configurations belonging to specific budgets during the BOHB optimization procedure. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "table",
+        "img_path": "images/04ff47956bae289cb669cd3433a8432687d3aeede6dd7ac5836cb618c11d41b2.jpg",
+        "table_caption": [
+            "Table 2: Results of architectures found on search space 1 and 2 with the best found configuration for 50 epochs by BOHB on search space 3. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Optimizer</td><td colspan=\"2\">Test regret</td></tr><tr><td>Search space 1</td><td>Search Space 2</td></tr><tr><td rowspan=\"2\">DARTS</td><td>Default config.</td><td>1.252e-2 ± 0.0 0.864e-2 ± 0.023e-2</td></tr><tr><td>Transferred config. 1.045e-2 ± 0.171e-2</td><td>0.992e-2 ± 0.211e-2</td></tr><tr><td rowspan=\"2\">GDAS</td><td>Default config.</td><td>1.252e-2 ± 0.0 0.871e-2 ± 0.0</td></tr><tr><td>Transferred config. 3.093e-2 ± 3.975e-2</td><td>0.831e-2 ± 0.045e-2</td></tr><tr><td rowspan=\"2\">PC-DARTS</td><td>Default config.</td><td>1.104e-2 ± 0.088e-2 1.133e-2 ± 0.404e-2</td></tr><tr><td>Transferred config. 5.843e-2 ± 4.118e-2</td><td>0.992e-2 ± 0.087e-2</td></tr></table>",
+        "bbox": [
+            228,
+            140,
+            766,
+            281
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            320,
+            823,
+            349
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Figure 19 shows the interaction between the Cutout (CO) and $L _ { 2 }$ factor when optimizing on CS2, DARTS 1st order, for search space 1, 2 and 3. It should be noted that the best found configuration involves at least one relatively high value of one of the regularizers in CS2. ",
+        "bbox": [
+            173,
+            356,
+            825,
+            398
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/0fa3c20d8d35b26e8f9dddb8adea3e24e09fcef0af9ac544ad16f7d02ec7a7c7.jpg",
+        "image_caption": [
+            "Figure 19: Parameter importance for two hyperparameters, Cutout (CO) and $L _ { 2 }$ regularization (CS2) across different training epochs and search spaces (SS). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            431,
+            826,
+            858
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "H CORRELATION BETWEEN THE ARCHITECTURE SEARCH MODEL AND THE ARCHITECTURE EVALUATION MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            808,
+            136
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "As a further experiment we wanted to test how strongly the validation error of the models used in architectures search and architecture evaluation are correlated. For this we sampled 150 architectures from search space 3 and trained this architecture in the proxy model. During training we compute the Spearman rank correlation between the validation error of the proxy model and the full architecture evaluation as queried from NAS-Bench-101. The results are shown in Figure 20. Note that 9 cells in the proxy was used for all of our previous experiments as it is also used by the NAS-Bench-101 models. ",
+        "bbox": [
+            173,
+            151,
+            825,
+            248
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "For 9 cells (Figure 20c) in the proxy model, we find that increasing the total number of channels leads to stronger correlation between the proxy model and the full architecture. However, increasing it beyond 16 channels leads to a decrease in correlation. For 3 cells (Figure 20a) the strongest anytime correlation was interestingly found using only 2 initial channels, with more channels leading to worse performance at the beginning and no better final performance. The results suggest that there exists a set of good combinations between the number of cells and the initial number of channels to get the maximum correlation between the search and evaluation model. As a future work we plan to investigate this relationship, which could eventually lead to a more effective bandit-based NAS method. ",
+        "bbox": [
+            173,
+            256,
+            825,
+            381
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/9eeb51d8a400b4c88d9e404eccca67fd3f7bd8a3ca37da9e0c5b70cd829ea444.jpg",
+        "image_caption": [
+            "Figure 20: In this experiment we varied the total number of cells within [3, 6, 9] and the number of initial channels of the proxy model within [2, 4, 8, 16, 36]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            393,
+            818,
+            536
+        ],
+        "page_idx": 19
+    }
+]

parse/train/Uq_tGs7N54M/Uq_tGs7N54M.md

@@ -0,0 +1,301 @@
+# Robust Counterfactual Explanations on Graph Neural Networks
+
+# Mohit Bajaj1\* Lingyang $\mathbf { C h u ^ { 2 * } }$ Zi Yu Xue1,3Jian Pei4 Lanjun Wang1Peter Cho-Ho Lam1Yong Zhang1
+
+1Huawei Technologies Canada Co., Ltd. 2McMaster University 3 The University of British Columbia 4Simon Fraser University {mohit.bajaj1，zi.yu.xue，lanjun.wang，cho.ho.lam，yong.zhang3}@huawei.com chul9@mcmaster.ca,jpei@cs.sfu.ca
+
+# Abstract
+
+Massive deployment of Graph Neural Networks (GNNs) in high-stake applications generates a strong demand for explanations that are robust to noise and align well with human intuition. Most existing methods generate explanations by identifying a subgraph of an input graph that has a strong correlation with the prediction. These explanations are not robust to noise because independently optimizing the correlation for a single input can easily overfit noise.Moreover, they are not counterfactual because removing an identified subgraph from an input graph does not necessarily change the prediction result. In this paper, we propose a novel method to generate robust counterfactual explanations on GNNs by explicitly modelling the common decision logic of GNNs on similar input graphs. Our explanations are naturally robust to noise because they are produced from the common decision boundaries of a GNN that govern the predictions of many similar input graphs. The explanations are also counterfactual because removing the set of edges identified by an explanation from the input graph changes the prediction significantly. Exhaustive experiments on many public datasets demonstrate the superior performance of our method.
+
+# 1 Introduction
+
+Graph Neural Networks (GNNs) [22,37,50] have achieved great practical successes in many realworld applications,such as chemistry [31],molecular biology[17],social networks [3] and epidemic modelling [34]. For most of these applications, explaining predictions made by a GNN model is crucial for establishing trust with end-users,identifying the cause of a prediction,and even discovering potential deficiencies of a GNN model before massive deployment. Ideally,an explanation should be able to answer questions like “Would the prediction of the GNN model change if a certain part of an input molecule is removed?” in the context of predicting whether an artificial molecule is active for acertain type of proteins [19,41],“Would an item recommended stillbe recommended if a customer had not purchased some other items in the past?” for a GNN built for recommendation systems [9, 44].
+
+Counterfactual explanations [28] in the form of “If X had not occurred, Y would not have occurred”[26] are the principled way to answer such questions and thus are highly desirable for GNNs. In the context of GNNs,a counterfactual explanation identifies a small subset of edges of the input graph instance such that removing those edges significantly changes the prediction made by the GNN. Counterfactual explanations are usually concise and easy to understand [28,36] because they align well with the human intuition to describe a causal situation [26]. To make explanations more trustworthy, the counterfactual explanation should be robust to noise,that is,some slight changes on an input graph do not change the explanation significantly. This idea aligns well with the notion of robustness discussed for DNN explanations in computer vision domain [11]. According to Ghorbani et al.[11] many interpretations on neural networks are fragile as it is easier to generate adversarial perturbations that produce perceptively indistinguishable inputs that are assigned the same predicted label,yet have very different interpretations.Here,the concepts of “fragile”“robustness”describe the same concept from opposite perspectives. An interpretation is said to be fragile if systematic perturbations can lead to dramatically different interpretations without changing the label. Otherwise, the interpretation is said to be robust.
+
+How to produce robust counterfactual explanations on predictions made by general graph neural networks is a novel problem that has not been systematically studied before.As to be discussed in Section 2, most GNN explanation methods [45,25,46,37,32] are neither counterfactual nor robust. These methods mostly focus on identifying a subgraph of an input graph that achieves a high correlation with the prediction result. Such explanations are usually not counterfactual because, due to the high non-convexity of GNNs, removing a subgraph that achieves a high correlation does not necessarily change the prediction result. Moreover, many existing methods [45,25,37,32] are not robust to noise and may change significantly upon slight modifications on input graphs, because the explanation of every single input graph prediction is independently optimized to maximize the correlation with the prediction, thus an explanation can easily overfit the noise in the data.
+
+In this paper², we develop RCExplainer, a novel method to produce robust counterfactual explanations on GNNs. The key idea is to first model the common decision logic of a GNN by set of decision regions where each decision region governs the predictions on a large number of graphs,and then extract robust counterfactual explanations by a deep neural network that explores the decision logic carried by the linear decision boundaries of the decision regions. We make the following contributions.
+
+First, we model the decision logic of a GNN by a set of decision regions, where each decision region is induced by a set of linear decision boundaries of the GNN. We propose an unsupervised method to find decision regions for each class such that each decision region governs the prediction of multiple graph samples predicted to be the same class. The linear decision boundaries of the decision region capture the common decision logic on all the graph instances inside the decision region, thus do not easily overfit the noise of an individual graph instance. By exploring the common decision logic encoded in the linear boundaries, we are able to produce counterfactual explanations that are inherently robust to noise.
+
+Second, based on the linear boundaries of the decision region,we propose a novel loss function to train a neural network that produces a robust counterfactual explanation as a small subset of edges of an input graph. The loss function is designed to directly optimize the explainability and counterfactual property of the subset of edges,such that: 1) the subgraph induced by the edges lies within the decision region,thus has a prediction consistent with the input graph; and 2) deleting the subset of edges from the input graph produces a remainder subgraph that lies outside the decision region, thus the prediction on the remainder subgraph changes significantly.
+
+Last, we conduct comprehensive experimental study to compare our method with the state-of-the-art methods on fidelity, robustness,accuracy and efficiency. All the results solidly demonstrate the superior performance of our approach.
+
+# 2Related work
+
+The existing GNN explanation methods [46,37, 45,32, 25] generally fall into two categories: model level explanation [46] and instance level explanation [37,45,32, 25].
+
+A model level explanation method [46] produces a high-level explanation about the general behaviors of a GNN independent from input examples. This may be achieved by synthesizing a set of artificial graph instances such that each artificial graph instance maximizes the prediction score on a certain class. The weakness of model level explanation methods is that an input graph instance may not contain an artificial graph instance,and removing an artificial graph from an input graph does not necessarily change the prediction. As a result, model level explanations are substantially different from counterfactual explanations, because the synthesized artificial graphs do not provide insights into how the GNN makes its prediction on a specific input graph instance.
+
+The instance level explanation methods [37,45,32, 25] explain the prediction(s) made by a GNN on a specific input graph instance or multiple instances by identifying a subgraph of an input graph instance that achieves a high correlation with the prediction on the input graph. GNNExplainer [45] removes redundant edges from an input graph instance to produce an explanation that maximizes the mutual information between the distribution of subgraphs of the input graph and the GNN's prediction. Following the same idea by Ying et al. [45],PGExplainer [25] parameterizes the generation process of explanations by a deep neural network,and trains it to maximize a similar mutual information based loss used by GNNExplainer [45]. The trained deep neural network is then applied to generate explanations for a single input graph instance or a group of input graphs. MEG [30] incorporates strong domain knowledge in chemistry with a reinforcement learning framework to produce counterfactual explanations on GNNs specifically built for compound prediction, but the heavy reliance on domain knowledge largely limits its applicability on general GNNs. The recently proposed CF-GNNExplainer [24] independently optimizes the counterfactual property for each explanation but ignores the correlation between the prediction and the explanation.
+
+Some studies [32,37] also adapt the existing explanation methods of image-oriented deep neural networks to produce instance level explanations for GNNs.Pope et al.[32] extend several gradient based methods [33,35,49] to explain predictions made by GNNs. The explanations are prone to gradient saturation[12] and may also be misleading [1] due to the heavy reliance on noisy gradients. Velickovic et al.[37] extend the atention mechanism[7,8] to identify the nodes in an input graph that contribute the most to the prediction.This method has to retrain the GNN with the altered architecture and the inserted attntion layers.Thus,the explanations may not be faithful to the original GNN.
+
+Instance level explanations from most of the methods are usually not counterfactual because, due to the non-convexity of GNNs, removing an explanation subgraph from the input graph does not necessarily change the prediction result. Moreover, those methods [45,25,37,32, 24] are usually not robust to noise because the explanation of every single input graph prediction is independently optimized. Thus,an explanation can easily overfit the noise inside input graphs and may change significantly upon slight modifications on input graphs.
+
+To tackle the weaknesses in the existing methods, in this paper, we directly optimize the counterfactual property of an explanation along with the correlation between the explanation and the prediction. Our explanations are also much more robust to modifications on input graphs,because they are produced from the common decision logic on a large group of similar input graphs, which do not easily overfit the noise of an individual graph sample.
+
+Please note that our study is substantially different from adversarial attacks on GNNs.The adversarial attacking methods [51,53,42,43,20] use adversarial examples to change the predictions of GNNs but ignore the explainability of the generated adversarial examples [1O]. Thus, the adversarial examples generated by adversarial attcks may not explain the original prediction.
+
+Our method is substantially different from the above works because we focus on explaining the prediction by directly optimizing the counterfactual property of an explanation along with correlation of the explanation with the prediction. We also require that the explanation is generally valid for a large set of similar graph instances by extracting it from the common linear decision boundaries of a large decision region.
+
+# 3Problem Formulation
+
+Denote by $G = \{ V , E \}$ a graph where $V = \{ v _ { 1 } , v _ { 2 } , \ldots , v _ { n } \}$ is the set of $n$ nodes and $E \subseteq V \times V$ is the set of edges. The edge structure of a graph $G$ is described by an adjacency matrix $\mathbf { A } \in \{ 0 , 1 \} ^ { n \times n }$ where ${ \bf A } _ { i j } = 1$ if there is an edge between node $v _ { i }$ and $v _ { j }$ ; and ${ \bf A } _ { i j } = 0$ otherwise.
+
+Denote by $\phi$ a GNN model that maps a graph to a probability distribution over a set of classes denoted by $C$ . Let $D$ denote the set of graphs that are used to train the GNN model $\phi$ .We focus on GNNs that adopt piecewise linear activation functions,such as MaxOut[14] and the family of ReLU[13,15,29].
+
+The robust counterfactual explanation problem is defined as follows.
+
+Definition 1 (Robust Counterfactual Explanation Problem) Given a GNN model $\phi$ trained on a set of graphs $D$ ， for an input graph $G = \{ V , E \}$ , our goal is to explain why $G$ is predicted by the GNN model as $\phi ( G )$ by identifying a small subset of edges $S \subseteq E$ ,such that $( l )$ removing the set of edges in $S$ from $G$ that causes the maximum drop in the confidence of the original prediction; and (2) $S$ is stable and doesn't change when the edges and the feature representations of the nodes of $G$ are perturbed by random noise.
+
+In the definition,the first requirement requires that the explanation $S$ is counterfactual, and the second requirement requires that the explanation is robust to noisy changes on the edges and nodes of $G$ ：
+
+# 4Method
+
+In this section, we first introduce how to extract the common decision logic of a GNN on a large set of graphs with the same predicted class. This is achieved by a decision region induced by a set of linear decision boundaries of the GNN.Then, based on the linear boundaries of the decision region, we propose a novel lossfunction to train a neural network that produces robust counterfactual explanations.Last, we discuss the time complexity of our method when generating explanations.
+
+# 4.1Modelling Decision Regions
+
+Following the routines of many deep neural network explanation methods [33, 48], we extract the decision region of a GNN in the $d$ -dimensional output space $\mathbb { O } ^ { d }$ of the last convolution layer of the GNN. The features generated by the last convolution layer are more conceptually meaningful and more robust to noise than those raw features of input graphs,such as vertices and edges [52, 2]. Denote by $\phi _ { g c }$ the mapping function realized by the graph convolution layers that maps an input graph $G$ to its graph embedding $\phi _ { g c } ( G ) \in \mathbb { O } ^ { d }$ ,and by $\phi _ { f c }$ the mapping function realized by the fully connected layers that maps the graph embedding $\phi _ { g c } ( G )$ to a predicted distribution over the classes in $C$ . The overall prediction $\phi ( { \bar { G } } )$ made by the GNN can be writtn as $\phi ( G ) = \phi _ { f c } ( \phi _ { g c } ( G ) )$
+
+For the GNNs that adopt piecewise linear activation functions for the hidden neurons, such as MaxOut [14] and the family of ReLU [13,15,29], the decision logic of $\phi _ { f c }$ in the space $\mathbb { O } ^ { d }$ is characterized by a piecewise linear decision boundary formed by connected pieces of decision hyperplanes in $\mathbb { O } ^ { d }$ [1]. We call these hyperplanes linear decision boundaries (LDBs), and denote by $\mathcal { H }$ the set of LDBs induced by $\phi _ { f c }$ . The set of LDBs in $\mathcal { H }$ partitions the space $\mathbb { O } ^ { d }$ into a large number of convex polytopes. A convex polytope is formed by a subset of LDBs in $\mathcal { H }$ . All the graphs whose graph embeddings are contained in the same convex polytope are predicted as the same class [4]. Therefore, the LDBs of a convex polytope encode the common decision logic of $\phi _ { f c }$ on all the graphs whose graph embeddings lie within the convex polytope [4]. Here,a graph $G$ is covered by a convex polytope if the graph embedding $\phi _ { g c } ( G )$ is contained in the convex polytope.
+
+Based on the above insight, we model the decision region for a set of graph instances as a convex polytope that satisfies the following two properties. First, the decision region should be induced by a subset of the LDBs in $\mathcal { H }$ .In this way, when we extract counterfactual explanations from the LDBs, the explanations are loyal to the real decision logic_of the GNN. Second, the decision region should cover many graph instances in the training dataset $D$ ,and all the covered graphs should be predicted as the same class. In this way, the LDBs of the decision region capture the common decision logic on all the graphs covered by the decision region. Here, the requirement of covering a larger number of graphs ensures that the common decision logic is general,and thus it is lesslikely to overfit the noise of an individual graph instance. As a result, the counterfactual explanations extracted from the LDBs of the decision region are insensitive to slight changes in the input graphs. Our method can be easily generalized to incorporate prediction confidence in the coverage measure,such as considering the count of graphs weighted by prediction confidence. To keep our discusson simple, we do not pursue this detail further in the paper.
+
+Next, we illustrate how to extract a decision region satisfying the above two requirements. The key idea is to find a convex polytope covering a large set of graph instances in $D$ that are predicted as the same class $c \in C$ ：
+
+Denote by $D _ { c } \subseteq D$ the set of graphs in $D$ predicted as a class $c \in C$ ,by $\mathcal { P } \subseteq \mathcal { H }$ a set of LDBs that partition the space $\mathbb { O } ^ { d }$ into a set of convex polytopes, and by $r ( \mathcal { P } , c )$ the convex polytope induced by $\mathcal { P }$ that covers the largest number of graphs in $D _ { c }$ . Denote by $g ( \mathcal { P } , c )$ the number of graphs in $D _ { c }$ covered by $r ( \mathcal { P } , c )$ ,and by $h ( \mathcal { P } , c )$ the number of graphs in $D$ that are covered by $r ( \mathcal { P } , \bar { c } )$ but are not predicted as class $c$ . We extract a decision region covering a large set of graph instances in $D _ { c }$ by solving the following constrained optimization problem.
+
+$$
+\operatorname* { m a x } _ { \mathcal { P } \subseteq \mathcal { H } } g ( \mathcal { P } , c ) , \mathrm { ~ s . t . ~ } h ( \mathcal { P } , c ) = 0
+$$
+
+This formulation realizes the two properties of decision regions because $\mathcal { P } \subseteq \mathcal { H }$ ensures that the decision region is induced by a subset of LDBs in $\mathcal { H }$ ,maximizing $g ( \mathcal { P } , c )$ requires that $r ( \mathcal { P } , c )$ covers
+
+a large number of graphs in $D _ { c }$ , and the constraint $h ( \mathcal { P } , c ) = 0$ ensures that allthe graphs covered by $r ( \mathcal { P } , c )$ are predicted as the same class $c$ ：
+
+Once we find a solution $\mathcal { P }$ to the above problem, the decision region $r ( \mathcal { P } , c )$ can be easily obtained by first counting the number of graphs in $D _ { c }$ covered by each convex polytope induced by $\mathcal { P }$ ,and then select the convex polytope that covers the largest number of graphs in $D _ { c }$ ：
+
+# 4.2Extracting Decision Regions
+
+The optimization problem in Equation (1) is intractable for standard GNNs, mainly because it is impractical to compute $\mathcal { H }$ , all the LDBs of a GNN. The number of LDBs in $\mathcal { H }$ of a GNN is exponential with respect to the number of neurons in the worst case [27].To address this challenge,we substitute $\mathcal { H }$ by a sample $\tilde { \mathcal { H } }$ of LDBs from $\tilde { \mathcal { H } }$ ：
+
+A LDB in the space $\mathbb { O } ^ { d }$ can be written as $\mathbf { w } ^ { \top } \mathbf { x } + b = 0$ ,where is $\mathbf { x } \in \mathbb { O } ^ { d }$ is a variable, w is the basis term, and $b$ corresponds to the bias.Following [4], for any input graph $G$ ,a linear boundary can be sampled from $\mathcal { H }$ by computing
+
+$$
+\mathbf { w } = \frac { \partial \left( \operatorname* { m a x } _ { 1 } ( \phi _ { f c } ( \alpha ) ) - \operatorname* { m a x } _ { 2 } ( \phi _ { f c } ( \alpha ) ) \right) } { \partial \alpha } | _ { \alpha = \phi _ { g c } ( G ) } ,
+$$
+
+and
+
+$$
+b = \mathrm { m a x } _ { 1 } ( \phi _ { f c } ( \alpha ) ) - \mathrm { m a x } _ { 2 } ( \phi _ { f c } ( \alpha ) ) - \mathbf { w } ^ { T } { \alpha } | _ { \alpha = \phi _ { g c } ( G ) } ,
+$$
+
+where $\operatorname* { m a x } _ { 1 } ( \phi _ { f c } ( \alpha ) ) )$ and $\operatorname* { m a x } _ { 2 } \bigl ( \phi _ { f c } ( \pmb { \alpha } ) \bigr )$ are the largest and the second largest values in the vector $\phi _ { f c } ( \alpha )$ ,respectively. Given an input graph $G$ ,Equations (2) and (3) identify one LDB from $\mathcal { H }$ .Thus, we can sample a subset of input graphs uniformly from $D$ ,and use Equations (2) and (3) to derive a sample of LDBs as $\tilde { \mathcal { H } } \subset \mathcal { H }$ ：
+
+Now, we substitute $\mathcal { H }$ in Equation (1) by $\tilde { \mathcal { H } }$ to produce the following problem.
+
+$$
+\operatorname* { m a x } _ { \mathcal { P } \subseteq \tilde { \mathcal { H } } } g ( \mathcal { P } , c ) , \mathrm { ~ s . t . ~ } h ( \mathcal { P } , c ) \leq \delta ,
+$$
+
+where $\delta \geq 0$ is a tolerance parameter to keep this problem feasible. The parameter $\delta$ is required because substituting $\mathcal { H }$ by $\tilde { \mathcal { H } }$ ignores the LDBs in $\mathcal { H } \backslash \tilde { \mathcal { H } }$ . Thus, the convex polytope $r ( \mathcal { P } , c )$ induced by subset of boundaries in $\tilde { \mathcal { H } }$ may contain instances that are not predicted as class $c$ . We directly set $\boldsymbol { \delta } \dot { = } \boldsymbol { h } ( \tilde { \mathcal { H } } , \boldsymbol { c } )$ , which is the smallest value of $\delta$ that keeps the practical problem feasible.
+
+The problem in Equation (4) can be proven to be a Submodular Cost Submodular Cover (SCSC) problem [18] (see Appendix $\mathbf { D }$ for proof) that is well known to be NP-hard [5]. We adopt a greedy boundary selection method to find a good solution to this problem [40]. Specifically, we initialize $\mathcal { P }$ as an empty set,and then iteratively select a new boundary $h$ from $\tilde { \mathcal { H } }$ by
+
+$$
+h = \arg \operatorname* { m i n } _ { h \in \tilde { \mathcal { H } } \backslash \mathcal { P } } \frac { g ( \mathcal { P } , c ) - g ( \mathcal { P } \cup \{ h \} , c ) + \epsilon } { h ( \mathcal { P } , c ) - h ( \mathcal { P } \cup \{ h \} , c ) } ,
+$$
+
+where $g ( \mathcal { P } , c ) - g ( \mathcal { P } \cup \{ h \} , c )$ is the decrease of $g ( \mathcal { P } , c )$ when adding $h$ into $\mathcal { P }$ ,and $h ( \mathcal { P } , c ) - h ( \mathcal { P } \cup$ $\{ h \} , c \bar { ) }$ is the decrease of $h ( \mathcal { P } , c )$ when adding $h$ into $\mathcal { P }$ .Both $g ( \mathcal { P } , c )$ and $h ( \mathcal { P } , c )$ are non-increasing when adding $h \in \tilde { \mathcal { H } }$ into $\mathcal { P }$ because adding a new boundary $h$ may only exclude some graphs from the convex polytope $r ( \mathcal { P } , c )$ ：
+
+Intuitively, in each iteration,Equation (5) selects a boundary $h \in \tilde { \mathcal { H } }$ such that adding $h$ into $\mathcal { P }$ reduces $g ( \mathcal { P } , c )$ the least and reduces $\bar { h } ( \mathcal { P } , c )$ the most. In this way,we can quickly reduce $h ( \mathcal { P } , c )$ to be smaller than $\delta$ without decreasing $g ( \mathcal { P } , c )$ too much, which produces a good feasible solution to the practical problem.We add a small constant $\epsilon$ to the numerator such that, when there are multiple candidates of $h$ that do not decrease $g ( \mathcal { P } , c )$ , we can still select the $h$ that reduces $h ( \mathcal { P } , c )$ the most.
+
+We apply a peeling-off strategy to iteratively extract multiple decision regions.For each class $c \in C$ we first solve the practical problem once to find a decision region $r ( \mathcal { P } , c )$ , then we remove the graphs covered by $r ( \mathcal { P } , \bar { c } )$ from $D _ { c }$ . If there are remaining graphs predicted as the class $c$ , we continue finding the decision regions using the remaining graphs until all the graphs in $D _ { c }$ are removed. When all the graphs in $D _ { c }$ are removed for each class $c \in C$ , we stop the iteration and return the set of decision regions we found.
+
+# 4.3Producing Explanations
+
+In this section, we introduce how to use the LDBs of decision regions to train a neural network that produces a robust counterfactual explanation as a small subset of edges of an input graph. We form explanations as a subset of edges because GNNs make decisions by aggregating messages passed on edges. Using edges instead of vertices as explanations can provide beter insights on the decision logic of GNNs.
+
+# 4.3.1The Neural Network Model
+
+Denote by $f _ { \theta }$ the neural network to generate a subset of edges of an input graph $G$ as the robust counterfactual explanation on the prediction $\phi ( G )$ ： $\theta$ represents the set of parameters of the neural network. For experiments, our explanation network $f$ consists of 2 fully connected layers with a ReLU activation and the hidden dimension of 64.
+
+For any two connected vertices $v _ { i }$ and $v _ { j }$ of $G$ ,denote by $\mathbf { z } _ { i }$ and $\mathbf { z } _ { j }$ the embeddings produced by the last convolution layer of the GNN for the two vertices, respectively. The neural network $f _ { \theta }$ takes $\mathbf { z } _ { i }$ and $\mathbf { z } _ { j }$ as the input and outputs the probability for the edge between $v _ { i }$ and $v _ { j }$ to be part of the explanation. This can be written as
+
+$$
+\begin{array} { r } { { \bf M } _ { i j } = f _ { \theta } ( { \bf z } _ { i } , { \bf z } _ { j } ) , } \end{array}
+$$
+
+where $\mathbf { M } _ { i j }$ denotes the probability that the edge between $v _ { i }$ and $v _ { j }$ is contained in the explanation. When there is no edge between $v _ { i }$ and $v _ { j }$ ,that is, ${ \bf A } _ { i j } = 0$ ,we set $\mathbf { \check { M } } _ { i j } = 0$
+
+For an input graph $G = \{ V , E \}$ with $n$ vertices and a trained neural network $f _ { \boldsymbol { \theta } } , \mathbf { M }$ is an $n$ -by- $\mathbf { \nabla } \cdot n$ matrix that carries the complete information to generate a robust counterfactual explanation as a subset of edges, denoted by $S \subseteq E$ . Concretely,we obtain $S$ by selecting all the edges in $E$ whose corresponding entries in $\mathbf { M }$ are larger than O.5.
+
+# 4.3.2Training Model $f _ { \theta }$
+
+For an input graph $G = ( V , E )$ , denote by $S \subseteq E$ the subset of edges produced by $f _ { \theta }$ to explain the prediction $\phi ( G )$ ,our goal is to train a good model $f _ { \theta }$ such that the prediction on the subgraph $G _ { S }$ induced by $S$ from $G$ is consistent with $\phi ( G )$ ; and deleting the edges in $S$ from $G$ produces a remainder subgraph $G _ { E \backslash S }$ such that the prediction on $G _ { E \backslash S }$ changes significantly from ${ \bar { \phi } } ( G )$ ：
+
+Since producing $S$ by $f _ { \theta }$ is a discrete operation that is hard to incorporate in an end-to-end training process, we define two proxy graphs to approximate $G _ { S }$ and $G _ { E \backslash S }$ ,respectively,such that the proxy graphs are determined by $\theta$ through continuous functions that can be smoothly incorporated into an end-to-end training process.
+
+The proxy graph of $G _ { S }$ , denoted by $G _ { \theta }$ , is defined by regarding $\mathbf { M }$ instead of $\mathbf { A }$ as the adjacency matrix. That is, $G _ { \theta }$ has exactly the same graph structure as $G$ , but the edge weights of $G _ { \theta }$ is given by the entries in $\mathbf { M }$ instead of $\mathbf { A }$ .Here,the subscript $\theta$ means $G _ { \theta }$ is determined by $\theta$
+
+The proxy graph of $G _ { E \backslash S }$ , denoted by $G _ { \theta } ^ { \prime }$ , also have the same graph structure as $G$ , but the edge weight between each pair of vertices $v _ { i }$ and $v _ { j }$ is defined as
+
+$$
+\begin{array} { r } { \mathbf { M } _ { i j } ^ { \prime } = \left\{ { 1 - \mathbf { M } _ { i j } \quad \mathrm { ~ i f ~ } \mathbf { A } _ { i j } = 1 } \atop { 0 } \right. } \end{array}
+$$
+
+The edge weights of both $G _ { \theta }$ and $G _ { \theta } ^ { \prime }$ are determined by $\theta$ through continuous functions, thus we can smoothly incorporate $G _ { \theta }$ and $G _ { \theta } ^ { \prime }$ into an end-to-end training framework.
+
+As discussed later in this section, we use a regularization term to force the value of each entry in $\mathbf { M } _ { i j }$ to be close to eitherOor 1,such that $G _ { \theta }$ and $\operatorname { \mathrm { \Sigma } } _ { G _ { \theta } ^ { \prime } } ^ { G \prime }$ better approximate $G _ { S }$ and $G _ { E \backslash S }$ respectively.
+
+We formulate our loss function as
+
+$$
+\mathcal { L } ( \theta ) = \sum _ { G \in D } \left\{ \lambda \mathcal { L } _ { s a m e } ( \theta , G ) + ( 1 - \lambda ) \mathcal { L } _ { o p p } ( \theta , G ) + \beta \mathcal { R } _ { s p a r s e } ( \theta , G ) + \mu \mathcal { R } _ { d i s c r e t e } ( \theta , G ) \right\} ,
+$$
+
+where $\lambda \in [ 0 , 1 ]$ $\beta \geq 0$ and $\mu \geq 0$ are the hyperparameters controlling the importance of each term. The influence of these parameters is discussed in Appendix $\mathbf { G }$ .The first term of our loss function requires that the prediction of the GNN on $G _ { \theta }$ is consistent with the prediction on $G$ . Intuitively, this means that the edges with larger weights in $G _ { \theta }$ dominate the prediction on $G$ .We formulate this term by requiring $G _ { \theta }$ to be covered by the same decision region covering $G$ ：
+
+Denote by $\mathcal { H } _ { G }$ the set of LDBs that induce the decision region covering $G$ ,and by $| \mathcal { H } _ { G } |$ the number of LDBs in $\mathcal { H } _ { G }$ . For the $i$ -th LDB $h _ { i } \in \mathcal { H } _ { G }$ , denote by $B _ { i } ( \mathbf { x } ) = \mathbf { w } _ { i } ^ { \top } \mathbf { x } + b _ { i }$ , where $\mathbf { w } _ { i }$ and $b _ { i }$ are the basis and bias of $h _ { i }$ , respectively, and $\mathbf { x } \in \mathbb { O } ^ { d }$ is a point in the space $\mathbb { O } ^ { d }$ . The sign of $B _ { i } ( { \bf x } )$ indicates whether a point $\mathbf { x }$ lies on the positive side or the negative side of $h _ { i }$ , and the absolute value $| B _ { i } ( { \bf x } ) |$ is proportional to the distance of a point $\mathbf { x }$ from $h _ { i }$ . Denote by $\sigma ( \cdot )$ the standard sigmoid function, we formulate the first term of our loss function as
+
+$$
+\mathcal { L } _ { s a m e } ( \theta , G ) = \frac { 1 } { | \mathcal { H } _ { G } | } \sum _ { h _ { i } \in \mathcal { H } _ { G } } \sigma \left( - \mathcal { B } _ { i } ( \phi _ { g c } ( G ) ) * \mathcal { B } _ { i } ( \phi _ { g c } ( G _ { \theta } ) ) \right) ,
+$$
+
+such that minimizing $\mathcal { L } _ { s a m e } ( \theta , G )$ encourages the graph embeddings $\phi _ { g c } ( G )$ and $\phi _ { g c } ( G _ { \theta } )$ to lie on the same side of every LDB in $\mathcal { H } _ { G }$ . Thus, $G _ { \theta }$ is encouraged to be covered by the same decision region covering $G$ ：
+
+The second term of our loss function optimizes the counterfactual property of the explanations by requiring the prediction on $G _ { \theta } ^ { \prime }$ to be significantly different from the prediction on $G$ . Intuitively, this means that the set of edges with larger weights in $G _ { \theta }$ are good counterfactual explanations because reducing the weights of these edges significantly changes the prediction. Following the above intuition,we formulate the second term as
+
+$$
+\mathcal { L } _ { o p p } ( \theta , G ) = \operatorname* { m i n } _ { h _ { i } \in \mathcal { H } _ { G } } \sigma \left( \mathcal { B } _ { i } ( \phi _ { g c } ( G ) ) * \mathcal { B } _ { i } ( \phi _ { g c } ( G _ { \theta } ^ { \prime } ) ) \right) ,
+$$
+
+such that minimizing $\mathcal { L } _ { o p p } ( \theta , G )$ encourages the graph embeddings $\phi _ { g c } ( G )$ and $\phi _ { g c } ( G _ { \theta } ^ { \prime } )$ to lie on the opposite sides of at least one LDB in $\mathcal { H } _ { G }$ . This further means that $G _ { \theta } ^ { \prime }$ is encouraged not to be covered by the decision region covering $G$ , thus the prediction on $G _ { \theta } ^ { \prime }$ can be changed significantly from the prediction on $G$ ：
+
+Similar to [45], we use a L1 regularization $\mathcal { R } _ { s p a r s e } ( \theta , G ) = \| \mathbf { M } \| _ { 1 }$ on the matrix $\mathbf { M }$ produced by $f _ { \theta }$ on an input graph $G$ to produce a sparse matrix M, such that only a small number of edges in $G$ are selected as the counterfactual explanation. We also follow [45] to use an entropy regularization
+
+$$
+\mathcal { R } _ { d i s c r e t e } ( \theta , G ) = - \frac { 1 } { | \mathbf { M } | } \sum _ { i , j } ( \mathbf { M } _ { i j } \log ( \mathbf { M } _ { i j } ) + ( 1 - \mathbf { M } _ { i j } ) \log ( 1 - \mathbf { M } _ { i j } ) )
+$$
+
+to push the value of each entry in $\mathbf { M } _ { i j }$ to be close to either Oor 1,such that $G _ { \theta }$ and $G _ { \theta } ^ { \prime }$ approximate $G _ { S }$ and $G _ { E \backslash S }$ well, respectively.
+
+Now we can use the graphs in $D$ and the extracted decision regions to train the neural network $f _ { \theta }$ in an end-to-end manner by minimizing $\mathcal { L } ( \boldsymbol { \theta } )$ over $\theta$ using back propagation. Once we finish training $f _ { \theta }$ , we can first apply $f _ { \theta }$ to produce the matrix $\mathbf { M }$ for an input graph $G = ( V , E )$ ,and then obtain the explanation $S$ by selecting all the edges in $E$ whose corresponding entries in $\mathbf { M }$ are larger than 0.5. We do not need the extracted boundaries for inference as the the decision logic of GNN is already distilled into the explanation network $f$ during the training.
+
+As discussed in Appendix B,our method can be easily extended to generate robust counterfactual explanations for node classification tasks.
+
+Our method is highly efficient with a time complexity $O ( | E | )$ for explaining the prediction on an input graph $G$ , where $| E |$ is the total number of edges in $G$ : Additionally, the neural network $f _ { \theta }$ can be directly used without retraining to predict explanations on unseen graphs. Thus our method is significantly faster than the other methods [45,32,47,38] that require retraining each time when generating explanations on a new input graph.
+
+# 5Experiments
+
+We conduct series of experiments to compare our method with the state-of-the-art methods including GNNExplainer [45],PGExplainer [25],PGM-Explainer [38], SubgraphX [47] and CFGNNExplainer [24]. For the methods that identify a set of vertices as an explanation, we use the set of vertices to induce a subgraph from the input graph,and then use the set of edges of the induced subgraph as the explanation. For the methods that identify a subgraph as an explanation, we directly use the set of edges of the identified subgraph as the explanation.
+
+![](images/b7fd56d0939a4af57dc11439ffc5d8bfba231262c91ca025fc019f5b6e33dc49.jpg)  
+Figure 1: Fidelity performance averaged across 10 runs for the datasets at different levels of sparsity.
+
+To demonstrate the effectiveness of the decision regions,we derive another baseline method named RCExp-NoLDB that adopts the general framework of RCExplainer but does not use the LDBs of decision regions to generate explanations.Instead, RCExp-NoLDB directly maximizes the prediction confidence on class $c$ for $G _ { \theta }$ and minimizes the prediction confidence of class $c$ for $G _ { \theta } ^ { \prime }$ ：
+
+We evaluate the explanation performance on two typical tasks: the graph clasification task that uses a GNN to predict the class of an input graph,and the node classification task that uses a GNN to predict the class of a graph node. For the graph classification task, we use one synthetic dataset, BA-2motifs [25],and two real-world datasets,Mutagenicity [21] and NCI1 [39].For the node classification task, we use the same four synthetic datasets as used by GNNExplainer [45], namely, BA-SHAPES,BA-COMMUNITY,TREE-CYCLES and TREE-GRID.
+
+Limited by space, we only report here the key results_on the graph classification task for fidelity, robustness and efficiency. Please refer to Appendix E for details on datasets, baselines and the experiment setups.Detailed experimental comparison on the node classification task willbe discussed in Appendix F where we show that our method produces extremely accurate explanations. The code3 is publicly available.
+
+# 5.1Fidelity
+
+Fidelity is measured by the decrease of prediction confidence after removing the explanation (i.e., a set of edges) from the input graph [32]. We use fidelity to evaluate how counterfactual the generated explanations are on the datasets Mutagenicity,NCI1 and BA-2motifs.A large fidelity score indicates stronger counterfactual characteristics. It is important to note that fidelity may be sensitive to sparsity of explanations. The sparsity of an explanation $S$ with respect to an input graph $G = ( \bar { V , } E )$ is $\begin{array} { r } { s p a r s i t y ( S , G ) = 1 - \frac { | S | } { | E | } } \end{array}$ ,thatis,tpeeefdgafrta from $G$ . We only compare explanations with the same level of sparsity.
+
+Figure 1 shows the results about fidelity. Our approach achieves the best fidelity performance at all levels of sparsity. The results validate the effectiveness of our method in producing highly counterfactual explanations. RCExplainer also significantly outperforms RCExp-NoLDB. This confirms that using LDBs of decision regions extracted from GNNs produces more faithful counterfactual explanations.
+
+CF-GNNExplainer performs the best among the rest of the methods.This is expected as it optimizes the counterfactual behavior of the explanations which results in higher fidelity for the explanations in comparison to those produced by other methods such as GNNExplainer and PGExplainer.
+
+The fidelity performance of SubgraphX reported in [47] was obtained by seting the features of nodes that are part of the explanation to Obut not removing the explanation edges from the input graph. This does not remove the message passing roles of the explanation nodes from the input graph because the edges connected to those nodes still can pass messages. In our experiments, we directly block the messages that are passed on the edges in the explanation, which completely prevents the explanation nodes in the input graph to participate in the message passing. As a result, the performance of SubgraphX drops significantly.
+
+![](images/1aa166e7cf33380e4add83effc9273d8301d54224aa1859e6e8d4478bf17806a.jpg)  
+Figure 2: Noise robustness (AUC) averaged across 10 runs for the datasets at diferent levels of noise.
+
+# 5.2Robustness Performance
+
+In this experiment, we evaluate the robustness of all methods by quantifying how much an explanation changes after adding noise to the input graph. For an input graph $G$ and the explanation $S$ ,we produce a perturbed graph $G ^ { \prime }$ by adding random noise to the node features and randomly adding or deleting some edges of the input graph such that the prediction on $G ^ { \prime }$ is consistent with the prediction on $G$ ： Using the same method we obtain the explanation $S ^ { \prime }$ on $G ^ { \prime }$ . Considering top- $k$ edges of $S$ as the ground-truth and comparing $S ^ { \prime }$ against them, we compute a receiver operating characteristic (ROC) curve and evaluate the robustnessby the area under curve (AUC) of the ROC curve. We report results for $k = 8$ in Figure 2. Results for other values of $k$ are included in Appendix F where we observe similar trend.
+
+Figure 2 shows the AUC of GNNExplainer, PGExplainer, RCExp-NoLDB and RCExplainer at different levels of noise. A higher AUC indicates better robustness. The percentage of noise shows the proportion of nodes and edges that are modified. Baselines such as PGM-Explainer and SubgraphX are not included in this experiment as they do not output the edge weights that are required for computing AUC.We present additional robustness experiments in Appendix F where we extend all the baselines to report node and edge level accuracy.
+
+GNNExplainer performs the worst on most of the datasets,since it optimizes each graph independently without considering other graphs in the training set. Even when no noise is added,the AUC of GNNExplainer is significantly lower than 1 because different runs produce different explanations for the same graph prediction. PGExplainer is generally more robust than GNNExplainer because the neural network they trained to produce explanations implicitly considers all the graphs used for training. CF-GNNExplainer also performs worse than RCExplainer, which means it is more susceptible to the noise as compared to RCExplainer.
+
+Our method achieves the best AUC on allthe datasets, because the common decision logic carried by the decision regions of a GNN is highly robust to noise. PGExplainer achieves a comparable performance as our method on the Mutagenicity dataset, because the samples of this dataset share a lot of common structures such as carbon rings, which makes it easier for the neural network trained by PGExplainer to identify these structures in presence of noise. However, for BA-2motifs and NCI1, this is harder as samples share very few structures and thus the AUC of PGExplainer drops significantly. RCExplainer also significantly outperforms RCExp-NoLDB on these datasets which highlights the role of decision boundaries in making our method highly robust.
+
+Table 1: Average time cost for producing an explanation on a single graph sample.   
+
+<table><tr><td>Method</td><td>GNNExplainer</td><td>PGExplainer</td><td>PGM-Explainer</td><td>SubgraphX</td><td>CF-GNNExplainer</td><td>RCExplainer</td></tr><tr><td>Time</td><td>1.2s ± 0.2</td><td>0.01s ± 0.03</td><td>13.1s ± 3.9</td><td>77.8s ± 4.5</td><td>4.6s± 0.2</td><td>0.01s ± 0.02</td></tr></table>
+
+Effciency. We evaluate efficiency by comparing the average computation time taken for inference on unseen graph samples. Table 1 shows the results on the Mutagenicity dataset. Since our method also can be directly used for unseen data without any retraining,it is as eficient as PGExplainer and significantly faster than GNNExplainer, PGM-Explainer, SubgraphX and CF-GNNExplainer.
+
+# 6Conclusion
+
+In this paper, we develop a novel method for producing counterfactual explanations on GNNs. We extract decision boundaries from the given GNN model to formulate an intuitive and effective counterfactual loss function. We optimize this loss to train a neural network to produce explanations with strong counterfactual characteristics. Since the decision boundaries are shared by multiple samples of the same predicted class, explanations produced by our method are robust and do not overfit the noise. Our experiments on synthetic and real-life benchmark datasets strongly validate the efficacy of our method. In this work,we focus on GNNs that belong to Piecewise Linear Neural Networks (PLNNs). Extending our method to other families of GNNs and tasks such as link prediction,remains an interesting future direction.
+
+Our method will benefit multiple fields where GNNs are intensively used. By allowing the users to interpret the predictions of complex GNNs better, it will promote transparency, trust and fairness in the society. However, there also exist some inherent risks. A generated explanation may expose private information if our method is not coupled with an adequate privacy protection technique. Also, some of the ideas presented in this paper may be adopted and extended to improve adversarial attacks. Without appropriate defense mechanisms,the misuse of such attcks poses a risk of disruption in the functionality of GNNs deployed in the real world.That said, we firmly believe that these risks can be mitigated through increased awareness and proactive measures.
+
+# Acknowledgments and Disclosure of Funding
+
+Lingyang Chu's research is supported in part by the startup grant provided by the Department of Computing and Software of McMaster University. All opinions, findings,conclusions,and recommendations in this paper are those of the authors and do not necessarily reflect the views of the funding agencies.
+
+# References
+
+[1] J. Adebayo,J. Gilmer,M.Muelly,I. Goodfellow,M. Hardt,and B. Kim. Sanity checks for saliency maps. In Advances in Neural Information Processing Systems.   
+[2] A.Bojchevski and S. Gunnemann. Certifiable robustness to graph perturbations.arXiv preprint arXiv:1910.14356,2019.   
+[3]E. Cho,S.A. Myers,and J.Leskovec.Friendship and mobility: user movement in location-based social networks. In Proceedings of the 17th ACM SIGkDD international conference on Knowledge discovery and data mining,pages 1082-1090,2011.   
+[4]L.Chu, X. Hu,J. Hu,L. Wang,and J.Pei. Exact and consistent interpretation for piecewise linear neural networks: A closed form solution. In Proceedings of the 24th ACM SiGKDD International Conference on Knowledge Discovery & Data Mining,pages 1244-1253,2018.   
+[5]V. Crawford,A. Kuhnle,and M. Thai. Submodular cost submodular cover with an approximate oracle.In International Conference on Machine Learning, pages 1426-1435.PMLR,2019.   
+[6] A. K. Debnath, R.L.Lopez de Compadre, G. Debnath, A. J. Shusterman,and C. Hansch. Structure-activity relationship of mutagenic aromatic and heteroaromatic nitro compounds.correlation with molecular orbital energies and hydrophobicity. Journal of medicinal chemistry,34(2):786-797,1991.   
+[7]M.Denil,S.G.Colmenarejo,S. Cabi,D.Saxton,and N. de Freitas. Programmable agents. arXiv preprint arXiv:1706.06383,2017.   
+[8]Y. Duan, M. Andrychowicz,B.C. Stadie,J. Ho,J.Schneider,I.Sutskever,P.Abbeel,and W. Zaremba. One-shot imitation learning. arXiv preprint arXiv:1703.07326,2017.   
+[9]W.Fan,Y.Ma,Q.Li,Y. He,E. Zhao,J.Tang,and D.Yin. Graph neural networks for social recommendation. In The World Wide Web Conference,pages 417-426,2019.   
+[10]T.Freiesleben.Counterfactualexplanations &adversarialexamplescommongrounds,essntialdifferences, and potential transfers. arXiv preprint arXiv:2009.05487, 2020.   
+[11]A. Ghorbani,A. Abid,and J. Zou. Interpretation of neural networks is fragile. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 3681-3688,2019.   
+[12] X. Glorot and Y. Bengio. Understanding the dificulty of training deep feedforward neural networks. InProceedingsofthethirteenth international conference onartificial intelligence and statistics,pages 249-256. JMLR Workshop and Conference Proceedings, 2010.   
+[13] X.Glorot,A.Bordes,and Y.Bengio.Deep sparse rectifier neural networks.In Proceedings ofthe fourteenth international conference on artificial intelligence and statistics, pages 315-323. JMLR Workshop and Conference Proceedings,2011.   
+[14] I. Goodfelow,D. Warde-Farley,M. Mirza,A. Courvile,and Y.Bengio. Maxout networks.In International conference on machine learning, pages 1319-1327.PMLR,2013.   
+[15]K. He, X. Zhang, S. Ren,and J. Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings ofthe IEEE international conferenceon computer vision, pages 1026-1034,2015.   
+[16] L.Holdijk,M. Boon,S.Henckens,and L.de Jong. [re] parameterized explainer for graph neural network. In ML Reproducibility Challenge 2020,2021.   
+[17] W. Huber, V.J. Carey,L.Long, S. Falcon,and R. Gentleman. Graphs in molecular biology. BMC bioinformatics,8(6):1-14,2007.   
+[18] R. K. Iyer and J. A. Bilmes. Submodular optimization with submodular cover and submodular knapsack constraints.In Advances in Neural Information Processing Systems.   
+[19]M. Jiang,Z. Li, S. Zhang,S. Wang,X. Wang, Q. Yuan,and Z. Wei. Drug-target affinity prediction using graph neural network and contact maps.RsC Advances,10(35):20701-20712, 2020.   
+[20] H. Jin and X. Zhang. Latent adversarial training of graph convolution networks. In ICML Workshop on Learning and Reasoning with Graph-Structured Representations,2019.   
+[21] J. Kazius,R. McGuire,and R. Bursi. Derivation and validation of toxicophores for mutagenicity prediction. Journal of medicinal chemistry,48(1):312-320,2005.   
+[22] T.N. Kipf and M. Welling. Semi-supervised classfication with graph convolutional networks. In 5th International Conference on Learning Representations,ICLR 2Ol7, Conference Track Proceedings.   
+[23]M. Liu, Y. Luo,L. Wang, Y. Xie, H. Yuan,S. Gui, H. Yu,Z. Xu, J. Zhang, Y. Liu, K. Yan, H. Liu, C. Fu, B. Oztekin,X. Zhang,and S.Ji. DIG: A turnkey library for diving into graph deep learning research. arXiv preprint arXiv:2103.12608,2021.   
+[24] A.Lucic,M.ter Hoeve,G. Tolomei,M.de Rijke,and F. Silvestri. Cf-gnnexplainer: Counterfactual explanations for graph neural networks.arXiv preprint arXiv:2102.03322,2021.   
+[25] D.Luo, W. Cheng,D. Xu, W. Yu, B. Zong, H. Chen,and X. Zhang. Parameterized explainer for graph neural network. In Advances in Neural Information Processing Systems.   
+[26] C. Molnar.Interpretable Machine Learning.2019.https://christophm.github.io/ interpretable-ml-book/.   
+[27] G.Montufar,R.Pascanu,K.Cho,and Y.Bengio.On the numberof linear regions of deep neural networks. arXiv preprint arXiv:1402.1869,2014.   
+[28]R.Moraffah,M. Karami,R.Guo,A. Raglin,and H.Liu.Causal interpretability for machine learningproblems,methods and evaluation. ACM SIGKDD Explorations Newsleter,22(1):18-33,2020.   
+[29] V.Nair and G.E.Hinton.Rectified linear units improve restricted boltzmann machines.In Icml,2010.   
+[30] D. Numeroso and D. Bacciu. Meg: Generating molecular counterfactual explanations for deep graph networks. arXiv preprint arXiv:2104.08060,2021.   
+[31] D.E. Pires,T. L. Blundel, and D. B. Ascher. pkcsm: predicting small-molecule pharmacokinetic and toxicity properties using graph-based signatures. Journal of medicinal chemistry,58(9):4066-4072,2015.   
+[32]P.E.Pope,S. Kolouri, M.Rostami, C.E. Martin,and H. Hoffmann.Explainability methods for graph convolutional neural networks.In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10772-10781,2019.   
+[33]R.R.Selvaraju,M.Cogswell,A.Das,R. Vedantam,D.Parikh,and D.Batra. Grad-cam: Visual explanations from deep networks via gradient-based localization. In Proceedings of the IEEE international conference on computer vision, pages 618-626, 2017.   
+[34] P.L. Simon, M.Taylor,and I. Z. Kiss. Exact epidemic models on graphs using graph-automorphism driven lumping. Journal of mathematical biology,62(4):479-508,2011.   
+[35] K. Simonyan, A. Vedaldi,and A. Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. ICLR,2014.   
+[36]K.Sokol and P.A.Flach. Counterfactual explanations of machine learning predictions: opportunities and challenges for ai safety. In SafeAI@ AAAI, 2019.   
+[37]P. Velickovic, G. Cucurul,A. Casanova,A. Romero,P.Lio,and Y. Bengio. Graph attention networks. In 6th International Conference on Learning Representations, ICLR 2O18, Conference Track Proceedings.   
+[38]M. Vu and M. T. Thai.Pgm-explainer: Probabilistic graphical model explanations for graph neural networks.In Advances in Neural Information Processing Systems.   
+[39] N. Wale and G. Karypis. Comparison of descriptor spaces for chemical compound retrieval and classification. In Sixth International Conference on Data Mining (ICDM'06),pages 678-689,2006.doi: 10.1109/ICDM.2006.39.   
+[40] L.A.Wolsey. An analysis of the greedy algorithm for the submodular setcovering problem. Combinatorica, 2(4):385-393,1982.   
+[41] J. Xiong,Z. Xiong, K. Chen,H. Jiang,and M. Zheng. Graph neural networks for automated de novo drug design. Drug Discovery Today,2021.   
+[42]H. Xu, Y. Ma, H.-C.Liu,D. Deb, H. Liu, J.-L. Tang,and A. K. Jain. Adversarial atacks and defenses in images, graphs and text: A review. International Journal of Automation and Computing,17(2):151-178, 2020.   
+[43] K. Xu, H. Chen,S.Liu,P.-Y. Chen, T.-W. Weng,M. Hong,and X. Lin. Topology attack and defense for graph neural networks: An optimization perspective. arXiv preprint arXiv:1906.04214, 2019.   
+[44] R. Yin,K.Li, G. Zhang,and J.Lu. A deeper graph neural network for recommender systems. KnowledgeBased Systems,185:105020,2019.   
+[45] Z. Ying,D. Bourgeois, J. You, M. Zitnik,and J.Leskovec. Gnnexplainer: Generating explanations for graph neural networks. In Advances in Neural Information Processing Systems, volume 32, 2019.   
+[46] H.Yuan,J.Tang,X.Hu,and S.Ji. Xgnn: Towards model-level explanations of graph neural networks.In Proceedings ofthe 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 430-438,2020.   
+[47] H. Yuan, H. Yu, J. Wang, K. Li, and S.Ji._On explainability of graph neural networks via subgraph explorations. arXiv preprint arXiv:2102.05152,2021.   
+[48] M.D. Zeiler and R.Fergus. Visualizing and understanding convolutional networks. In European conference on computer vision, pages 818-833. Springer,2014.   
+[49] J. Zhang,S.A. Bargal,Z.Lin,J.Brandt,X. Shen,and S.Sclarof. Top-down neural attention by excitation backprop. International Journal of Computer Vision,126(10):1084-1102,2018.   
+[50] M. Zhang and Y. Chen. Link prediction based on graph neural networks. In Advances in Neural Information Processing Systems.   
+[51] D. Zugner and S. Gunnemann. Adversarial attacks on graph neural networks via meta learning. arXiv preprint arXiv:1902.08412, 2019.   
+[52] D.Zügner and S.Gunnemann.Certifable robustness and robust training for graph convolutional networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining,pages 246-256,2019.   
+[53] D. Zugner, A. Akbarnejad,and S. Gunnemann. Adversarial atacks on neural networks for graph data. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 2847-2856,2018.

parse/train/Uq_tGs7N54M/Uq_tGs7N54M_content_list.json

@@ -0,0 +1,1353 @@
+[
+    {
+        "type": "text",
+        "text": "Robust Counterfactual Explanations on Graph Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            215,
+            122,
+            782,
+            170
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mohit Bajaj1\\* Lingyang $\\mathbf { C h u ^ { 2 * } }$ Zi Yu Xue1,3Jian Pei4 Lanjun Wang1Peter Cho-Ho Lam1Yong Zhang1 ",
+        "text_level": 1,
+        "bbox": [
+            289,
+            218,
+            709,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Huawei Technologies Canada Co., Ltd. 2McMaster University 3 The University of British Columbia 4Simon Fraser University {mohit.bajaj1，zi.yu.xue，lanjun.wang，cho.ho.lam，yong.zhang3}@huawei.com chul9@mcmaster.ca,jpei@cs.sfu.ca ",
+        "bbox": [
+            214,
+            261,
+            784,
+            316
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            352,
+            535,
+            368
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Massive deployment of Graph Neural Networks (GNNs) in high-stake applications generates a strong demand for explanations that are robust to noise and align well with human intuition. Most existing methods generate explanations by identifying a subgraph of an input graph that has a strong correlation with the prediction. These explanations are not robust to noise because independently optimizing the correlation for a single input can easily overfit noise.Moreover, they are not counterfactual because removing an identified subgraph from an input graph does not necessarily change the prediction result. In this paper, we propose a novel method to generate robust counterfactual explanations on GNNs by explicitly modelling the common decision logic of GNNs on similar input graphs. Our explanations are naturally robust to noise because they are produced from the common decision boundaries of a GNN that govern the predictions of many similar input graphs. The explanations are also counterfactual because removing the set of edges identified by an explanation from the input graph changes the prediction significantly. Exhaustive experiments on many public datasets demonstrate the superior performance of our method. ",
+        "bbox": [
+            233,
+            382,
+            766,
+            593
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            617,
+            310,
+            633
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks (GNNs) [22,37,50] have achieved great practical successes in many realworld applications,such as chemistry [31],molecular biology[17],social networks [3] and epidemic modelling [34]. For most of these applications, explaining predictions made by a GNN model is crucial for establishing trust with end-users,identifying the cause of a prediction,and even discovering potential deficiencies of a GNN model before massive deployment. Ideally,an explanation should be able to answer questions like “Would the prediction of the GNN model change if a certain part of an input molecule is removed?” in the context of predicting whether an artificial molecule is active for acertain type of proteins [19,41],“Would an item recommended stillbe recommended if a customer had not purchased some other items in the past?” for a GNN built for recommendation systems [9, 44]. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            780
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Counterfactual explanations [28] in the form of “If X had not occurred, Y would not have occurred”[26] are the principled way to answer such questions and thus are highly desirable for GNNs. In the context of GNNs,a counterfactual explanation identifies a small subset of edges of the input graph instance such that removing those edges significantly changes the prediction made by the GNN. Counterfactual explanations are usually concise and easy to understand [28,36] because they align well with the human intuition to describe a causal situation [26]. To make explanations more trustworthy, the counterfactual explanation should be robust to noise,that is,some slight changes on an input graph do not change the explanation significantly. This idea aligns well with the notion of robustness discussed for DNN explanations in computer vision domain [11]. According to Ghorbani et al.[11] many interpretations on neural networks are fragile as it is easier to generate adversarial perturbations that produce perceptively indistinguishable inputs that are assigned the same predicted label,yet have very different interpretations.Here,the concepts of “fragile”“robustness”describe the same concept from opposite perspectives. An interpretation is said to be fragile if systematic perturbations can lead to dramatically different interpretations without changing the label. Otherwise, the interpretation is said to be robust. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            878
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            196
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "How to produce robust counterfactual explanations on predictions made by general graph neural networks is a novel problem that has not been systematically studied before.As to be discussed in Section 2, most GNN explanation methods [45,25,46,37,32] are neither counterfactual nor robust. These methods mostly focus on identifying a subgraph of an input graph that achieves a high correlation with the prediction result. Such explanations are usually not counterfactual because, due to the high non-convexity of GNNs, removing a subgraph that achieves a high correlation does not necessarily change the prediction result. Moreover, many existing methods [45,25,37,32] are not robust to noise and may change significantly upon slight modifications on input graphs, because the explanation of every single input graph prediction is independently optimized to maximize the correlation with the prediction, thus an explanation can easily overfit the noise in the data. ",
+        "bbox": [
+            174,
+            204,
+            825,
+            335
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper², we develop RCExplainer, a novel method to produce robust counterfactual explanations on GNNs. The key idea is to first model the common decision logic of a GNN by set of decision regions where each decision region governs the predictions on a large number of graphs,and then extract robust counterfactual explanations by a deep neural network that explores the decision logic carried by the linear decision boundaries of the decision regions. We make the following contributions. ",
+        "bbox": [
+            174,
+            343,
+            825,
+            409
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "First, we model the decision logic of a GNN by a set of decision regions, where each decision region is induced by a set of linear decision boundaries of the GNN. We propose an unsupervised method to find decision regions for each class such that each decision region governs the prediction of multiple graph samples predicted to be the same class. The linear decision boundaries of the decision region capture the common decision logic on all the graph instances inside the decision region, thus do not easily overfit the noise of an individual graph instance. By exploring the common decision logic encoded in the linear boundaries, we are able to produce counterfactual explanations that are inherently robust to noise. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            521
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Second, based on the linear boundaries of the decision region,we propose a novel loss function to train a neural network that produces a robust counterfactual explanation as a small subset of edges of an input graph. The loss function is designed to directly optimize the explainability and counterfactual property of the subset of edges,such that: 1) the subgraph induced by the edges lies within the decision region,thus has a prediction consistent with the input graph; and 2) deleting the subset of edges from the input graph produces a remainder subgraph that lies outside the decision region, thus the prediction on the remainder subgraph changes significantly. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            621
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Last, we conduct comprehensive experimental study to compare our method with the state-of-the-art methods on fidelity, robustness,accuracy and efficiency. All the results solidly demonstrate the superior performance of our approach. ",
+        "bbox": [
+            176,
+            626,
+            821,
+            666
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            685,
+            316,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The existing GNN explanation methods [46,37, 45,32, 25] generally fall into two categories: model level explanation [46] and instance level explanation [37,45,32, 25]. ",
+        "bbox": [
+            174,
+            715,
+            823,
+            743
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A model level explanation method [46] produces a high-level explanation about the general behaviors of a GNN independent from input examples. This may be achieved by synthesizing a set of artificial graph instances such that each artificial graph instance maximizes the prediction score on a certain class. The weakness of model level explanation methods is that an input graph instance may not contain an artificial graph instance,and removing an artificial graph from an input graph does not necessarily change the prediction. As a result, model level explanations are substantially different from counterfactual explanations, because the synthesized artificial graphs do not provide insights into how the GNN makes its prediction on a specific input graph instance. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            854
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The instance level explanation methods [37,45,32, 25] explain the prediction(s) made by a GNN on a specific input graph instance or multiple instances by identifying a subgraph of an input graph instance that achieves a high correlation with the prediction on the input graph. GNNExplainer [45] removes redundant edges from an input graph instance to produce an explanation that maximizes the mutual information between the distribution of subgraphs of the input graph and the GNN's prediction. Following the same idea by Ying et al. [45],PGExplainer [25] parameterizes the generation process of explanations by a deep neural network,and trains it to maximize a similar mutual information based loss used by GNNExplainer [45]. The trained deep neural network is then applied to generate explanations for a single input graph instance or a group of input graphs. MEG [30] incorporates strong domain knowledge in chemistry with a reinforcement learning framework to produce counterfactual explanations on GNNs specifically built for compound prediction, but the heavy reliance on domain knowledge largely limits its applicability on general GNNs. The recently proposed CF-GNNExplainer [24] independently optimizes the counterfactual property for each explanation but ignores the correlation between the prediction and the explanation. ",
+        "bbox": [
+            178,
+            861,
+            825,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            250
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Some studies [32,37] also adapt the existing explanation methods of image-oriented deep neural networks to produce instance level explanations for GNNs.Pope et al.[32] extend several gradient based methods [33,35,49] to explain predictions made by GNNs. The explanations are prone to gradient saturation[12] and may also be misleading [1] due to the heavy reliance on noisy gradients. Velickovic et al.[37] extend the atention mechanism[7,8] to identify the nodes in an input graph that contribute the most to the prediction.This method has to retrain the GNN with the altered architecture and the inserted attntion layers.Thus,the explanations may not be faithful to the original GNN. ",
+        "bbox": [
+            173,
+            256,
+            825,
+            349
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Instance level explanations from most of the methods are usually not counterfactual because, due to the non-convexity of GNNs, removing an explanation subgraph from the input graph does not necessarily change the prediction result. Moreover, those methods [45,25,37,32, 24] are usually not robust to noise because the explanation of every single input graph prediction is independently optimized. Thus,an explanation can easily overfit the noise inside input graphs and may change significantly upon slight modifications on input graphs. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            435
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To tackle the weaknesses in the existing methods, in this paper, we directly optimize the counterfactual property of an explanation along with the correlation between the explanation and the prediction. Our explanations are also much more robust to modifications on input graphs,because they are produced from the common decision logic on a large group of similar input graphs, which do not easily overfit the noise of an individual graph sample. ",
+        "bbox": [
+            174,
+            440,
+            825,
+            507
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Please note that our study is substantially different from adversarial attacks on GNNs.The adversarial attacking methods [51,53,42,43,20] use adversarial examples to change the predictions of GNNs but ignore the explainability of the generated adversarial examples [1O]. Thus, the adversarial examples generated by adversarial attcks may not explain the original prediction. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            566
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our method is substantially different from the above works because we focus on explaining the prediction by directly optimizing the counterfactual property of an explanation along with correlation of the explanation with the prediction. We also require that the explanation is generally valid for a large set of similar graph instances by extracting it from the common linear decision boundaries of a large decision region. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            640
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3Problem Formulation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            667,
+            387,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Denote by $G = \\{ V , E \\}$ a graph where $V = \\{ v _ { 1 } , v _ { 2 } , \\ldots , v _ { n } \\}$ is the set of $n$ nodes and $E \\subseteq V \\times V$ is the set of edges. The edge structure of a graph $G$ is described by an adjacency matrix $\\mathbf { A } \\in \\{ 0 , 1 \\} ^ { n \\times n }$ where ${ \\bf A } _ { i j } = 1$ if there is an edge between node $v _ { i }$ and $v _ { j }$ ; and ${ \\bf A } _ { i j } = 0$ otherwise. ",
+        "bbox": [
+            174,
+            704,
+            825,
+            747
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Denote by $\\phi$ a GNN model that maps a graph to a probability distribution over a set of classes denoted by $C$ . Let $D$ denote the set of graphs that are used to train the GNN model $\\phi$ .We focus on GNNs that adopt piecewise linear activation functions,such as MaxOut[14] and the family of ReLU[13,15,29]. ",
+        "bbox": [
+            176,
+            752,
+            823,
+            792
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The robust counterfactual explanation problem is defined as follows. ",
+        "bbox": [
+            174,
+            797,
+            620,
+            813
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 (Robust Counterfactual Explanation Problem) Given a GNN model $\\phi$ trained on a set of graphs $D$ ， for an input graph $G = \\{ V , E \\}$ , our goal is to explain why $G$ is predicted by the GNN model as $\\phi ( G )$ by identifying a small subset of edges $S \\subseteq E$ ,such that $( l )$ removing the set of edges in $S$ from $G$ that causes the maximum drop in the confidence of the original prediction; and (2) $S$ is stable and doesn't change when the edges and the feature representations of the nodes of $G$ are perturbed by random noise. ",
+        "bbox": [
+            174,
+            830,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the definition,the first requirement requires that the explanation $S$ is counterfactual, and the second requirement requires that the explanation is robust to noisy changes on the edges and nodes of $G$ ： ",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            137,
+            271,
+            154
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first introduce how to extract the common decision logic of a GNN on a large set of graphs with the same predicted class. This is achieved by a decision region induced by a set of linear decision boundaries of the GNN.Then, based on the linear boundaries of the decision region, we propose a novel lossfunction to train a neural network that produces robust counterfactual explanations.Last, we discuss the time complexity of our method when generating explanations. ",
+        "bbox": [
+            174,
+            167,
+            825,
+            234
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1Modelling Decision Regions ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            250,
+            405,
+            265
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following the routines of many deep neural network explanation methods [33, 48], we extract the decision region of a GNN in the $d$ -dimensional output space $\\mathbb { O } ^ { d }$ of the last convolution layer of the GNN. The features generated by the last convolution layer are more conceptually meaningful and more robust to noise than those raw features of input graphs,such as vertices and edges [52, 2]. Denote by $\\phi _ { g c }$ the mapping function realized by the graph convolution layers that maps an input graph $G$ to its graph embedding $\\phi _ { g c } ( G ) \\in \\mathbb { O } ^ { d }$ ,and by $\\phi _ { f c }$ the mapping function realized by the fully connected layers that maps the graph embedding $\\phi _ { g c } ( G )$ to a predicted distribution over the classes in $C$ . The overall prediction $\\phi ( { \\bar { G } } )$ made by the GNN can be writtn as $\\phi ( G ) = \\phi _ { f c } ( \\phi _ { g c } ( G ) )$ ",
+        "bbox": [
+            173,
+            275,
+            825,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For the GNNs that adopt piecewise linear activation functions for the hidden neurons, such as MaxOut [14] and the family of ReLU [13,15,29], the decision logic of $\\phi _ { f c }$ in the space $\\mathbb { O } ^ { d }$ is characterized by a piecewise linear decision boundary formed by connected pieces of decision hyperplanes in $\\mathbb { O } ^ { d }$ [1]. We call these hyperplanes linear decision boundaries (LDBs), and denote by $\\mathcal { H }$ the set of LDBs induced by $\\phi _ { f c }$ . The set of LDBs in $\\mathcal { H }$ partitions the space $\\mathbb { O } ^ { d }$ into a large number of convex polytopes. A convex polytope is formed by a subset of LDBs in $\\mathcal { H }$ . All the graphs whose graph embeddings are contained in the same convex polytope are predicted as the same class [4]. Therefore, the LDBs of a convex polytope encode the common decision logic of $\\phi _ { f c }$ on all the graphs whose graph embeddings lie within the convex polytope [4]. Here,a graph $G$ is covered by a convex polytope if the graph embedding $\\phi _ { g c } ( G )$ is contained in the convex polytope. ",
+        "bbox": [
+            173,
+            391,
+            825,
+            530
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Based on the above insight, we model the decision region for a set of graph instances as a convex polytope that satisfies the following two properties. First, the decision region should be induced by a subset of the LDBs in $\\mathcal { H }$ .In this way, when we extract counterfactual explanations from the LDBs, the explanations are loyal to the real decision logic_of the GNN. Second, the decision region should cover many graph instances in the training dataset $D$ ,and all the covered graphs should be predicted as the same class. In this way, the LDBs of the decision region capture the common decision logic on all the graphs covered by the decision region. Here, the requirement of covering a larger number of graphs ensures that the common decision logic is general,and thus it is lesslikely to overfit the noise of an individual graph instance. As a result, the counterfactual explanations extracted from the LDBs of the decision region are insensitive to slight changes in the input graphs. Our method can be easily generalized to incorporate prediction confidence in the coverage measure,such as considering the count of graphs weighted by prediction confidence. To keep our discusson simple, we do not pursue this detail further in the paper. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            707
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next, we illustrate how to extract a decision region satisfying the above two requirements. The key idea is to find a convex polytope covering a large set of graph instances in $D$ that are predicted as the same class $c \\in C$ ： ",
+        "bbox": [
+            174,
+            712,
+            825,
+            752
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Denote by $D _ { c } \\subseteq D$ the set of graphs in $D$ predicted as a class $c \\in C$ ,by $\\mathcal { P } \\subseteq \\mathcal { H }$ a set of LDBs that partition the space $\\mathbb { O } ^ { d }$ into a set of convex polytopes, and by $r ( \\mathcal { P } , c )$ the convex polytope induced by $\\mathcal { P }$ that covers the largest number of graphs in $D _ { c }$ . Denote by $g ( \\mathcal { P } , c )$ the number of graphs in $D _ { c }$ covered by $r ( \\mathcal { P } , c )$ ,and by $h ( \\mathcal { P } , c )$ the number of graphs in $D$ that are covered by $r ( \\mathcal { P } , \\bar { c } )$ but are not predicted as class $c$ . We extract a decision region covering a large set of graph instances in $D _ { c }$ by solving the following constrained optimization problem. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            839
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/199dfcc9238c4541a86b7079313a4ecb03e682dc957ef9622a8d982bbb04d186.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\mathcal { P } \\subseteq \\mathcal { H } } g ( \\mathcal { P } , c ) , \\mathrm { ~ s . t . ~ } h ( \\mathcal { P } , c ) = 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            845,
+            599,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This formulation realizes the two properties of decision regions because $\\mathcal { P } \\subseteq \\mathcal { H }$ ensures that the decision region is induced by a subset of LDBs in $\\mathcal { H }$ ,maximizing $g ( \\mathcal { P } , c )$ requires that $r ( \\mathcal { P } , c )$ covers ",
+        "bbox": [
+            173,
+            883,
+            823,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "a large number of graphs in $D _ { c }$ , and the constraint $h ( \\mathcal { P } , c ) = 0$ ensures that allthe graphs covered by $r ( \\mathcal { P } , c )$ are predicted as the same class $c$ ： ",
+        "bbox": [
+            173,
+            90,
+            823,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Once we find a solution $\\mathcal { P }$ to the above problem, the decision region $r ( \\mathcal { P } , c )$ can be easily obtained by first counting the number of graphs in $D _ { c }$ covered by each convex polytope induced by $\\mathcal { P }$ ,and then select the convex polytope that covers the largest number of graphs in $D _ { c }$ ： ",
+        "bbox": [
+            173,
+            125,
+            825,
+            165
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2Extracting Decision Regions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            180,
+            410,
+            195
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The optimization problem in Equation (1) is intractable for standard GNNs, mainly because it is impractical to compute $\\mathcal { H }$ , all the LDBs of a GNN. The number of LDBs in $\\mathcal { H }$ of a GNN is exponential with respect to the number of neurons in the worst case [27].To address this challenge,we substitute $\\mathcal { H }$ by a sample $\\tilde { \\mathcal { H } }$ of LDBs from $\\tilde { \\mathcal { H } }$ ： ",
+        "bbox": [
+            173,
+            205,
+            825,
+            261
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A LDB in the space $\\mathbb { O } ^ { d }$ can be written as $\\mathbf { w } ^ { \\top } \\mathbf { x } + b = 0$ ,where is $\\mathbf { x } \\in \\mathbb { O } ^ { d }$ is a variable, w is the basis term, and $b$ corresponds to the bias.Following [4], for any input graph $G$ ,a linear boundary can be sampled from $\\mathcal { H }$ by computing ",
+        "bbox": [
+            174,
+            267,
+            825,
+            310
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2dbc5d9de809bb0aacc312e490149627bcf7576859a17ad5d232a303bbbb6bf6.jpg",
+        "text": "$$\n\\mathbf { w } = \\frac { \\partial \\left( \\operatorname* { m a x } _ { 1 } ( \\phi _ { f c } ( \\alpha ) ) - \\operatorname* { m a x } _ { 2 } ( \\phi _ { f c } ( \\alpha ) ) \\right) } { \\partial \\alpha } | _ { \\alpha = \\phi _ { g c } ( G ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            315,
+            676,
+            348
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and ",
+        "bbox": [
+            173,
+            353,
+            200,
+            366
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/79c9953979154b44111c9874d086d71cda854549201b41bbe069b902cc4cfe90.jpg",
+        "text": "$$\nb = \\mathrm { m a x } _ { 1 } ( \\phi _ { f c } ( \\alpha ) ) - \\mathrm { m a x } _ { 2 } ( \\phi _ { f c } ( \\alpha ) ) - \\mathbf { w } ^ { T } { \\alpha } | _ { \\alpha = \\phi _ { g c } ( G ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            375,
+            686,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\operatorname* { m a x } _ { 1 } ( \\phi _ { f c } ( \\alpha ) ) )$ and $\\operatorname* { m a x } _ { 2 } \\bigl ( \\phi _ { f c } ( \\pmb { \\alpha } ) \\bigr )$ are the largest and the second largest values in the vector $\\phi _ { f c } ( \\alpha )$ ,respectively. Given an input graph $G$ ,Equations (2) and (3) identify one LDB from $\\mathcal { H }$ .Thus, we can sample a subset of input graphs uniformly from $D$ ,and use Equations (2) and (3) to derive a sample of LDBs as $\\tilde { \\mathcal { H } } \\subset \\mathcal { H }$ ： ",
+        "bbox": [
+            173,
+            400,
+            826,
+            457
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Now, we substitute $\\mathcal { H }$ in Equation (1) by $\\tilde { \\mathcal { H } }$ to produce the following problem. ",
+        "bbox": [
+            173,
+            463,
+            686,
+            479
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f52df860ca40a98e65cc25516b494f56cafd46c079811fa063e656225dbb0792.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\mathcal { P } \\subseteq \\tilde { \\mathcal { H } } } g ( \\mathcal { P } , c ) , \\mathrm { ~ s . t . ~ } h ( \\mathcal { P } , c ) \\leq \\delta ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            484,
+            599,
+            512
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\delta \\geq 0$ is a tolerance parameter to keep this problem feasible. The parameter $\\delta$ is required because substituting $\\mathcal { H }$ by $\\tilde { \\mathcal { H } }$ ignores the LDBs in $\\mathcal { H } \\backslash \\tilde { \\mathcal { H } }$ . Thus, the convex polytope $r ( \\mathcal { P } , c )$ induced by subset of boundaries in $\\tilde { \\mathcal { H } }$ may contain instances that are not predicted as class $c$ . We directly set $\\boldsymbol { \\delta } \\dot { = } \\boldsymbol { h } ( \\tilde { \\mathcal { H } } , \\boldsymbol { c } )$ , which is the smallest value of $\\delta$ that keeps the practical problem feasible. ",
+        "bbox": [
+            173,
+            517,
+            825,
+            580
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The problem in Equation (4) can be proven to be a Submodular Cost Submodular Cover (SCSC) problem [18] (see Appendix $\\mathbf { D }$ for proof) that is well known to be NP-hard [5]. We adopt a greedy boundary selection method to find a good solution to this problem [40]. Specifically, we initialize $\\mathcal { P }$ as an empty set,and then iteratively select a new boundary $h$ from $\\tilde { \\mathcal { H } }$ by ",
+        "bbox": [
+            173,
+            585,
+            825,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1f9f845a8a01b5db73f4894fc93b9fa1e911127e6b892e443b6edc0c7061df65.jpg",
+        "text": "$$\nh = \\arg \\operatorname* { m i n } _ { h \\in \\tilde { \\mathcal { H } } \\backslash \\mathcal { P } } \\frac { g ( \\mathcal { P } , c ) - g ( \\mathcal { P } \\cup \\{ h \\} , c ) + \\epsilon } { h ( \\mathcal { P } , c ) - h ( \\mathcal { P } \\cup \\{ h \\} , c ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            648,
+            638,
+            686
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $g ( \\mathcal { P } , c ) - g ( \\mathcal { P } \\cup \\{ h \\} , c )$ is the decrease of $g ( \\mathcal { P } , c )$ when adding $h$ into $\\mathcal { P }$ ,and $h ( \\mathcal { P } , c ) - h ( \\mathcal { P } \\cup$ $\\{ h \\} , c \\bar { ) }$ is the decrease of $h ( \\mathcal { P } , c )$ when adding $h$ into $\\mathcal { P }$ .Both $g ( \\mathcal { P } , c )$ and $h ( \\mathcal { P } , c )$ are non-increasing when adding $h \\in \\tilde { \\mathcal { H } }$ into $\\mathcal { P }$ because adding a new boundary $h$ may only exclude some graphs from the convex polytope $r ( \\mathcal { P } , c )$ ： ",
+        "bbox": [
+            173,
+            693,
+            825,
+            751
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, in each iteration,Equation (5) selects a boundary $h \\in \\tilde { \\mathcal { H } }$ such that adding $h$ into $\\mathcal { P }$ reduces $g ( \\mathcal { P } , c )$ the least and reduces $\\bar { h } ( \\mathcal { P } , c )$ the most. In this way,we can quickly reduce $h ( \\mathcal { P } , c )$ to be smaller than $\\delta$ without decreasing $g ( \\mathcal { P } , c )$ too much, which produces a good feasible solution to the practical problem.We add a small constant $\\epsilon$ to the numerator such that, when there are multiple candidates of $h$ that do not decrease $g ( \\mathcal { P } , c )$ , we can still select the $h$ that reduces $h ( \\mathcal { P } , c )$ the most. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            827
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We apply a peeling-off strategy to iteratively extract multiple decision regions.For each class $c \\in C$ we first solve the practical problem once to find a decision region $r ( \\mathcal { P } , c )$ , then we remove the graphs covered by $r ( \\mathcal { P } , \\bar { c } )$ from $D _ { c }$ . If there are remaining graphs predicted as the class $c$ , we continue finding the decision regions using the remaining graphs until all the graphs in $D _ { c }$ are removed. When all the graphs in $D _ { c }$ are removed for each class $c \\in C$ , we stop the iteration and return the set of decision regions we found. ",
+        "bbox": [
+            173,
+            830,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3Producing Explanations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            380,
+            106
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce how to use the LDBs of decision regions to train a neural network that produces a robust counterfactual explanation as a small subset of edges of an input graph. We form explanations as a subset of edges because GNNs make decisions by aggregating messages passed on edges. Using edges instead of vertices as explanations can provide beter insights on the decision logic of GNNs. ",
+        "bbox": [
+            173,
+            116,
+            825,
+            183
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3.1The Neural Network Model ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            196,
+            416,
+            212
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Denote by $f _ { \\theta }$ the neural network to generate a subset of edges of an input graph $G$ as the robust counterfactual explanation on the prediction $\\phi ( G )$ ： $\\theta$ represents the set of parameters of the neural network. For experiments, our explanation network $f$ consists of 2 fully connected layers with a ReLU activation and the hidden dimension of 64. ",
+        "bbox": [
+            173,
+            219,
+            825,
+            273
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For any two connected vertices $v _ { i }$ and $v _ { j }$ of $G$ ,denote by $\\mathbf { z } _ { i }$ and $\\mathbf { z } _ { j }$ the embeddings produced by the last convolution layer of the GNN for the two vertices, respectively. The neural network $f _ { \\theta }$ takes $\\mathbf { z } _ { i }$ and $\\mathbf { z } _ { j }$ as the input and outputs the probability for the edge between $v _ { i }$ and $v _ { j }$ to be part of the explanation. This can be written as ",
+        "bbox": [
+            173,
+            279,
+            825,
+            333
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dd0dc1b00ca37ef79ae9976d880a0ec02cf8d2aade732ccacacb9c981b208e29.jpg",
+        "text": "$$\n\\begin{array} { r } { { \\bf M } _ { i j } = f _ { \\theta } ( { \\bf z } _ { i } , { \\bf z } _ { j } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            342,
+            560,
+            359
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { M } _ { i j }$ denotes the probability that the edge between $v _ { i }$ and $v _ { j }$ is contained in the explanation. When there is no edge between $v _ { i }$ and $v _ { j }$ ,that is, ${ \\bf A } _ { i j } = 0$ ,we set $\\mathbf { \\check { M } } _ { i j } = 0$ ",
+        "bbox": [
+            169,
+            367,
+            825,
+            396
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For an input graph $G = \\{ V , E \\}$ with $n$ vertices and a trained neural network $f _ { \\boldsymbol { \\theta } } , \\mathbf { M }$ is an $n$ -by- $\\mathbf { \\nabla } \\cdot n$ matrix that carries the complete information to generate a robust counterfactual explanation as a subset of edges, denoted by $S \\subseteq E$ . Concretely,we obtain $S$ by selecting all the edges in $E$ whose corresponding entries in $\\mathbf { M }$ are larger than O.5. ",
+        "bbox": [
+            173,
+            400,
+            825,
+            455
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3.2Training Model $f _ { \\theta }$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            468,
+            352,
+            483
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For an input graph $G = ( V , E )$ , denote by $S \\subseteq E$ the subset of edges produced by $f _ { \\theta }$ to explain the prediction $\\phi ( G )$ ,our goal is to train a good model $f _ { \\theta }$ such that the prediction on the subgraph $G _ { S }$ induced by $S$ from $G$ is consistent with $\\phi ( G )$ ; and deleting the edges in $S$ from $G$ produces a remainder subgraph $G _ { E \\backslash S }$ such that the prediction on $G _ { E \\backslash S }$ changes significantly from ${ \\bar { \\phi } } ( G )$ ： ",
+        "bbox": [
+            174,
+            491,
+            825,
+            546
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since producing $S$ by $f _ { \\theta }$ is a discrete operation that is hard to incorporate in an end-to-end training process, we define two proxy graphs to approximate $G _ { S }$ and $G _ { E \\backslash S }$ ,respectively,such that the proxy graphs are determined by $\\theta$ through continuous functions that can be smoothly incorporated into an end-to-end training process. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            608
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The proxy graph of $G _ { S }$ , denoted by $G _ { \\theta }$ , is defined by regarding $\\mathbf { M }$ instead of $\\mathbf { A }$ as the adjacency matrix. That is, $G _ { \\theta }$ has exactly the same graph structure as $G$ , but the edge weights of $G _ { \\theta }$ is given by the entries in $\\mathbf { M }$ instead of $\\mathbf { A }$ .Here,the subscript $\\theta$ means $G _ { \\theta }$ is determined by $\\theta$ ",
+        "bbox": [
+            173,
+            613,
+            825,
+            655
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The proxy graph of $G _ { E \\backslash S }$ , denoted by $G _ { \\theta } ^ { \\prime }$ , also have the same graph structure as $G$ , but the edge weight between each pair of vertices $v _ { i }$ and $v _ { j }$ is defined as ",
+        "bbox": [
+            173,
+            660,
+            821,
+            688
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/afaae5efb14f27284c6a4b7446792ec5cf01118d4490a60597c99ebbd88ab0af.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { M } _ { i j } ^ { \\prime } = \\left\\{ { 1 - \\mathbf { M } _ { i j } \\quad \\mathrm { ~ i f ~ } \\mathbf { A } _ { i j } = 1 } \\atop { 0 } \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            694,
+            607,
+            731
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The edge weights of both $G _ { \\theta }$ and $G _ { \\theta } ^ { \\prime }$ are determined by $\\theta$ through continuous functions, thus we can smoothly incorporate $G _ { \\theta }$ and $G _ { \\theta } ^ { \\prime }$ into an end-to-end training framework. ",
+        "bbox": [
+            169,
+            743,
+            823,
+            772
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As discussed later in this section, we use a regularization term to force the value of each entry in $\\mathbf { M } _ { i j }$ to be close to eitherOor 1,such that $G _ { \\theta }$ and $\\operatorname { \\mathrm { \\Sigma } } _ { G _ { \\theta } ^ { \\prime } } ^ { G \\prime }$ better approximate $G _ { S }$ and $G _ { E \\backslash S }$ respectively. ",
+        "bbox": [
+            171,
+            777,
+            823,
+            805
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We formulate our loss function as ",
+        "bbox": [
+            174,
+            810,
+            397,
+            824
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cfc41b2d76850caa450e5da3d6381caaa5c3ed3056969b987fa0fd0bf367d283.jpg",
+        "text": "$$\n\\mathcal { L } ( \\theta ) = \\sum _ { G \\in D } \\left\\{ \\lambda \\mathcal { L } _ { s a m e } ( \\theta , G ) + ( 1 - \\lambda ) \\mathcal { L } _ { o p p } ( \\theta , G ) + \\beta \\mathcal { R } _ { s p a r s e } ( \\theta , G ) + \\mu \\mathcal { R } _ { d i s c r e t e } ( \\theta , G ) \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            184,
+            829,
+            790,
+            863
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda \\in [ 0 , 1 ]$ $\\beta \\geq 0$ and $\\mu \\geq 0$ are the hyperparameters controlling the importance of each term. The influence of these parameters is discussed in Appendix $\\mathbf { G }$ .The first term of our loss function requires that the prediction of the GNN on $G _ { \\theta }$ is consistent with the prediction on $G$ . Intuitively, this means that the edges with larger weights in $G _ { \\theta }$ dominate the prediction on $G$ .We formulate this term by requiring $G _ { \\theta }$ to be covered by the same decision region covering $G$ ： ",
+        "bbox": [
+            176,
+            871,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Denote by $\\mathcal { H } _ { G }$ the set of LDBs that induce the decision region covering $G$ ,and by $| \\mathcal { H } _ { G } |$ the number of LDBs in $\\mathcal { H } _ { G }$ . For the $i$ -th LDB $h _ { i } \\in \\mathcal { H } _ { G }$ , denote by $B _ { i } ( \\mathbf { x } ) = \\mathbf { w } _ { i } ^ { \\top } \\mathbf { x } + b _ { i }$ , where $\\mathbf { w } _ { i }$ and $b _ { i }$ are the basis and bias of $h _ { i }$ , respectively, and $\\mathbf { x } \\in \\mathbb { O } ^ { d }$ is a point in the space $\\mathbb { O } ^ { d }$ . The sign of $B _ { i } ( { \\bf x } )$ indicates whether a point $\\mathbf { x }$ lies on the positive side or the negative side of $h _ { i }$ , and the absolute value $| B _ { i } ( { \\bf x } ) |$ is proportional to the distance of a point $\\mathbf { x }$ from $h _ { i }$ . Denote by $\\sigma ( \\cdot )$ the standard sigmoid function, we formulate the first term of our loss function as ",
+        "bbox": [
+            173,
+            123,
+            825,
+            208
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5f3b7a1f439726d3306abd8a0a28ca52ec5b541263656487dafdb921adbdf0a2.jpg",
+        "text": "$$\n\\mathcal { L } _ { s a m e } ( \\theta , G ) = \\frac { 1 } { | \\mathcal { H } _ { G } | } \\sum _ { h _ { i } \\in \\mathcal { H } _ { G } } \\sigma \\left( - \\mathcal { B } _ { i } ( \\phi _ { g c } ( G ) ) * \\mathcal { B } _ { i } ( \\phi _ { g c } ( G _ { \\theta } ) ) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            212,
+            707,
+            251
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "such that minimizing $\\mathcal { L } _ { s a m e } ( \\theta , G )$ encourages the graph embeddings $\\phi _ { g c } ( G )$ and $\\phi _ { g c } ( G _ { \\theta } )$ to lie on the same side of every LDB in $\\mathcal { H } _ { G }$ . Thus, $G _ { \\theta }$ is encouraged to be covered by the same decision region covering $G$ ： ",
+        "bbox": [
+            174,
+            257,
+            825,
+            299
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The second term of our loss function optimizes the counterfactual property of the explanations by requiring the prediction on $G _ { \\theta } ^ { \\prime }$ to be significantly different from the prediction on $G$ . Intuitively, this means that the set of edges with larger weights in $G _ { \\theta }$ are good counterfactual explanations because reducing the weights of these edges significantly changes the prediction. Following the above intuition,we formulate the second term as ",
+        "bbox": [
+            173,
+            304,
+            825,
+            371
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4a6e9260c897b62607fd0281735b7c87296a87e988d8b6aacd13c47e8cb7d8c9.jpg",
+        "text": "$$\n\\mathcal { L } _ { o p p } ( \\theta , G ) = \\operatorname* { m i n } _ { h _ { i } \\in \\mathcal { H } _ { G } } \\sigma \\left( \\mathcal { B } _ { i } ( \\phi _ { g c } ( G ) ) * \\mathcal { B } _ { i } ( \\phi _ { g c } ( G _ { \\theta } ^ { \\prime } ) ) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            377,
+            674,
+            401
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "such that minimizing $\\mathcal { L } _ { o p p } ( \\theta , G )$ encourages the graph embeddings $\\phi _ { g c } ( G )$ and $\\phi _ { g c } ( G _ { \\theta } ^ { \\prime } )$ to lie on the opposite sides of at least one LDB in $\\mathcal { H } _ { G }$ . This further means that $G _ { \\theta } ^ { \\prime }$ is encouraged not to be covered by the decision region covering $G$ , thus the prediction on $G _ { \\theta } ^ { \\prime }$ can be changed significantly from the prediction on $G$ ： ",
+        "bbox": [
+            173,
+            409,
+            825,
+            463
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Similar to [45], we use a L1 regularization $\\mathcal { R } _ { s p a r s e } ( \\theta , G ) = \\| \\mathbf { M } \\| _ { 1 }$ on the matrix $\\mathbf { M }$ produced by $f _ { \\theta }$ on an input graph $G$ to produce a sparse matrix M, such that only a small number of edges in $G$ are selected as the counterfactual explanation. We also follow [45] to use an entropy regularization ",
+        "bbox": [
+            176,
+            468,
+            825,
+            510
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/92c85db5def2d86edeb67eb745a7f02fb8e21bbf2fd6168f0abe3416cc9d7222.jpg",
+        "text": "$$\n\\mathcal { R } _ { d i s c r e t e } ( \\theta , G ) = - \\frac { 1 } { | \\mathbf { M } | } \\sum _ { i , j } ( \\mathbf { M } _ { i j } \\log ( \\mathbf { M } _ { i j } ) + ( 1 - \\mathbf { M } _ { i j } ) \\log ( 1 - \\mathbf { M } _ { i j } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            515,
+            743,
+            554
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "to push the value of each entry in $\\mathbf { M } _ { i j }$ to be close to either Oor 1,such that $G _ { \\theta }$ and $G _ { \\theta } ^ { \\prime }$ approximate $G _ { S }$ and $G _ { E \\backslash S }$ well, respectively. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            590
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Now we can use the graphs in $D$ and the extracted decision regions to train the neural network $f _ { \\theta }$ in an end-to-end manner by minimizing $\\mathcal { L } ( \\boldsymbol { \\theta } )$ over $\\theta$ using back propagation. Once we finish training $f _ { \\theta }$ , we can first apply $f _ { \\theta }$ to produce the matrix $\\mathbf { M }$ for an input graph $G = ( V , E )$ ,and then obtain the explanation $S$ by selecting all the edges in $E$ whose corresponding entries in $\\mathbf { M }$ are larger than 0.5. We do not need the extracted boundaries for inference as the the decision logic of GNN is already distilled into the explanation network $f$ during the training. ",
+        "bbox": [
+            173,
+            595,
+            825,
+            676
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As discussed in Appendix B,our method can be easily extended to generate robust counterfactual explanations for node classification tasks. ",
+        "bbox": [
+            174,
+            681,
+            823,
+            709
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our method is highly efficient with a time complexity $O ( | E | )$ for explaining the prediction on an input graph $G$ , where $| E |$ is the total number of edges in $G$ : Additionally, the neural network $f _ { \\theta }$ can be directly used without retraining to predict explanations on unseen graphs. Thus our method is significantly faster than the other methods [45,32,47,38] that require retraining each time when generating explanations on a new input graph. ",
+        "bbox": [
+            174,
+            714,
+            825,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            800,
+            312,
+            818
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We conduct series of experiments to compare our method with the state-of-the-art methods including GNNExplainer [45],PGExplainer [25],PGM-Explainer [38], SubgraphX [47] and CFGNNExplainer [24]. For the methods that identify a set of vertices as an explanation, we use the set of vertices to induce a subgraph from the input graph,and then use the set of edges of the induced subgraph as the explanation. For the methods that identify a subgraph as an explanation, we directly use the set of edges of the identified subgraph as the explanation. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b7fd56d0939a4af57dc11439ffc5d8bfba231262c91ca025fc019f5b6e33dc49.jpg",
+        "image_caption": [
+            "Figure 1: Fidelity performance averaged across 10 runs for the datasets at different levels of sparsity. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            271,
+            88,
+            725,
+            195
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the effectiveness of the decision regions,we derive another baseline method named RCExp-NoLDB that adopts the general framework of RCExplainer but does not use the LDBs of decision regions to generate explanations.Instead, RCExp-NoLDB directly maximizes the prediction confidence on class $c$ for $G _ { \\theta }$ and minimizes the prediction confidence of class $c$ for $G _ { \\theta } ^ { \\prime }$ ： ",
+        "bbox": [
+            174,
+            263,
+            825,
+            318
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the explanation performance on two typical tasks: the graph clasification task that uses a GNN to predict the class of an input graph,and the node classification task that uses a GNN to predict the class of a graph node. For the graph classification task, we use one synthetic dataset, BA-2motifs [25],and two real-world datasets,Mutagenicity [21] and NCI1 [39].For the node classification task, we use the same four synthetic datasets as used by GNNExplainer [45], namely, BA-SHAPES,BA-COMMUNITY,TREE-CYCLES and TREE-GRID. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            404
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Limited by space, we only report here the key results_on the graph classification task for fidelity, robustness and efficiency. Please refer to Appendix E for details on datasets, baselines and the experiment setups.Detailed experimental comparison on the node classification task willbe discussed in Appendix F where we show that our method produces extremely accurate explanations. The code3 is publicly available. ",
+        "bbox": [
+            174,
+            410,
+            825,
+            478
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1Fidelity ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            506,
+            264,
+            520
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Fidelity is measured by the decrease of prediction confidence after removing the explanation (i.e., a set of edges) from the input graph [32]. We use fidelity to evaluate how counterfactual the generated explanations are on the datasets Mutagenicity,NCI1 and BA-2motifs.A large fidelity score indicates stronger counterfactual characteristics. It is important to note that fidelity may be sensitive to sparsity of explanations. The sparsity of an explanation $S$ with respect to an input graph $G = ( \\bar { V , } E )$ is $\\begin{array} { r } { s p a r s i t y ( S , G ) = 1 - \\frac { | S | } { | E | } } \\end{array}$ ,thatis,tpeeefdgafrta from $G$ . We only compare explanations with the same level of sparsity. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            636
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 shows the results about fidelity. Our approach achieves the best fidelity performance at all levels of sparsity. The results validate the effectiveness of our method in producing highly counterfactual explanations. RCExplainer also significantly outperforms RCExp-NoLDB. This confirms that using LDBs of decision regions extracted from GNNs produces more faithful counterfactual explanations. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            708
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "CF-GNNExplainer performs the best among the rest of the methods.This is expected as it optimizes the counterfactual behavior of the explanations which results in higher fidelity for the explanations in comparison to those produced by other methods such as GNNExplainer and PGExplainer. ",
+        "bbox": [
+            176,
+            714,
+            823,
+            755
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The fidelity performance of SubgraphX reported in [47] was obtained by seting the features of nodes that are part of the explanation to Obut not removing the explanation edges from the input graph. This does not remove the message passing roles of the explanation nodes from the input graph because the edges connected to those nodes still can pass messages. In our experiments, we directly block the messages that are passed on the edges in the explanation, which completely prevents the explanation nodes in the input graph to participate in the message passing. As a result, the performance of SubgraphX drops significantly. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            854
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1aa166e7cf33380e4add83effc9273d8301d54224aa1859e6e8d4478bf17806a.jpg",
+        "image_caption": [
+            "Figure 2: Noise robustness (AUC) averaged across 10 runs for the datasets at diferent levels of noise. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            272,
+            88,
+            725,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2Robustness Performance ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            247,
+            385,
+            261
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we evaluate the robustness of all methods by quantifying how much an explanation changes after adding noise to the input graph. For an input graph $G$ and the explanation $S$ ,we produce a perturbed graph $G ^ { \\prime }$ by adding random noise to the node features and randomly adding or deleting some edges of the input graph such that the prediction on $G ^ { \\prime }$ is consistent with the prediction on $G$ ： Using the same method we obtain the explanation $S ^ { \\prime }$ on $G ^ { \\prime }$ . Considering top- $k$ edges of $S$ as the ground-truth and comparing $S ^ { \\prime }$ against them, we compute a receiver operating characteristic (ROC) curve and evaluate the robustnessby the area under curve (AUC) of the ROC curve. We report results for $k = 8$ in Figure 2. Results for other values of $k$ are included in Appendix F where we observe similar trend. ",
+        "bbox": [
+            173,
+            271,
+            826,
+            391
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows the AUC of GNNExplainer, PGExplainer, RCExp-NoLDB and RCExplainer at different levels of noise. A higher AUC indicates better robustness. The percentage of noise shows the proportion of nodes and edges that are modified. Baselines such as PGM-Explainer and SubgraphX are not included in this experiment as they do not output the edge weights that are required for computing AUC.We present additional robustness experiments in Appendix F where we extend all the baselines to report node and edge level accuracy. ",
+        "bbox": [
+            173,
+            396,
+            825,
+            477
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "GNNExplainer performs the worst on most of the datasets,since it optimizes each graph independently without considering other graphs in the training set. Even when no noise is added,the AUC of GNNExplainer is significantly lower than 1 because different runs produce different explanations for the same graph prediction. PGExplainer is generally more robust than GNNExplainer because the neural network they trained to produce explanations implicitly considers all the graphs used for training. CF-GNNExplainer also performs worse than RCExplainer, which means it is more susceptible to the noise as compared to RCExplainer. ",
+        "bbox": [
+            173,
+            483,
+            825,
+            575
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our method achieves the best AUC on allthe datasets, because the common decision logic carried by the decision regions of a GNN is highly robust to noise. PGExplainer achieves a comparable performance as our method on the Mutagenicity dataset, because the samples of this dataset share a lot of common structures such as carbon rings, which makes it easier for the neural network trained by PGExplainer to identify these structures in presence of noise. However, for BA-2motifs and NCI1, this is harder as samples share very few structures and thus the AUC of PGExplainer drops significantly. RCExplainer also significantly outperforms RCExp-NoLDB on these datasets which highlights the role of decision boundaries in making our method highly robust. ",
+        "bbox": [
+            173,
+            582,
+            825,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/747a5f1226941eaba594797ad5d8f60f7224157469cea7e8953b63d2c1a53516.jpg",
+        "table_caption": [
+            "Table 1: Average time cost for producing an explanation on a single graph sample. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>GNNExplainer</td><td>PGExplainer</td><td>PGM-Explainer</td><td>SubgraphX</td><td>CF-GNNExplainer</td><td>RCExplainer</td></tr><tr><td>Time</td><td>1.2s ± 0.2</td><td>0.01s ± 0.03</td><td>13.1s ± 3.9</td><td>77.8s ± 4.5</td><td>4.6s± 0.2</td><td>0.01s ± 0.02</td></tr></table>",
+        "bbox": [
+            173,
+            702,
+            823,
+            739
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effciency. We evaluate efficiency by comparing the average computation time taken for inference on unseen graph samples. Table 1 shows the results on the Mutagenicity dataset. Since our method also can be directly used for unseen data without any retraining,it is as eficient as PGExplainer and significantly faster than GNNExplainer, PGM-Explainer, SubgraphX and CF-GNNExplainer. ",
+        "bbox": [
+            173,
+            781,
+            825,
+            835
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            853,
+            299,
+            869
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we develop a novel method for producing counterfactual explanations on GNNs. We extract decision boundaries from the given GNN model to formulate an intuitive and effective counterfactual loss function. We optimize this loss to train a neural network to produce explanations with strong counterfactual characteristics. Since the decision boundaries are shared by multiple samples of the same predicted class, explanations produced by our method are robust and do not overfit the noise. Our experiments on synthetic and real-life benchmark datasets strongly validate the efficacy of our method. In this work,we focus on GNNs that belong to Piecewise Linear Neural Networks (PLNNs). Extending our method to other families of GNNs and tasks such as link prediction,remains an interesting future direction. ",
+        "bbox": [
+            173,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our method will benefit multiple fields where GNNs are intensively used. By allowing the users to interpret the predictions of complex GNNs better, it will promote transparency, trust and fairness in the society. However, there also exist some inherent risks. A generated explanation may expose private information if our method is not coupled with an adequate privacy protection technique. Also, some of the ideas presented in this paper may be adopted and extended to improve adversarial attacks. Without appropriate defense mechanisms,the misuse of such attcks poses a risk of disruption in the functionality of GNNs deployed in the real world.That said, we firmly believe that these risks can be mitigated through increased awareness and proactive measures. ",
+        "bbox": [
+            173,
+            190,
+            825,
+            296
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            315,
+            553,
+            333
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lingyang Chu's research is supported in part by the startup grant provided by the Department of Computing and Software of McMaster University. All opinions, findings,conclusions,and recommendations in this paper are those of the authors and do not necessarily reflect the views of the funding agencies. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            420,
+            266,
+            435
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] J. Adebayo,J. Gilmer,M.Muelly,I. Goodfellow,M. Hardt,and B. Kim. Sanity checks for saliency maps. In Advances in Neural Information Processing Systems.   \n[2] A.Bojchevski and S. Gunnemann. Certifiable robustness to graph perturbations.arXiv preprint arXiv:1910.14356,2019.   \n[3]E. Cho,S.A. Myers,and J.Leskovec.Friendship and mobility: user movement in location-based social networks. In Proceedings of the 17th ACM SIGkDD international conference on Knowledge discovery and data mining,pages 1082-1090,2011.   \n[4]L.Chu, X. Hu,J. Hu,L. Wang,and J.Pei. Exact and consistent interpretation for piecewise linear neural networks: A closed form solution. In Proceedings of the 24th ACM SiGKDD International Conference on Knowledge Discovery & Data Mining,pages 1244-1253,2018.   \n[5]V. Crawford,A. Kuhnle,and M. Thai. Submodular cost submodular cover with an approximate oracle.In International Conference on Machine Learning, pages 1426-1435.PMLR,2019.   \n[6] A. K. Debnath, R.L.Lopez de Compadre, G. Debnath, A. J. Shusterman,and C. Hansch. Structure-activity relationship of mutagenic aromatic and heteroaromatic nitro compounds.correlation with molecular orbital energies and hydrophobicity. Journal of medicinal chemistry,34(2):786-797,1991.   \n[7]M.Denil,S.G.Colmenarejo,S. Cabi,D.Saxton,and N. de Freitas. Programmable agents. arXiv preprint arXiv:1706.06383,2017.   \n[8]Y. Duan, M. Andrychowicz,B.C. Stadie,J. Ho,J.Schneider,I.Sutskever,P.Abbeel,and W. Zaremba. One-shot imitation learning. arXiv preprint arXiv:1703.07326,2017.   \n[9]W.Fan,Y.Ma,Q.Li,Y. He,E. Zhao,J.Tang,and D.Yin. Graph neural networks for social recommendation. In The World Wide Web Conference,pages 417-426,2019.   \n[10]T.Freiesleben.Counterfactualexplanations &adversarialexamplescommongrounds,essntialdifferences, and potential transfers. arXiv preprint arXiv:2009.05487, 2020.   \n[11]A. Ghorbani,A. Abid,and J. Zou. Interpretation of neural networks is fragile. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 3681-3688,2019.   \n[12] X. Glorot and Y. Bengio. Understanding the dificulty of training deep feedforward neural networks. InProceedingsofthethirteenth international conference onartificial intelligence and statistics,pages 249-256. JMLR Workshop and Conference Proceedings, 2010.   \n[13] X.Glorot,A.Bordes,and Y.Bengio.Deep sparse rectifier neural networks.In Proceedings ofthe fourteenth international conference on artificial intelligence and statistics, pages 315-323. JMLR Workshop and Conference Proceedings,2011.   \n[14] I. Goodfelow,D. Warde-Farley,M. Mirza,A. Courvile,and Y.Bengio. Maxout networks.In International conference on machine learning, pages 1319-1327.PMLR,2013.   \n[15]K. He, X. Zhang, S. Ren,and J. Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings ofthe IEEE international conferenceon computer vision, pages 1026-1034,2015.   \n[16] L.Holdijk,M. Boon,S.Henckens,and L.de Jong. [re] parameterized explainer for graph neural network. In ML Reproducibility Challenge 2020,2021.   \n[17] W. Huber, V.J. Carey,L.Long, S. Falcon,and R. Gentleman. Graphs in molecular biology. BMC bioinformatics,8(6):1-14,2007.   \n[18] R. K. Iyer and J. A. Bilmes. Submodular optimization with submodular cover and submodular knapsack constraints.In Advances in Neural Information Processing Systems.   \n[19]M. Jiang,Z. Li, S. Zhang,S. Wang,X. Wang, Q. Yuan,and Z. Wei. Drug-target affinity prediction using graph neural network and contact maps.RsC Advances,10(35):20701-20712, 2020.   \n[20] H. Jin and X. Zhang. Latent adversarial training of graph convolution networks. In ICML Workshop on Learning and Reasoning with Graph-Structured Representations,2019.   \n[21] J. Kazius,R. McGuire,and R. Bursi. Derivation and validation of toxicophores for mutagenicity prediction. Journal of medicinal chemistry,48(1):312-320,2005.   \n[22] T.N. Kipf and M. Welling. Semi-supervised classfication with graph convolutional networks. In 5th International Conference on Learning Representations,ICLR 2Ol7, Conference Track Proceedings.   \n[23]M. Liu, Y. Luo,L. Wang, Y. Xie, H. Yuan,S. Gui, H. Yu,Z. Xu, J. Zhang, Y. Liu, K. Yan, H. Liu, C. Fu, B. Oztekin,X. Zhang,and S.Ji. DIG: A turnkey library for diving into graph deep learning research. arXiv preprint arXiv:2103.12608,2021.   \n[24] A.Lucic,M.ter Hoeve,G. Tolomei,M.de Rijke,and F. Silvestri. Cf-gnnexplainer: Counterfactual explanations for graph neural networks.arXiv preprint arXiv:2102.03322,2021.   \n[25] D.Luo, W. Cheng,D. Xu, W. Yu, B. Zong, H. Chen,and X. Zhang. Parameterized explainer for graph neural network. In Advances in Neural Information Processing Systems.   \n[26] C. Molnar.Interpretable Machine Learning.2019.https://christophm.github.io/ interpretable-ml-book/.   \n[27] G.Montufar,R.Pascanu,K.Cho,and Y.Bengio.On the numberof linear regions of deep neural networks. arXiv preprint arXiv:1402.1869,2014.   \n[28]R.Moraffah,M. Karami,R.Guo,A. Raglin,and H.Liu.Causal interpretability for machine learningproblems,methods and evaluation. ACM SIGKDD Explorations Newsleter,22(1):18-33,2020.   \n[29] V.Nair and G.E.Hinton.Rectified linear units improve restricted boltzmann machines.In Icml,2010.   \n[30] D. Numeroso and D. Bacciu. Meg: Generating molecular counterfactual explanations for deep graph networks. arXiv preprint arXiv:2104.08060,2021.   \n[31] D.E. Pires,T. L. Blundel, and D. B. Ascher. pkcsm: predicting small-molecule pharmacokinetic and toxicity properties using graph-based signatures. Journal of medicinal chemistry,58(9):4066-4072,2015.   \n[32]P.E.Pope,S. Kolouri, M.Rostami, C.E. Martin,and H. Hoffmann.Explainability methods for graph convolutional neural networks.In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10772-10781,2019.   \n[33]R.R.Selvaraju,M.Cogswell,A.Das,R. Vedantam,D.Parikh,and D.Batra. Grad-cam: Visual explanations from deep networks via gradient-based localization. In Proceedings of the IEEE international conference on computer vision, pages 618-626, 2017.   \n[34] P.L. Simon, M.Taylor,and I. Z. Kiss. Exact epidemic models on graphs using graph-automorphism driven lumping. Journal of mathematical biology,62(4):479-508,2011.   \n[35] K. Simonyan, A. Vedaldi,and A. Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. ICLR,2014.   \n[36]K.Sokol and P.A.Flach. Counterfactual explanations of machine learning predictions: opportunities and challenges for ai safety. In SafeAI@ AAAI, 2019.   \n[37]P. Velickovic, G. Cucurul,A. Casanova,A. Romero,P.Lio,and Y. Bengio. Graph attention networks. In 6th International Conference on Learning Representations, ICLR 2O18, Conference Track Proceedings.   \n[38]M. Vu and M. T. Thai.Pgm-explainer: Probabilistic graphical model explanations for graph neural networks.In Advances in Neural Information Processing Systems.   \n[39] N. Wale and G. Karypis. Comparison of descriptor spaces for chemical compound retrieval and classification. In Sixth International Conference on Data Mining (ICDM'06),pages 678-689,2006.doi: 10.1109/ICDM.2006.39.   \n[40] L.A.Wolsey. An analysis of the greedy algorithm for the submodular setcovering problem. Combinatorica, 2(4):385-393,1982.   \n[41] J. Xiong,Z. Xiong, K. Chen,H. Jiang,and M. Zheng. Graph neural networks for automated de novo drug design. Drug Discovery Today,2021.   \n[42]H. Xu, Y. Ma, H.-C.Liu,D. Deb, H. Liu, J.-L. Tang,and A. K. Jain. Adversarial atacks and defenses in images, graphs and text: A review. International Journal of Automation and Computing,17(2):151-178, 2020.   \n[43] K. Xu, H. Chen,S.Liu,P.-Y. Chen, T.-W. Weng,M. Hong,and X. Lin. Topology attack and defense for graph neural networks: An optimization perspective. arXiv preprint arXiv:1906.04214, 2019.   \n[44] R. Yin,K.Li, G. Zhang,and J.Lu. A deeper graph neural network for recommender systems. KnowledgeBased Systems,185:105020,2019.   \n[45] Z. Ying,D. Bourgeois, J. You, M. Zitnik,and J.Leskovec. Gnnexplainer: Generating explanations for graph neural networks. In Advances in Neural Information Processing Systems, volume 32, 2019.   \n[46] H.Yuan,J.Tang,X.Hu,and S.Ji. Xgnn: Towards model-level explanations of graph neural networks.In Proceedings ofthe 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 430-438,2020.   \n[47] H. Yuan, H. Yu, J. Wang, K. Li, and S.Ji._On explainability of graph neural networks via subgraph explorations. arXiv preprint arXiv:2102.05152,2021.   \n[48] M.D. Zeiler and R.Fergus. Visualizing and understanding convolutional networks. In European conference on computer vision, pages 818-833. Springer,2014.   \n[49] J. Zhang,S.A. Bargal,Z.Lin,J.Brandt,X. Shen,and S.Sclarof. Top-down neural attention by excitation backprop. International Journal of Computer Vision,126(10):1084-1102,2018.   \n[50] M. Zhang and Y. Chen. Link prediction based on graph neural networks. In Advances in Neural Information Processing Systems.   \n[51] D. Zugner and S. Gunnemann. Adversarial attacks on graph neural networks via meta learning. arXiv preprint arXiv:1902.08412, 2019.   \n[52] D.Zügner and S.Gunnemann.Certifable robustness and robust training for graph convolutional networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining,pages 246-256,2019.   \n[53] D. Zugner, A. Akbarnejad,and S. Gunnemann. Adversarial atacks on neural networks for graph data. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 2847-2856,2018. ",
+        "bbox": [
+            178,
+            438,
+            826,
+            912
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            83,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            828,
+            765
+        ],
+        "page_idx": 11
+    }
+]

parse/train/dV19Yyi1fS3/dV19Yyi1fS3.md

@@ -0,0 +1,496 @@
+# TRAINING WITH QUANTIZATION NOISE FOREXTREME MODEL COMPRESSION
+
+Pierre Stock ∗ † Facebook AI Research, Inria
+
+Angela Fan∗ Facebook AI Research, LORIA
+
+Benjamin Graham Facebook AI Research
+
+Edouard Grave Facebook AI Research
+
+Rémi Gribonval Inria
+
+Hervé Jégou Facebook AI Research
+
+Armand Joulin Facebook AI Research
+
+# ABSTRACT
+
+We tackle the problem of producing compact models, maximizing their accuracy for a given model size. A standard solution is to train networks with Quantization Aware Training (Jacob et al., 2018), where the weights are quantized during training and the gradients approximated with the Straight-Through Estimator (Bengio et al., 2013). In this paper, we extend this approach to work beyond int8 fixedpoint quantization with extreme compression methods where the approximations introduced by STE are severe, such as Product Quantization. Our proposal is to only quantize a different random subset of weights during each forward, allowing for unbiased gradients to flow through the other weights. Controlling the amount of noise and its form allows for extreme compression rates while maintaining the performance of the original model. As a result we establish new state-of-the-art compromises between accuracy and model size both in natural language processing and image classification. For example, applying our method to state-of-the-art Transformer and ConvNet architectures, we can achieve $8 2 . 5 \%$ accuracy on MNLI by compressing RoBERTa to $1 4 \mathbf { M B }$ and $8 0 . 0 \%$ top-1 accuracy on ImageNet by compressing an EfficientNet-B3 to $3 . 3 \mathrm { M B }$ . 1
+
+# 1 INTRODUCTION
+
+Many of the best performing neural network architectures in real-world applications have a large number of parameters. For example, the current standard machine translation architecture, Transformer (Vaswani et al., 2017), has layers that contain millions of parameters. Even models that are designed to jointly optimize the performance and the parameter efficiency, such as EfficientNets (Tan & Le, 2019), still require dozens to hundreds of megabytes, which limits their applications to domains like robotics or virtual assistants.
+
+Model compression schemes reduce the memory footprint of overparametrized models. Pruning (LeCun et al., 1990) and distillation (Hinton et al., 2015) remove parameters by reducing the number of network weights. In contrast, quantization focuses on reducing the bits per weight. This makes quantization particularly interesting when compressing models that have already been carefully optimized in terms of network architecture. Whereas deleting weights or whole hidden units will inevitably lead to a drop in performance, we demonstrate that quantizing the weights can be performed with little to no loss in accuracy.
+
+Popular postprocessing quantization methods, like scalar quantization, replace the floating-point weights of a trained network by a lower-precision representation, like fixed-width integers (Vanhoucke et al., 2011). These approaches achieve a good compression rate with the additional benefit of accelerating inference on supporting hardware. However, the errors made by these approximations accumulate in the computations operated during the forward pass, inducing a significant drop in performance (Stock et al., 2019).
+
+![](images/e8fa608fc575221a61a670b21fc8efe8983cacc3f544405b658da957ea4c631e.jpg)  
+Figure 1: Quant-Noise trains models to be resilient to inference-time quantization by mimicking the effect of the quantization method during training time. This allows for extreme compression rates without much loss in accuracy on a variety of tasks and benchmarks.
+
+A solution to address this drifting effect is to directly quantize the network during training. This raises two challenges. First, the discretization operators have a null gradient — the derivative with respect to the input is zero almost everywhere. This requires special workarounds to train a network with these operators. The second challenge that often comes with these workarounds is the discrepancy that appears between the train and test functions implemented by the network. Quantization Aware Training (QAT) (Jacob et al., 2018) resolves these issues by quantizing all the weights during the forward and using a straight through estimator (STE) (Bengio et al., 2013) to compute the gradient. This works when the error introduced by STE is small, like with int8 quantization, but does not suffice in compression regimes where the approximation made by the compression is more severe.
+
+In this work, we show that quantizing only a subset of weights instead of the entire network during training is more stable for high compression schemes. Indeed, by quantizing only a random fraction of the network at each forward, most the weights are updated with unbiased gradients. Interestingly, we show that our method can employ a simpler quantization scheme during the training. This is particularly useful for quantizers with trainable parameters, such as Product Quantizer (PQ), for which our quantization proxy is not parametrized. Our approach simply applies a quantization noise, called Quant-Noise, to a random subset of the weights, see Figure 1. We observe that this makes a network resilient to various types of discretization methods: it significantly improves the accuracy associated with (a) low precision representation of weights like int8; and (b) state-of-the-art PQ. Further, we demonstrate that Quant-Noise can be applied to existing trained networks as a post-processing step, to improve the performance network after quantization.
+
+In summary, this paper makes the following contributions:
+
+• We introduce the Quant-Noise technique to learn networks that are more resilient to a variety of quantization methods such as int4, int8, and PQ; • Adding Quant-Noise to PQ leads to new state-of-the-art trade-offs between accuracy and model size. For instance, for natural language processing (NLP), we reach $8 2 . 5 \%$ accuracy on MNLI by compressing RoBERTa to 14 MB. Similarly for computer vision, we report $8 0 . 0 \%$ top-1 accuracy on ImageNet by compressing an EfficientNet-B3 to $3 . 3 { \mathrm { M B } }$ ; • By combining PQ and int8 to quantize weights and activations for networks trained with Quant-Noise, we obtain extreme compression with fixed-precision computation and achieve $7 9 . 8 \%$ top-1 accuracy on ImageNet and 21.1 perplexity on WikiText-103.
+
+# 2 RELATED WORK
+
+Model compression. Many compression methods focus on efficient parameterization, via weight pruning (LeCun et al., 1990; Li et al., 2016; Huang et al., 2018; Mittal et al., 2018), weight sharing (Dehghani et al., 2018; Turc et al., 2019; Lan et al., 2019) or with dedicated architectures (Tan & Le, 2019; Zhang et al., 2017; Howard et al., 2019). Weight pruning is implemented during training (Louizos et al., 2017) or as a fine-tuning post-processing step (Han et al., 2015; 2016). Many pruning methods are unstructured, i.e., remove individual weights (LeCun et al., 1990; Molchanov et al., 2017). On the other hand, structured pruning methods follow the structure of the weights to
+
+reduce both the memory footprint and the inference time of a model (Li et al., 2016; Luo et al., 2017;   
+Fan et al., 2019). We refer the reader to Liu et al. (2018) for a review of different pruning strategies.
+
+Other authors have worked on lightweight architectures, by modifying existing models (Zhang et al., 2018; Wu et al., 2019; Sukhbaatar et al., 2019a) or developing new networks, such as MobileNet (Howard et al., 2019), ShuffleNet (Zhang et al., 2017), and EfficientNet (Tan & Le, 2019) in vision.
+
+Finally, knowledge distillation (Hinton et al., 2015) has been applied to sentence representation (Turc et al., 2019; Sanh et al., 2019a; Sun et al., 2019; Zhao et al., 2019; Jiao et al., 2019), to reduce the size of a BERT model (Devlin et al., 2018).
+
+Quantization. There are extensive studies of scalar quantization to train networks with lowprecision weights and activations (Courbariaux et al., 2015; Courbariaux & Bengio, 2016; Rastegari et al., 2016; McDonnell, 2018). These methods benefit from specialized hardware to also improve the runtime during inference (Vanhoucke et al., 2011). Other quantization methods such as Vector Quantization (VQ) and PQ (Jegou et al., 2011) quantize blocks of weights simultaneously to achieve higher compression rate (Stock et al., 2019; Gong et al., 2014; Joulin et al., 2016; Carreira-Perpiñán & Idelbayev, 2017). Closer to our work, several works have focused at simultaneously training and quantizing a network (Jacob et al., 2018; Krishnamoorthi, 2018; Gupta et al., 2015; Dong et al., 2019). Gupta et al. (2015) assigns weights to a quantized bin stochastically which is specific to scalar quantization, but allows training with fixed point arithmetic. Finally, our method can be interpreted as a form of Bayesian compression (Louizos et al., 2017), using the Bayesian interpretation of Dropout (Gal & Ghahramani, 2016). As opposed to their work, we select our noise to match the weight transformation of a target quantization methods without restricting it to a scale mixture prior.
+
+# 3 QUANTIZING NEURAL NETWORKS
+
+In this section, we present the principles of quantization, several standard quantization methods, and describe how to combine scalar and product quantization. For clarity, we focus on the case of a fixed real matrix $\mathbf { W } \in \mathbf { R } ^ { n \times p }$ . We suppose that this matrix is split into $m \times q$ blocks $\mathbf { b } _ { k l }$ :
+
+$$
+\mathbf { W } = \left( \sum _ { \vdots } ^ { \mathbf { b } _ { 1 1 } } \mathrm { ~  ~ \cdots ~ } \sum _ { \mathbf { b } _ { m q } } \right) ,
+$$
+
+where the nature of these blocks is determined by the quantization method. A codebook is a set of $K$ vectors, i.e., ${ \mathcal { C } } = \{ \mathbf { c } [ 1 ] , \dots , \mathbf { c } [ K ] \}$ . Quantization methods compress the matrix W by assigning to each block $\mathbf { b } _ { k l }$ an index that points to a codeword $\mathbf { c }$ in a codebook $\mathcal { C }$ , and storing the codebook $\mathcal { C }$ and the resulting indices (as the entries ${ \bf { I } } _ { k l }$ of an index matrix $\mathbf { I }$ ) instead of the real weights. During the inference, they reconstruct an approximation $\widehat { \bf W }$ of the original matrix W such that $\widehat { \mathbf { b } } _ { k l } = \mathbf { c } [ \mathbf { I } _ { k l } ]$ .
+
+We distinguish scalar quantization, such as int8, where each block $\mathbf { b } _ { k l }$ consists of a single weight, from vector quantization, where several weights are quantized jointly.
+
+# 3.1 FIXED-POINT SCALAR QUANTIZATION
+
+Fixed-point scalar quantization methods replace floating-point number representations by lowprecision fixed-point representations. They simultaneously reduce a model’s memory footprint and accelerate inference by using fixed-point arithmetic on supporting hardware.
+
+Fixed-point scalar quantization operates on blocks that represent a single weight, i.e., $\mathbf { b } _ { k l } = \mathbf { W } _ { k l }$ Floating-point weights are replaced by $N$ bit fixed-point numbers (Gupta et al., 2015), with the extreme case of binarization where $N = 1$ (Courbariaux et al., 2015). More precisely, the weights are rounded to one of $2 ^ { N }$ possible codewords. These codewords correspond to bins evenly spaced by a scale factor $s$ and shifted by a bias $z$ . Each weight ${ \bf W } _ { k l }$ is mapped to its nearest codeword $c$ by successively quantizing with $z \mapsto$ round $( \mathbf { W } _ { k l } / s + z )$ and dequantizing with the inverse operation:
+
+$$
+\begin{array} { r } { \mathbf { c } = ( \mathrm { r o u n d } ( \mathbf { W } _ { k l } / s + z ) - z ) \times s , } \end{array}
+$$
+
+where we compute the scale and bias as:
+
+$$
+s = { \frac { \operatorname* { m a x } \mathbf { W } - \operatorname* { m i n } \mathbf { W } } { 2 ^ { N } - 1 } } \quad { \mathrm { a n d } } \quad z = \operatorname { r o u n d } ( \operatorname* { m i n } \mathbf { W } / s ) .
+$$
+
+We focus on this uniform rounding scheme instead of other non-uniform schemes (Choi et al., 2018; Li et al., 2019), because it allows for fixed-point arithmetic with implementations in PyTorch and Tensorflow (see Appendix). The compression rate is $\times 3 2 / N$ . The activations are also rounded to $N$ -bit fixed-point numbers. With int8 for instance, this leads to $\times 2$ to $\times 4$ faster inference on dedicated hardware. In this work, we consider both int4 and int8 quantization.
+
+# 3.2 PRODUCT QUANTIZATION
+
+Several quantization methods work on groups of weights, such as vectors, to benefit from the correlation induced by the structure of the network. In this work, we focus on Product Quantization for its good performance at extreme compression ratio (Stock et al., 2019).
+
+Traditional PQ. In vector quantization methods, the blocks are predefined groups of weights instead of single weights. The codewords are groups of values, and the index matrix I maps groups of weights from the matrix W to these codewords. In this section, we present the Product Quantization framework as it generalizes both scalar and vector quantization. We consider the case where we apply PQ to the columns of W and thus assume that $q = p$ .
+
+Traditional vector quantization techniques split the matrix $\mathbf { W }$ into its $p$ columns and learn a codebook on the resulting $p$ vectors. Instead, Product Quantization splits each column into $m$ subvectors and learns the same codebook for each of the resulting $m \times p$ subvectors. Each quantized vector is subsequently obtained by assigning its subvectors to the nearest codeword in the codebook. Learning the codebook is traditionally done using $k$ -means with a fixed number $K$ of centroids, typically $K = 2 5 6$ to store the index matrix I using int8. Thus, the objective function is written as:
+
+$$
+\Vert \mathbf { W } - \widehat { \mathbf { W } } \Vert _ { 2 } ^ { 2 } = \sum _ { k , l } \Vert \mathbf { b } _ { k l } - \mathbf { c } [ \mathbf { I } _ { k l } ] \Vert _ { 2 } ^ { 2 } .
+$$
+
+PQ shares representations between subvectors, which allows for higher compression rates than intN.
+
+Iterative PQ. When quantizing a full network rather than a single matrix, extreme compression with PQ induces a quantization drift as reconstruction error accumulates (Stock et al., 2019). Indeed, subsequent layers take as input the output of preceding layers, which are modified by the quantization of the preceding layers. This creates a drift in the network activations, resulting in large losses of performance. A solution proposed by Stock et al. (2019), which we call iterative PQ (iPQ), is to quantize layers sequentially from the lowest to the highest, and finetune the upper layers as the lower layers are quantized, under the supervision of the uncompressed (teacher) model. Codewords of each layer are finetuned by averaging the gradients of their assigned elements with gradient steps:
+
+$$
+\mathbf { c } \gets \mathbf { c } - \eta \frac { 1 } { | J _ { \mathbf { c } } | } \sum _ { ( k , l ) \in J _ { \mathbf { c } } } \frac { \partial \mathcal { L } } { \partial \mathbf { b } _ { k l } } ,
+$$
+
+where $J _ { \mathbf { c } } = \{ ( k , l ) | \mathbf { c } [ \mathbf { I } _ { k l } ] = \mathbf { c } \}$ , $\mathcal { L }$ is the loss function and $\eta > 0$ is a learning rate. This adapts the upper layers to the drift appearing in their inputs, reducing the impact of the quantization approximation on the overall performance.
+
+# 3.3 COMBINING FIXED-POINT WITH PRODUCT QUANTIZATION
+
+Fixed-point quantization and Product Quantization are often regarded as competing choices, but can be advantageously combined. Indeed, PQ/iPQ compresses the network by replacing vectors of weights by their assigned centroids, but these centroids are in floating-point precision. Fixed-point quantization compresses both activations and weights to fixed-point representations. Combining both approaches means that the vectors of weights are mapped to centroids that are compressed to fixed-point representations, along with the activations. This benefits from the extreme compression ratio of iPQ and the finite-precision arithmetics of intN quantization.
+
+More precisely, for a given matrix, we store the $\dot { \mathtt { 1 } } \mathtt { n t } \mathtt { 8 }$ representation of the $K$ centroids of dimension $d$ along with the $\log _ { 2 } K$ representations of the centroid assignments of the $m \times p$ subvectors. The int8 representation of the centroids is obtained with Eq. (2). The overall storage of the matrix and activations during a forward pass with batch size 1 (recalling that the input dimension is n) writes
+
+$$
+M = 8 \times K d + \log _ { 2 } { K } \times m p + 8 \times n \mathrm { b i t s } .
+$$
+
+In particular, when $K = 2 5 6$ , the centroid assignments are also stored in int8, which means that every value required for a forward pass is stored in an int8 format. We divide by 4 the float32 overhead of storing the centroids, although the storage requirement associated with the centroids is small compared to the cost of indexing the subvectors for standard networks. In contrast to iPQ alone where we only quantize the weights, we also quantize the activations using int8. We evaluate this approach on both natural language processing and computer vision tasks in Section 5.
+
+# 4 METHOD
+
+Deep networks are not exposed to the noise caused by the quantization drift during training, leading to suboptimal performance. A solution to make the network robust to quantization is to introduce it during training. Quantization Aware Training (QAT) (Jacob et al., 2018) exposes the network during training by quantizing weights during the forward pass. This transformation is not differentiable and gradients are approximated with a straight through estimator (STE) (Bengio et al., 2013; Courbariaux & Bengio, 2016). STE introduces a bias in the gradients that depends on level of quantization of the weights, and thus, the compression ratio. In this section, we propose a simple modification to control this induced bias with a stochastic amelioration of QAT, called Quant-Noise. The idea is to quantize a randomly selected fraction of the weights instead of the full network as in QAT, leaving some unbiased gradients flow through unquantized weights. Our general formulation can simulate the effect of both quantization and of pruning during training.
+
+# 4.1 TRAINING NETWORKS WITH QUANTIZATION NOISE
+
+We consider the case of a real matrix W as in Section 3. During the training of a network, our proposed Quant-Noise method works as follows: first, we compute blocks $\mathbf { b } _ { k l }$ related to a target quantization method. Then, during each forward pass, we randomly select a subset of these blocks and apply some distortion to them.
+
+More formally, given a set of tuples of indices $J \subset \{ ( k , l ) \}$ for $1 \leq k \leq m$ , $1 \leq l \leq q$ and a distortion or noise function $\varphi$ acting on a block, we define an operator $\psi ( \cdot \mid J )$ such that, for each block $\mathbf { b } _ { k l }$ , we apply the following transformation:
+
+$$
+\psi ( \mathbf { b } _ { k l } \mid J ) = { \left\{ \begin{array} { l l } { \varphi ( \mathbf { b } _ { k l } ) } & { { \mathrm { i f ~ } } ( k , l ) \in J , } \\ { \mathbf { b } _ { k l } } & { { \mathrm { o t h e r w i s e } } . } \end{array} \right. }
+$$
+
+The noise function $\varphi$ simulates the change in the weights produced by the target quantization method (see Section 4.2 for details). We replace the matrix W by the resulting noisy matrix $\mathbf { W } _ { \mathrm { n o i s e } }$ during the forward pass to compute a noisy output $\mathbf { y } _ { \mathrm { n o i s e } }$ , i.e.,
+
+$$
+\mathbf { W } _ { \mathrm { n o i s e } } = ( \psi ( \mathbf { b } _ { k l } \mid J ) ) _ { k l } \mathrm { a n d } \mathbf { y } _ { \mathrm { n o i s e } } = \mathbf { x } \mathbf { W } _ { \mathrm { n o i s e } }
+$$
+
+where $\mathbf { x }$ is an input vector. During the backward pass, we apply STE, which amounts to replacing the distorted weights $\mathbf { W _ { \mathrm { n o i s e } } }$ by their non-distorted counterparts. Note that our approach is equivalent to QAT when $J$ containts all the tuples of indices. However, an advantage of Quant-Noise over QAT is that unbiased gradients continue to flow via blocks unaffected by the noise. As these blocks are randomly selected for each forward, we guarantee that each weight regularly sees gradients that are not affected by the nature of the function $\varphi$ . As a side effect, our quantization noise regularizes the network in a similar way as DropConnect (Wan et al., 2013) or LayerDrop (Fan et al., 2019).
+
+Composing quantization noises. As noise operators are compositionally commutative, we can make a network robust to a combination of quantization methods by composing their noise operators:
+
+$$
+\psi ( \mathbf { b } _ { k l } \mid J ) = \psi _ { 1 } \circ \psi _ { 2 } ( \mathbf { b } _ { k l } \mid J ) .
+$$
+
+This property is particularly useful to combine quantization with pruning operators during training, as well as combining scalar quantization with product quantization.
+
+# 4.2 ADDING NOISE TO SPECIFIC QUANTIZATION METHODS
+
+In this section, we propose several implementations of the noise function $\varphi$ for the quantization methods described in Section 3. We also show how to handle pruning with it.
+
+Table 1: Comparison of different quantization schemes with and without Quant-Noise on language modeling and image classification. For language modeling, we train a Transformer on the Wikitext-103 benchmark and report perplexity (PPL) on test. For image classification, we train a EfficientNet-B3 on the ImageNet-1k benchmark and report top-1 accuracy on validation and use our re-implementation of EfficientNet-B3. The original implementation of Tan & Le (2019) achieves an uncompressed Top-1 accuracy of $8 1 . 9 \%$ . For both settings, we report model size in megabyte (MB) and the compression ratio compared to the original model.   
+
+<table><tr><td>Quantization Scheme</td><td colspan="4">Language Modeling 16-layer Transformer Wikitext-103</td><td colspan="4">Image Classification EfficientNet-B3 ImageNet-1k</td></tr><tr><td></td><td>Size</td><td>Compression</td><td></td><td>PPL</td><td>Size</td><td>Compression</td><td></td><td>Top-1</td></tr><tr><td>Uncompressed model</td><td>942</td><td>×1</td><td></td><td>18.3</td><td>46.7</td><td>×1</td><td></td><td>81.5</td></tr><tr><td>int 4 quantization</td><td>118</td><td>×8</td><td></td><td>39.4</td><td>5.8</td><td>×8</td><td></td><td>45.3</td></tr><tr><td>- trained with QAT</td><td>118</td><td>×8</td><td></td><td>34.1</td><td>5.8</td><td>×8</td><td></td><td>59.4</td></tr><tr><td>- trained with Quant-Noise</td><td>118</td><td>×8</td><td></td><td>21.8</td><td>5.8</td><td>×8</td><td></td><td>67.8</td></tr><tr><td>int 8 quantization</td><td>236</td><td>×4</td><td></td><td>19.6</td><td>11.7</td><td>×4</td><td></td><td>80.7</td></tr><tr><td>- trained with QAT</td><td>236</td><td>×4</td><td></td><td>21.0</td><td>11.7</td><td>×4</td><td></td><td>80.8</td></tr><tr><td>- trained with Quant-Noise</td><td>236</td><td>×4</td><td></td><td>18.7</td><td>11.7</td><td>×4</td><td></td><td>80.9</td></tr><tr><td>iPQ</td><td>38</td><td>×25</td><td></td><td>25.2</td><td>3.3</td><td>×14</td><td></td><td>79.0</td></tr><tr><td>- trained with QAT</td><td>38</td><td>×25</td><td></td><td>41.2</td><td>3.3</td><td>×14</td><td></td><td>55.7</td></tr><tr><td>- trained with Quant-Noise</td><td>38</td><td>×25</td><td></td><td>20.7</td><td>3.3</td><td>×14</td><td></td><td>80.0</td></tr><tr><td>iPQ&amp;int8 +Quant-Noise</td><td>38</td><td>×25</td><td></td><td>21.1</td><td>3.1</td><td>×15</td><td></td><td>79.8</td></tr></table>
+
+Fixed-point scalar quantization. In intN quantization, the blocks are atomic and weights are rounded to their nearest neighbor in the codebook. The function $\varphi$ replaces weight ${ \bf W } _ { k l }$ with the output of the rounding function defined in Eq. (2), i.e.,
+
+$$
+\varphi _ { \mathrm { i n t N } } ( w ) = ( \mathrm { r o u n d } ( w / s + z ) - z ) \times s ,
+$$
+
+where $s$ and $z$ are updated during training. In particular, the application of Quant-Noise to int8 scalar quantization is a stochastic amelioration of QAT.
+
+Product quantization. As opposed to intN, codebooks in PQ require a clustering step based on weight values. During training, we learn codewords online and use the resulting centroids to implement the quantization noise. More precisely, the noise function $\varphi _ { \mathrm { P Q } }$ assigns a selected block b to its nearest codeword in the associated codebook $\mathcal { C }$ :
+
+$$
+\begin{array} { r } { \varphi _ { \mathrm { P Q } } ( \mathbf { v } ) = \operatorname * { a r g m i n } _ { \mathbf { c } \in \mathcal { C } } \| \mathbf { b } - \mathbf { c } \| _ { 2 } ^ { 2 } . } \end{array}
+$$
+
+Updating the codebooks online works well. However, empirically, running $k$ -means once per epoch is faster and does not noticeably modify the resulting accuracy.
+
+Note that computing the exact noise function for PQ is computationally demanding. We propose a simpler and faster alternative approximation $\varphi _ { \mathrm { p r o x y } }$ to the operational transformation of PQ and iPQ. The noise function simply zeroes out the subvectors of the selected blocks, i.e., $\varphi _ { \mathrm { p r o x y } } ( \mathbf { v } ) = 0$ . As a sidenote, we considered other alternatives, for instance one where the subvectors are mapped to the mean subvector. In practice, we found that these approximations lead to similar performance, see Section 7.2. This proxy noise function is a form of Structured Dropout and encourages correlations between the subvectors. This correlation is beneficial to the subsequent clustering involved in PQ/iPQ.
+
+Adding pruning to the quantization noise. The specific form of quantization noise can be adjusted to incorporate additional noise specific to pruning. We simply combine the noise operators of quantization and pruning by composing them following Eq. (8). We consider the pruning noise function of Fan et al. (2019) where they randomly drop predefined structures during training. In particular, we focus on LayerDrop, where the structures are the residual blocks of highway-like layers (Srivastava et al., 2015), as most modern architectures, such as ResNet or Transformer, are composed of this structure. More precisely, the corresponding noise operator over residual blocks $\mathbf { v }$ is $\dot { \varphi } _ { \mathrm { L a y e r D r o p } } ( \mathbf { v } ) = 0 .$ . For pruning, we do not use STE to backpropagate the gradient of pruned weights, as dropping them entirely during training has the benefit of speeding convergence (Huang et al., 2016). Once a model is trained with LayerDrop, the number of layers kept at inference can be adapted to match computation budget or time constraint.
+
+![](images/fb191eba2d0809d5fb2682e2e7926abb2bbee75ac52ef027ff222f8961c973a6.jpg)  
+Figure 2: Performance as a function of model size. We compare models quantized with PQ and trained with the related Quant-Noise to the state of the art. (a) Test perplexity on Wikitext-103 (b) Dev Accuracy on MNLI (c) ImageNet Top-1 accuracy. Model size is shown in megabytes on a log scale. Red and gray coloring indicates existing work, with different colors for visual distinction.
+
+Table 2: Decomposing the impact of the different compression schemes. (a) we train Transformers with Adaptive Input and LayerDrop on Wikitext-103 (b) we pre-train RoBERTA base models with LayerDrop and then finetune on MNLI (c) we train an EfficientNet-B3 on ImageNet. We report the compression ratio w.r.t. to the original model (“comp.”) and the resulting size in MB.   
+
+<table><tr><td rowspan="3"></td><td colspan="4">Language modeling</td><td colspan="4">Sentence Representation</td><td colspan="4">Image Classification</td></tr><tr><td>Comp.</td><td></td><td>Size</td><td>PPL</td><td>Comp.</td><td></td><td>Size</td><td>Acc.</td><td>Comp.</td><td></td><td>Size</td><td>Acc.</td></tr><tr><td>Unquantized models</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Original model</td><td>×1</td><td></td><td>942</td><td>18.3</td><td>×1</td><td></td><td>480</td><td>84.8</td><td>×1</td><td></td><td>46.7</td><td>81.5</td></tr><tr><td>+ Sharing</td><td></td><td>×1.8</td><td>510</td><td>18.7</td><td>×1.9</td><td></td><td>250</td><td>84.0</td><td>×1.4</td><td></td><td>34.2</td><td>80.1</td></tr><tr><td>+ Pruning</td><td></td><td>×3.7</td><td>255</td><td>22.5</td><td>×3.8</td><td></td><td>125</td><td>81.3</td><td>×1.6</td><td></td><td>29.5</td><td>78.5</td></tr><tr><td>Quantized models</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>iPQ</td><td></td><td>×24.8</td><td>38</td><td>25.2</td><td>×12.6</td><td></td><td>38</td><td>82.5</td><td>× 14.1</td><td></td><td>3.3</td><td>79.0</td></tr><tr><td>+ Quant-Noise</td><td></td><td>×24.8</td><td>38</td><td>20.7</td><td>×12.6</td><td></td><td>38</td><td>83.6</td><td>×14.1</td><td></td><td>3.3</td><td>80.0</td></tr><tr><td>+ Sharing</td><td></td><td>× 49.5</td><td>19</td><td>22.0</td><td>×</td><td>34.3</td><td>14</td><td>82.5</td><td></td><td>×18</td><td>2.6</td><td>78.9</td></tr><tr><td>+ Pruning</td><td></td><td>×94.2</td><td>10</td><td>24.7</td><td></td><td>×58.5</td><td>8</td><td>78.8</td><td></td><td>×20</td><td>2.3</td><td>77.8</td></tr></table>
+
+# 5 RESULTS
+
+We demonstrate the impact of Quant-Noise on the performance of several quantization schemes in a variety of settings (see Appendix - Sec. 7.5).
+
+# 5.1 IMPROVING COMPRESSION WITH QUANT-NOISE
+
+Quant-Noise is a regularization method that makes networks more robust to the target quantization scheme or combination of quantization schemes during training. We show the impact of Quant-Noise in Table 1 for a variety of quantization methods: int8/int4 and iPQ.
+
+We experiment in 2 different settings: a Transformer network trained for language modeling on WikiText-103 and a EfficientNet-B3 convolutional network trained for image classification on ImageNet-1k. Our quantization noise framework is general and flexible — Quant-Noise improves the performance of quantized models for every quantization scheme in both experimental settings. Importantly, Quant-Noise only changes model training by adding a regularization noise similar to dropout, with no impact on convergence and very limited impact on training speed $( < 5 \%$ slower).
+
+This comparison of different quantization schemes shows that Quant-Noise works particularly well with high performance quantization methods, like iPQ, where QAT tends to degrade the performances, even compared to quantizing as a post-processing step. In subsequent experiments in this section, we focus on applications with iPQ because it offers the best trade-off between model performance and compression, and has little negative impact on FLOPS.
+
+<table><tr><td>Language Modeling</td><td>PPL</td><td>RoBERTa</td><td>Acc.</td></tr><tr><td>Train without Quant-Noise</td><td>25.2</td><td>Train without Quant-Noise</td><td>82.5</td></tr><tr><td>+ Finetune with Quant-Noise</td><td>20.9</td><td>+ Finetune with Quant-Noise</td><td>83.4</td></tr><tr><td>Train with Quant-Noise</td><td>20.7</td><td>Train with Quant-Noise</td><td>83.6</td></tr></table>
+
+Table 3: Quant-Noise: Finetuning vs training. We report performance after iPQ quantization. We train with the $\phi _ { \mathrm { p r o x y } }$ noise and finetune with Quant-Noise, and use it during the transfer to MNLI for each RoBERTa model.
+
+Fixed-Point Product Quantization. Combining iPQ and int8 as described in Section 3.3 allows us to take advantage of the high compression rate of iPQ with a fixed-point representation of both centroids and activations. As shown in Table 1, this combination incurs little loss in accuracy with respect to $\mathrm { i } \mathrm { P Q } +$ Quant-Noise. Most of the memory footprint of iPQ comes from indexing and not storing centroids, so the compression ratios are comparable.
+
+Complementarity with Weight Pruning and Sharing. We analyze how Quant-Noise is compatible and complementary with pruning (“+Prune”) and weight sharing ( $^ { 6 6 } { + } \mathrm { S l }$ hare”), see Appendix for details on weight sharing. We report results for Language modeling on WikiText-103, pre-trained sentence representations on MNLI and object classification on ImageNet-1k in Table 2. The conclusions are remarkably consistent across tasks and benchmarks: Quant-Noise gives a large improvement over strong iPQ baselines. Combining it with sharing and pruning offers additional interesting operating points of performance vs size.
+
+# 5.2 COMPARISON WITH THE STATE OF THE ART
+
+We now compare our approach on the same tasks against the state of the art. We compare $\mathrm { i } \mathrm { P Q } +$ Quant-Noise with 6 methods of network compression for Language modeling, 8 state-of-the-art methods for Text classification, and 8 recent methods evaluate image classification on Imagenet with compressed models. These comparisons demonstrate that Quant-Noise leads to extreme compression rates at a reasonable cost in accuracy. We apply our best quantization setup on competitive models and reduce their memory footprint by $\times 2 0 - 9 4 $ when combining with weight sharing and pruning, offering extreme compression for good performance.
+
+Natural Language Processing. In Figure 2, we examine the trade-off between performance and model size. Our quantized RoBERTa offers a competitive trade-off between size and performance with memory reduction methods dedicated to BERT, like TinyBERT, MobileBERT, or AdaBERT.
+
+Image Classification. We compress EfficientNet-B3 from 46.7Mb to $3 . 3 { \mathrm { M b } }$ ( $\times 1 4$ compression) while maintaining high top-1 accuracy $( 7 8 . 5 \%$ versus $8 0 \%$ for the original model). As shown in Figure 2, our quantized EfficientNet-B3 is smaller and more accurate than architectures dedicated to optimize on-device performance with limited size like MobileNet or ShuffleNet. We further evaluate the beneficial effect of Quant-Noise on ResNet-50 to compare directly with Stock et al. (2019). Results shown in Table 4 indicate improvement with Quant-Noise compared to previous work.
+
+Incorporating pruning noise into quantization is also beneficial. For example, with pruning $\mathrm { i P Q + }$ Quant-Noise reduces size by $\times 2 5$ with only a drop of $2 . 4 \ : \mathrm { P P L }$ in language modeling. Further, pruning reduces FLOPS by the same ratio as its compression factor, in our case, $\times 2$ . By adding sharing with pruning, in language modeling, we achieve an extreme compression ratio of $\times 9 4$ with a drop of $6 . 4 \ : \mathrm { P P L }$ with FLOPS reduction from pruning entire shared chunks of layers. For comparison, our $1 0 \mathbf { M B }$ model has the same performance as the $5 7 0 \mathrm { M B }$ Transformer-XL base.
+
+# 5.3 FINETUNING WITH QUANT-NOISE FOR POST-PROCESSING QUANTIZATION
+
+We explore taking existing models and post-processing with Quant-Noise instead of training from scratch. For language modeling, we train for 10 additional epochs. For RoBERTa, we train for $2 5 \mathrm { k }$ additional updates. Finetuning with Quant-Noise incorporates the benefits and almost matches training from scratch (Table 3). In language modeling, there is only a $0 . 2 \ : \mathrm { P P L }$ difference. We further examine how to incorporate Quant-Noise more flexibly into pretraining RoBERTa. We take an already trained RoBERTa model and incorporate Quant-Noise during sentence classification finetuning. This is effective at compressing while retaining accuracy after quantization.
+
+# 6 CONCLUSION
+
+We show that quantizing a random subset of weights during training maintains performance in the high quantization regime. We validate that Quant-Noise works with a variety of different quantization schemes on several applications in text and vision. Our method can be applied to a combination of iPQ and int8 to benefit from extreme compression ratio and fixed-point arithmetic. Finally, we show that Quant-Noise can be used as a post-processing step to prepare already trained networks for subsequent quantization, to improve the performance of the compressed model.
+
+# REFERENCES
+
+A. Adcock, V. Reis, M. Singh, Z. Yan, L. van der Maaten, K. Zhang, S. Motwani, J. Guerin, N. Goyal, I. Misra, L. Gustafson, C. Changhan, and P. Goyal. Classy vision. 2019.   
+Alexei Baevski and Michael Auli. Adaptive input representations for neural language modeling. arXiv preprint arXiv:1809.10853, 2018.   
+Yoshua Bengio, Nicholas Léonard, and Aaron Courville. Estimating or propagating gradients through stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013.   
+James Bradbury, Stephen Merity, Caiming Xiong, and Richard Socher. Quasi-recurrent neural networks. arXiv preprint arXiv:1611.01576, 2016.   
+Qingqing Cao, Harsh Trivedi, Aruna Balasubramanian, and Niranjan Balasubramanian. Faster and just as accurate: A simple decomposition for transformer models.   
+Miguel A. Carreira-Perpiñán and Yerlan Idelbayev. Model compression as constrained optimization, with application to neural nets. part ii: quantization, 2017.   
+Daoyuan Chen, Yaliang Li, Minghui Qiu, Zhen Wang, Bofang Li, Bolin Ding, Hongbo Deng, Jun Huang, Wei Lin, and Jingren Zhou. Adabert: Task-adaptive bert compression with differentiable neural architecture search. arXiv preprint arXiv:2001.04246, 2020.   
+Jungwook Choi, Zhuo Wang, Swagath Venkataramani, Pierce I-Jen Chuang, Vijayalakshmi Srinivasan, and Kailash Gopalakrishnan. Pact: Parameterized clipping activation for quantized neural networks. arXiv preprint arXiv:1805.06085, 2018.   
+Matthieu Courbariaux and Yoshua Bengio. Binarynet: Training deep neural networks with weights and activations constrained to $+ 1$ or -1. CoRR, 2016.   
+Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. CoRR, 2015.   
+Zihang Dai, Zhilin Yang, Yiming Yang, William W Cohen, Jaime Carbonell, Quoc V Le, and Ruslan Salakhutdinov. Transformer-xl: Attentive language models beyond a fixed-length context. arXiv preprint arXiv:1901.02860, 2019.   
+Yann N. Dauphin, Angela Fan, Michael Auli, and David Grangier. Language modeling with gated convolutional networks. In Proc. of ICML, 2017.   
+Mostafa Dehghani, Stephan Gouws, Oriol Vinyals, Jakob Uszkoreit, and Łukasz Kaiser. Universal transformers, 2018.   
+J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR, 2009.   
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
+
+Yinpeng Dong, Renkun Ni, Jianguo Li, Yurong Chen, Hang Su, and Jun Zhu. Stochastic quantization for learning accurate low-bit deep neural networks. International Journal of Computer Vision, 127 (11-12):1629–1642, 2019.
+
+Angela Fan, Edouard Grave, and Armand Joulin. Reducing transformer depth on demand with structured dropout. arXiv preprint arXiv:1909.11556, 2019.
+
+Yarin Gal and Zoubin Ghahramani. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. In international conference on machine learning, pp. 1050–1059, 2016.
+
+Yunchao Gong, Liu Liu, Ming Yang, and Lubomir Bourdev. Compressing deep convolutional networks using vector quantization. arXiv preprint arXiv:1412.6115, 2014.
+
+Edouard Grave, Armand Joulin, Moustapha Cisse, David Grangier, and Herve Jegou. Efficient softmax approximation for gpus. arXiv, abs/1609.04309, 2016.
+
+Suyog Gupta, Ankur Agrawal, Kailash Gopalakrishnan, and Pritish Narayanan. Deep learning with limited numerical precision. In ICML, 2015.
+
+Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In NIPS, pp. 1135–1143, 2015.
+
+Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and Huffman coding. ICLR, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, 2015.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Andrew Howard, Mark Sandler, Grace Chu, Liang-Chieh Chen, Bo Chen, Mingxing Tan, Weijun Wang, Yukun Zhu, Ruoming Pang, Vijay Vasudevan, Quoc V. Le, and Hartwig Adam. Searching for mobilenetv3. arXiv e-prints, 2019.
+
+Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with stochastic depth. In ECCV, 2016.
+
+Gao Huang, Shichen Liu, Laurens Van der Maaten, and Kilian Q Weinberger. Condensenet: An efficient densenet using learned group convolutions. In CVPR, 2018.
+
+Benoit Jacob, Skirmantas Kligys, Bo Chen, Menglong Zhu, Matthew Tang, Andrew Howard, Hartwig Adam, and Dmitry Kalenichenko. Quantization and training of neural networks for efficient integer-arithmetic-only inference. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2704–2713, 2018.
+
+Herve Jegou, Matthijs Douze, and Cordelia Schmid. Product quantization for nearest neighbor search. PAMI, 2011.
+
+Xiaoqi Jiao, Yichun Yin, Lifeng Shang, Xin Jiang, Xiao Chen, Linlin Li, Fang Wang, and Qun Liu. Tinybert: Distilling bert for natural language understanding. arXiv preprint arXiv:1909.10351, 2019.
+
+Armand Joulin, Edouard Grave, Piotr Bojanowski, Matthijs Douze, Hérve Jégou, and Tomas Mikolov. Fasttext.zip: Compressing text classification models. arXiv preprint arXiv:1612.03651, 2016.
+
+Raghuraman Krishnamoorthi. Quantizing deep convolutional networks for efficient inference: A whitepaper. arXiv preprint arXiv:1806.08342, 2018.
+
+Guillaume Lample and Alexis Conneau. Cross-lingual language model pretraining. arXiv preprint arXiv:1901.07291, 2019.
+
+Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. Albert: A lite bert for self-supervised learning of language representations, 2019.
+
+Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In NIPS, 1990.
+
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. arXiv preprint arXiv:1608.08710, 2016.
+
+Yuhang Li, Xin Dong, and Wei Wang. Additive powers-of-two quantization: A non-uniform discretization for neural networks. arXiv preprint arXiv:1909.13144, 2019.
+
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.
+
+Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. arXiv preprint arXiv:1810.05270, 2018.
+
+Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983, 2016.
+
+Christos Louizos, Max Welling, and Diederik P Kingma. Learning sparse neural networks through l_0 regularization. arXiv preprint arXiv:1712.01312, 2017.
+
+Jian-Hao Luo, Jianxin Wu, and Weiyao Lin. Thinet: A filter level pruning method for deep neural network compression. In ICCV, 2017.
+
+Ningning Ma, Xiangyu Zhang, Hai-Tao Zheng, and Jian Sun. Shufflenet V2: practical guidelines for efficient CNN architecture design. CoRR, 2018.
+
+Xindian Ma, Peng Zhang, Shuai Zhang, Nan Duan, Yuexian Hou, Dawei Song, and Ming Zhou. A tensorized transformer for language modeling. arXiv preprint arXiv:1906.09777, 2019.
+
+Mark D. McDonnell. Training wide residual networks for deployment using a single bit for each weight, 2018.
+
+Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer Sentinel Mixture Models. arXiv, abs/1609.07843, 2016.
+
+Deepak Mittal, Shweta Bhardwaj, Mitesh M Khapra, and Balaraman Ravindran. Recovering from random pruning: On the plasticity of deep convolutional neural networks. In WACV, 2018.
+
+Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. In ICML, 2017.
+
+Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. In Proceedings of NAACL-HLT 2019: Demonstrations, 2019.
+
+Razvan Pascanu, Caglar Gulcehre, Kyunghyun Cho, and Yoshua Bengio. How to construct deep recurrent neural networks. In Proceedings of the Second International Conference on Learning Representations (ICLR 2014), 2014.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017.
+
+Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. 2019.
+
+Jack W Rae, Anna Potapenko, Siddhant M Jayakumar, and Timothy P Lillicrap. Compressive transformers for long-range sequence modelling. arXiv preprint arXiv:1911.05507, 2019.
+
+Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In ECCV, 2016.
+
+Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In Conference on Computer Vision and Pattern Recognition, pp. 4510–4520, 2018.
+
+Victor Sanh, Lysandre Debut, Julien Chaumond, and Thomas Wolf. Distilbert, a distilled version of bert: smaller, faster, cheaper and lighter. 2019a.
+
+Victor Sanh, Lysandre Debut, Julien Chaumond, and Thomas Wolf. Distilbert, a distilled version of bert: smaller, faster, cheaper and lighter. arXiv preprint arXiv:1910.01108, 2019b.
+
+Rupesh Kumar Srivastava, Klaus Greff, and Jürgen Schmidhuber. Highway networks. arXiv preprint arXiv:1505.00387, 2015.
+
+Pierre Stock, Armand Joulin, Rémi Gribonval, Benjamin Graham, and Hervé Jégou. And the bit goes down: Revisiting the quantization of neural networks. CoRR, abs/1907.05686, 2019.
+
+Sainbayar Sukhbaatar, Edouard Grave, Piotr Bojanowski, and Armand Joulin. Adaptive attention span in transformers. arXiv preprint arXiv:1905.07799, 2019a.
+
+Sainbayar Sukhbaatar, Edouard Grave, Guillaume Lample, Herve Jegou, and Armand Joulin. Augmenting self-attention with persistent memory. arXiv preprint arXiv:1907.01470, 2019b.
+
+Siqi Sun, Yu Cheng, Zhe Gan, and Jingjing Liu. Patient knowledge distillation for bert model compression. EMNLP, 2019.
+
+Zhiqing Sun, Hongkun Yu, Xiaodan Song, Renjie Liu, Yiming Yang, and Denny Zhou. Mobilebert: Task-agnostic compression of bert for resource limited devices.
+
+Ilya Sutskever, James Martens, George Dahl, and Geoffrey Hinton. On the importance of initialization and momentum in deep learning. In International conference on machine learning, pp. 1139–1147, 2013.
+
+Mingxing Tan and Quoc V. Le. Efficientnet: Rethinking model scaling for convolutional neural networks, 2019.
+
+Iulia Turc, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Well-read students learn better: The impact of student initialization on knowledge distillation. arXiv preprint arXiv:1908.08962, 2019.
+
+Vincent Vanhoucke, Andrew Senior, and Mark Z Mao. Improving the speed of neural networks on cpus. 2011.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NIPS, 2017.
+
+Li Wan, Matthew Zeiler, Sixin Zhang, Yann Le Cun, and Rob Fergus. Regularization of neural networks using DropConnect. In ICML, 2013.
+
+Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. GLUE: A multi-task benchmark and analysis platform for natural language understanding. 2019. ICLR.
+
+Kuan Wang, Zhijian Liu, Yujun Lin andx Ji Lin, and Song Han. HAQ: hardware-aware automated quantization. CoRR, 2018.
+
+Adina Williams, Nikita Nangia, and Samuel R. Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In Proceedings of NAACL-HLT, 2018.
+
+Felix Wu, Angela Fan, Alexei Baevski, Yann Dauphin, and Michael Auli. Pay less attention with lightweight and dynamic convolutions. In ICLR, 2019.
+
+Biao Zhang, Deyi Xiong, and Jinsong Su. Accelerating neural transformer via an average attention network. arXiv preprint arXiv:1805.00631, 2018.
+
+Xiangyu Zhang, Xinyu Zhou, Mengxiao Lin, and Jian Sun. Shufflenet: An extremely efficient convolutional neural network for mobile devices. CoRR, 2017.
+
+Sanqiang Zhao, Raghav Gupta, Yang Song, and Denny Zhou. Extreme language model compression with optimal subwords and shared projections. arXiv preprint arXiv:1909.11687, 2019.
+
+<table><tr><td> Setting</td><td>Model</td><td>Compression</td><td>Top-1 Accuracy</td></tr><tr><td rowspan="2">Small Blocks</td><td>Stock et al. (2019)</td><td>19x</td><td>73.8</td></tr><tr><td>Quant-Noise</td><td>19x</td><td>74.3</td></tr><tr><td rowspan="2">Large Blocks</td><td>Stock et al. (2019)</td><td>32x</td><td>68.2</td></tr><tr><td>Quant-Noise</td><td>32x</td><td>68.8</td></tr></table>
+
+![](images/ba35cf41421a36478cb5c76c461ca17166f7ed7e069174cbe097a3f7e7e6cbf8.jpg)  
+Table 4: Compression of ResNet-50 with Quant-Noise. We compare to Stock et al. (2019) in both the small and large blocks regime. For fair comparison, we hold the compression rate constant. Quant-Noise provides improved performance in both settings.   
+Figure 3: Effect of Quantization Parameters. We report the influence of the proportion of blocks to which we apply the noise. We focus on Transformer for Wikitext-103 language modeling. We explore two settings: iPQ and int8. For iPQ, we use $\varphi _ { \mathrm { p r o x y } }$ .
+
+# 7 APPENDIX
+
+# 7.1 QUANTIZATION OF ADDITIONAL ARCHITECTURES
+
+ResNet-50. We explore the compression of ResNet-50, a standard architecture used Computer Vision. In Table 4, we compare Quant-Noise to iPQ Compression from Stock et al. (2019) and show that Quant-Noise provide consistent additional improvement.
+
+# 7.2 ABLATIONS
+
+In this section, we examine the impact of the level of noise during training as well as the impact of approximating iPQ during training.
+
+# 7.3 IMPACT OF NOISE RATE
+
+We analyze the performance for various values of Quant-Noise in Figure 3 on a Transformer for language modeling. For iPQ, performance is impacted by high rates of quantization noise. For example, a Transformer with the noise function $\varphi _ { \mathrm { p r o x y } }$ degrades with rate higher than 0.5, i.e., when half of the weights are passed through the noise function $\varphi _ { \mathrm { p r o x y } }$ . We hypothesize that for large quantities of noise, a larger effect of using proxy rather than the exact PQ noise is observed. For int8 quantization and its noise function, higher rates of noise are slightly worse but not as severe. A rate of 1 for int8 quantization is equivalent to the Quantization Aware Training of (Krishnamoorthi, 2018), as the full matrix is quantized with STE, showing the potential benefit of partial quantization during training.
+
+# 7.4 IMPACT OF APPROXIMATING THE NOISE FUNCTION
+
+We study the impact of approximating quantization noise during training. We focus on the case of iPQ with the approximation described in Section 4.2. In Table 5, we compare the correct noise function for iPQ with its approximation $\varphi _ { \mathrm { p r o x y } }$ . This approximate noise function does not consider cluster assignments or centroid values and simply zeroes out the selected blocks. For completeness, we include an intermediate approximation where we consider cluster assignments to apply noise within each cluster, but still zero-out the vectors. These approximations do not affect the performance of the quantized models. This suggests that increasing the correlation between subvectors that are jointly clustered is enough to maintain the performance of a model quantized with iPQ. Since PQ tends to work well on highly correlated vectors, such as activations in convolutional networks, this is not surprising. Using the approximation $\varphi _ { \mathrm { p r o x y } }$ presents the advantage of speed and practicality. Indeed, one does not need to compute cluster assignments and centroids for every layer in the network after each epoch. Moreover, the approach $\varphi _ { \mathrm { p r o x y } }$ is less involved in terms of code.
+
+Table 5: Exact versus proxy noise function for different block selections with iPQ. We compare exact $\phi _ { \mathrm { P Q } }$ and the approximation $\phi _ { \mathrm { p r o x y } }$ with blocks selected from all subvectors or subvectors from the same cluster.   
+
+<table><tr><td>Noise</td><td>Blocks</td><td>PPL</td><td>Quant PPL</td></tr><tr><td>PQ</td><td>Subvectors</td><td>18.3</td><td>21.1</td></tr><tr><td>PQ</td><td>Clusters</td><td>18.3</td><td>21.2</td></tr><tr><td>proxy</td><td>Subvectors</td><td>18.3</td><td>21.0</td></tr><tr><td>proxy</td><td>Clusters</td><td>18.4</td><td>21.1</td></tr></table>
+
+# 7.5 EXPERIMENTAL SETTING
+
+We assess the effectiveness of Quant-Noise on competitive language and vision benchmarks. We consider Transformers for language modeling, RoBERTa for pre-training sentence representations, and EfficientNet for image classification. Our models are implemented in PyTorch (Paszke et al., 2017). We use fairseq (Ott et al., 2019) for language modeling and pre-training for sentence representation tasks and Classy Vision (Adcock et al., 2019) for EfficientNet.
+
+Language Modeling. We experiment on the Wikitext-103 benchmark (Merity et al., 2016) that contains 100M tokens and a vocabulary of 260k words. We train a 16 layer Transformer following Baevski & Auli (2018) with a LayerDrop rate of 0.2 (Fan et al., 2019). We report perplexity (PPL) on the test set.
+
+Pre-Training of Sentence Representations. We pre-train the base BERT model (Devlin et al., 2018) on the BooksCorpus $^ +$ Wiki dataset with a LayerDrop rate of 0.2. We finetune the pre-trained models on the MNLI task (Williams et al., 2018) from the GLUE Benchmark (Wang et al., 2019) and report accuracy. We follow the parameters in Liu et al. (2019) training and finetuning.
+
+Image Classification. We train an EfficientNet-B3 model (Tan & Le, 2019) on the ImageNet object classification benchmark (Deng et al., 2009). The EfficientNet-B3 of Classy Vision achieves a Top-1 accuracy of $8 1 . 5 \%$ , which is slightly below than the performance of $8 1 . 9 \%$ reported by Tan & Le (2019).
+
+# 7.6 TRAINING DETAILS
+
+Language Modeling To handle the large vocabulary of Wikitext-103, we follow (Dauphin et al., 2017) and (Baevski & Auli, 2018) in using adaptive softmax (Grave et al., 2016) and adaptive input for computational efficiency. For both input and output embeddings, we use dimension size 1024 and three adaptive bands: 20K, 40K, and 200K. We use a cosine learning rate schedule (Baevski & Auli, 2018; Loshchilov & Hutter, 2016) and train with Nesterov’s accelerated gradient (Sutskever et al., 2013). We set the momentum to 0.99 and renormalize gradients if the norm exceeds 0.1 (Pascanu et al., 2014). During training, we partition the data into blocks of contiguous tokens that ignore document boundaries. At test time, we respect sentence boundaries. We set LayerDrop to 0.2. We set Quant-Noise value to 0.05. During training time, we searched over the parameters (0.05, 0.1, 0.2) to determine the optimal value of Quant-Noise. During training time, the block size of Quant-Noise is 8.
+
+RoBERTa The base architecture is a 12 layer model with embedding size 768 and FFN size 3072. We follow (Liu et al., 2019) in using the subword tokenization scheme from (Radford et al., 2019), which uses bytes as subword units. This eliminates unknown tokens. We train with large batches of size 8192 and maintain this batch size using gradient accumulation. We do not use next sentence prediction (Lample & Conneau, 2019). We optimize with Adam with a polynomial decay learning rate schedule. We set LayerDrop to 0.2. We set Quant-Noise value to 0.1. We did not hyperparameter
+
+<table><tr><td>Model</td><td>MB</td><td>PPL</td></tr><tr><td>Trans XL Large (Dai et al., 2019) Compressive Trans (Rae et al.,2019) GCNN (Dauphin et al., 2017) 4 Layer QRNN (Bradbury et al., 2016)</td><td>970 970 870</td><td>18.3 17.1 37.2 33.0</td></tr><tr><td>Trans XL Base (Dai et al.,2019) Persis Mem (Sukhbaatar etal.,2019b) Tensorized core-2 (Ma et al.,2019)</td><td>570 506 325</td><td>24.0 20.6</td></tr><tr><td></td><td></td><td>18.9</td></tr><tr><td>Quant-Noise</td><td>38</td><td>20.7</td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td>Quant-Noise + Share + Prune</td><td></td><td></td></tr><tr><td></td><td>10</td><td></td></tr><tr><td></td><td></td><td>24.2</td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr></table>
+
+Table 6: Performance on Wikitext-103. We report test set perplexity and model size in megabytes.   
+Lower perplexity is better.
+
+search to determine the optimal value of Quant-Noise as training RoBERTa is computationally intensive. During training time, the block size of Quant-Noise is 8.
+
+During finetuning, we hyperparameter search over three learning rate options (1e-5, 2e-5, 3e-5) and batchsize (16 or 32 sentences). The other parameters are set following (Liu et al., 2019). We do single task finetuning, meaning we only tune on the data provided for the given natural language understanding task. We do not perform ensembling. When finetuning models trained with LayerDrop, we apply LayerDrop and Quant-Noise during finetuning time as well.
+
+EfficientNet We use the architecture of EfficientNet-B3 defined in Classy Vision (Adcock et al., 2019) and follow the default hyperparameters for training. We set Quant-Noise value to 0.1. During training time, we searched over the parameters (0.05, 0.1, 0.2) to determine the optimal value of Quant-Noise. During training time, the block size of Quant-Noise is set to 4 for all $1 \times 1$ convolutions, 9 for depth-wise $3 \times 3$ convolutions, 5 for depth-wise $5 \times 5$ convolutions and 4 for the classifier. For sharing, we shared weights between blocks 9-10, 11-12, 14-15, 16-17, 19-20-21, 22-23 and refer to blocks that share the same weights as a chunk. For LayerDrop, we drop the chunks of blocks defined previously with probability 0.2 and evaluate only with chunks 9-10, 14-15 and 19-20-21.
+
+# 7.7 SCALAR QUANTIZATION DETAILS
+
+We closely follow the methodology of PyTorch 1.4. We emulate scalar quantization by quantizing the weights and the activations. The scales and zero points of activations are determined by doing a few forward passes ahead of the evaluation and then fixed. We use the Histogram method to compute $s$ and $z$ , which aims at approximately minimizing the $L _ { 2 }$ quantization error by adjusting $s$ and $z$ . This scheme is a refinement of the MinMax scheme. Per channel quantization is also discussed in Table 10.
+
+# 7.8 IPQ QUANTIZATION DETAILS
+
+Language Modeling We quantize FFN with block size 8, embeddings with block size 8, and attention with block size 4. We tuned the block size for attention between the values (4, 8) to find the best performance. Note that during training with apply Quant-Noise to all the layers.
+
+RoBERTa We quantize FFN with block size 4, embeddings with block size 4, and attention with block size 4. We tuned the block size between the values (4, 8) to find the best performance. Note that during training with apply Quant-Noise to all the layers.
+
+EfficientNet We quantize blocks sequentially and end up with the classifier. The block sizes are 4 for all $1 \times 1$ convolutions, 9 for depth-wise $3 \times 3$ convolutions, 5 for depth-wise $5 \times 5$ convolutions and 4 for the classifier. Note that during training with apply Quant-Noise to all the weights in InvertedResidual Blocks (except the Squeeze-Excitation subblocks), the head convolution and the classifier.
+
+Table 7: Performance on MNLI. We report accuracy and size in megabytes. \* indicates distillation using BERT Large. $\dagger$ indicates training with data augmentation. Work from Sun et al. (2019) and Zhao et al. (2019) do not report results on the dev set. Cao et al. do not report model size. Higher accuracy is better.   
+
+<table><tr><td>Model</td><td>MB</td><td>MNLI</td></tr><tr><td>RoBERTa Base +LD (Fan et al., 2019)</td><td>480</td><td>84.8</td></tr><tr><td>BERT Base (Devlin et al.,2018)</td><td>420</td><td>84.4</td></tr><tr><td>PreTrained Distil (Turc et al., 2019)</td><td>257</td><td>82.5</td></tr><tr><td>DistilBERT (Sanh et al.,2019b)</td><td>250</td><td>81.8</td></tr><tr><td>MobileBERT* (Sun et al.)</td><td>96</td><td>84.4</td></tr><tr><td>TinyBERTt (Jiao et al.,2019)</td><td>55</td><td>82.8</td></tr><tr><td>ALBERT Base (Lan et al.,2019)</td><td>45</td><td>81.6</td></tr><tr><td>AdaBERTt (Chen et al.,2020)</td><td>36</td><td>81.6</td></tr><tr><td>Quant-Noise</td><td>38</td><td>83.6</td></tr><tr><td>Quant-Noise+ Share +Prune</td><td>14</td><td>82.5</td></tr></table>
+
+Table 8: Performance on ImageNet. We report accuracy and size in megabytes. Higher accuracy is better.   
+
+<table><tr><td>Model</td><td>MB</td><td>Acc.</td></tr><tr><td>EfficientNet-B7 (Tan &amp;Le,2019) ResNet-50 (He et al., 2015) DenseNet-169 (Huang et al., 2018) EfficientNet-BO (Tan &amp;Le,2019) MobileNet-v2 (Sandler et al., 2018)</td><td>260 97.5 53.4 20.2 13.4</td><td>84.4 76.1 76.2 77.3 71.9</td></tr><tr><td>Shufflenet-v2 ×1 (Ma et al.,2018) HAQ 4 bits (Wang et al., 2018) iPQ ResNet-50 (Stock et al.,2019)</td><td>8.7 12.4</td><td>69.4 76.2</td></tr><tr><td>Quant-Noise</td><td>5.09 3.3</td><td>76.1 80.0</td></tr><tr><td>Quant-Noise + Share + Prune</td><td>2.3</td><td>77.8</td></tr></table>
+
+# 7.9 DETAILS OF PRUNING AND LAYER SHARING
+
+We apply the Every Other Layer strategy from Fan et al. (2019). When combining layer sharing with pruning, we train models with shared layers and then prune chunks of shared layers. When sharing layers, the weights of adjacent layers are shared in chunks of two. For a concrete example, imagine we have a model with layers A, B, C, D, E, F, G, H. We share layers A and B, C and D, E and F, G and H. To prune, every other chunk would be pruned away, for example we could prune A, B, E, F.
+
+# 7.10 NUMERICAL RESULTS FOR GRAPHICAL DIAGRAMS
+
+We report the numerical values displayed in Figures 2 in Table 6 for language modeling, Table 7 for BERT, and Table 8 for ImageNet.
+
+# 7.11 FURTHER ABLATIONS
+
+# 7.11.1 IMPACT OF QUANT-NOISE FOR THE VISION SETUP
+
+We provide another study showing the impact of the proportion of elements on which to apply Quant-Noise in Table 9.
+
+# 7.11.2 IMPACT OF THE NUMBER OF CENTROIDS
+
+We quantize with 256 centroids which represents a balance between size and representation capacity. The effect of the number of centroids on performance and size is shown in Figure 4 (a). Quantizing
+
+<table><tr><td>p</td><td>0</td><td>0.2</td><td>0.4</td><td>0.6</td><td>0.8</td><td>1</td></tr><tr><td>Top-1</td><td>80.66</td><td>80.83</td><td>80.82</td><td>80.88</td><td>80.92</td><td>80.64</td></tr></table>
+
+Table 9: Effect of Quantization Parameters. We report the influence of the Quant-Noise rate $p$ with Scalar Quantization (int8). We focus on EfficientNet for ImageNet classification.
+
+![](images/cf825d2cf66ad807058d5706153a322d0dca0137253c54a0e00ac009d8f56a9a.jpg)  
+Figure 4: Quantizing with a larger number of centroids. Results are shown on Wikitext-103 valid.
+
+with more centroids improves perplexity — this parameter could be adjusted based on the practical storage constraints.
+
+# 7.11.3 EFFECT OF INITIAL MODEL SIZE
+
+Large, overparameterized models are more easily compressed. In Figure 5, we explore quantizing both shallower and skinnier models. For shallow models, the gap between quantized and non-quantized perplexity does not increase as layers are removed (Figure 5, left). In contrast, there is a larger gap in performance for models with smaller FFN (Figure 5, right). As the FFN size decreases, the weights are less redundant and more difficult to quantize with iPQ.
+
+# 7.11.4 DIFFICULTY OF QUANTIZING DIFFERENT MODEL STRUCTURES
+
+Quantization is applied to various portions of the Transformer architecture — the embedding, attention, feedforward, and classifier output. We compare the quantizability of various portions of the network in this section.
+
+Is the order of structures important? We quantize specific network structures first — this is important as quantizing weight matrices can accumulate reconstruction error. Some structures of the network should be quantized last so the finetuning process can better adjust the centroids. We find that there are small variations in performance based on quantization order (see Figure 6). We choose to quantize FFN, then embeddings, and finally the attention matrices in Transformer networks.
+
+Which structures can be compressed the most? Finally, we analyze which network structures can be most compressed. During quantization, various matrix block sizes can be chosen as a parameter — the larger the block size, the more compression, but also the larger the potential reduction of performance. Thus, it is important to understand how much each network structure can be compressed to reduce the memory footprint of the final model as much as possible. In Figure 6, we quantize two model structures with a fixed block size and vary the block size of the third between 4 and 32. As shown, the FFN and embedding structures are more robust to aggressive compression, while the attention drastically loses performance as larger block sizes are used.
+
+# 7.11.5 APPROACH TO I N TN SCALAR QUANTIZATION
+
+We compare quantizing per-channel to using a histogram quantizer in Table 10. The histogram quantizer maintains a running min/max and minimizes L2 distance between quantized and nonquantized values to find the optimal min/max. Quantizing per channel learns scales and offsets as vectors along the channel dimension, which provides more flexibility since scales and offsets can be different.
+
+![](images/89d51efee35f6dc30bb5ffaa4bb5b370bcc344263f7bf64ce5139ec44a66a0da.jpg)  
+Figure 5: (a) Effect of Initial Model Size for more shallow models (b) Effect of Initial Model Size more skinny models
+
+![](images/8012673edf3e43ed6c0eaae7f98a58780eb2aa1fbaa3915613839ed665d88982.jpg)  
+Figure 6: Effect of Quantization on Model Structures. Results are shown on the validation set of Wikitext-103. (a) Quantizing Attention, FFN, and Embeddings in different order. (b) More Extreme compression of different structures.
+
+# 7.11.6 LAYERDROP WITH STE
+
+For quantization noise, we apply the straight through estimator (STE) to remaining weights in the backward pass. We experiment with applying STE to the backward pass of LayerDrop’s pruning noise. Results are shown in Table 11 and find slightly worse results.
+
+Table 10: Comparison of different approaches to int4 and int8 with and without QuantNoise on language modeling and image classification. For language modeling, we train a Transformer on the Wikitext-103 benchmark. We report perplexity (PPL) on the test set. For image classification, we train a EfficientNet-B3 on the ImageNet-1K benchmark. We report top-1 accuracy on the validation set. For both setting, we also report model size in megabyte (MB) and the compression ratio compared to the original model.   
+
+<table><tr><td>Quantization Scheme</td><td colspan="3">Language Modeling 16-layer Transformer Wikitext-103</td><td colspan="3">Image Classification EfficientNet-B3 ImageNet-1K</td></tr><tr><td></td><td>Size</td><td>Compress</td><td>Test PPL</td><td>Size</td><td>Compress</td><td>Top-1 Acc.</td></tr><tr><td>Uncompressed model</td><td>942</td><td>×1</td><td>18.3</td><td>46.7</td><td>×1</td><td>81.5</td></tr><tr><td>Int4 Quant Histogram</td><td>118</td><td>×8</td><td>39.4</td><td>5.8</td><td>×8</td><td>45.3</td></tr><tr><td>+ Quant-Noise</td><td>118</td><td>×8</td><td>21.8</td><td>5.8</td><td>×8</td><td>67.8</td></tr><tr><td>Int4 Quant Channel</td><td>118</td><td>×8</td><td>21.2</td><td>5.8</td><td>×8</td><td>68.2</td></tr><tr><td>+ Quant-Noise</td><td>118</td><td>×8</td><td>19.5</td><td>5.8</td><td>×8</td><td>72.3</td></tr><tr><td>Int8 Quant Histogram</td><td>236</td><td>×4</td><td>19.6</td><td>11.7</td><td>×4</td><td>80.7</td></tr><tr><td>+ Quant-Noise</td><td>236</td><td>×4</td><td>18.7</td><td>11.7</td><td>×4</td><td>80.9</td></tr><tr><td>Int8 Quant Channel</td><td>236</td><td>×4</td><td>18.5</td><td>11.7</td><td>×4</td><td>81.1</td></tr><tr><td>+ Quant-Noise</td><td>236</td><td>×4</td><td>18.3</td><td>11.7</td><td>×4</td><td>81.2</td></tr></table>
+
+Table 11: Performance on Wikitext-103 when using STE in the backward pass of the LayerDrop pruning noise.   
+
+<table><tr><td>Model</td><td>MB</td><td>PPL</td></tr><tr><td>Quant-Noise + Share + Prune</td><td>10</td><td>24.2</td></tr><tr><td>Quant-Noise + Share + Prune with STE</td><td>10</td><td>24.5</td></tr></table>

parse/train/hfkER_KJiNw/hfkER_KJiNw.md

@@ -0,0 +1,358 @@
+# Graph Neural Networks with Adaptive Residual
+
+Xiaorui Liu1 xiaorui@msu.edu
+
+Jiayuan Ding1 dingjia5@msu.edu
+
+Wei Jin1 jinwei2@msu.edu
+
+Han Xu1 xuhan1@msu.edu
+
+Yao Ma2 yao.ma@njit.edu
+
+Zitao Liu3 liuzitao@100tal.com
+
+Jiliang Tang1 tangjili@msu.edu
+
+1Michigan State University, East Lansing, MI, USA 2New Jersey Institute of Technology, Newark, NJ, USA 3TAL Education Group, Beijing, China
+
+# Abstract
+
+Graph neural networks (GNNs) have shown the power in graph representation learning for numerous tasks. In this work, we discover an interesting phenomenon that although residual connections in the message passing of GNNs help improve the performance, they immensely amplify GNNs’ vulnerability against abnormal node features. This is undesirable because in real-world applications, node features in graphs could often be abnormal such as being naturally noisy or adversarially manipulated. We analyze possible reasons to understand this phenomenon and aim to design GNNs with stronger resilience to abnormal features. Our understandings motivate us to propose and derive a simple, efficient, interpretable, and adaptive message passing scheme, leading to a novel GNN with Adaptive residual, AirGNN1. Extensive experiments under various abnormal feature scenarios demonstrate the effectiveness of the proposed algorithm.
+
+# 1 Introduction
+
+Recent years have witnessed the great success of graph neural networks (GNNs) in representation learning for graph structure data [1]. Essentially, GNNs generalize deep neural networks (DNNs) from regular grids, such as image, video and text, to irregular data such as social, energy, transportation, citation, and biological networks. Such data can be naturally represented as graphs with nodes and edges. The key building block for such generalization is the neural message passing framework [2]:
+
+$$
+\mathbf { x } _ { u } ^ { ( k + 1 ) } = \mathrm { U P D A T E } ^ { ( k ) } \left( \mathbf { x } _ { u } ^ { ( k ) } , \mathbf { m } _ { \mathcal { N } ( u ) } ^ { ( k ) } \right)
+$$
+
+where x(ku $\mathbf { x } _ { u } ^ { ( k ) } \in \mathbb { R } ^ { d }$ denotes the feature vector of node $u$ in the $k$ -th iteration of message passing, and $\mathbf { m } _ { \mathcal { N } ( u ) } ^ { ( k ) }$ is the message aggregated from $u$ ’s neighborhood $\mathcal { N } ( u )$ . The specific design of message passing scheme can be motivated from spectral domain [3, 4] or spatial domain [5, 6, 7, 2]. It usually linearly smooths the features in a local neighborhood on the graph.
+
+GNNs have achieved superior performance in a large number of benchmark datasets [8] where the node features are assumed to be complete and informative. However, in real-world applications, some node features could be abnormal from various aspects. For instance, in social networks, new users might not have complete profile before they make connections with others, leading to missing user features. In transportation networks, node features can be noisy since there exist certain uncertainty and dynamics in the observation of the traffic information. What is worse, node features can be adversarially chosen by the attacker to maliciously manipulate the prediction made by GNNs. Therefore, it is greatly desired to design GNN models with stronger resilience to abnormal node features.
+
+In this work, we first perform empirical investigations on how representative GNN models behave on graphs with abnormal features. Specifically, based upon standard benchmark datasets, we simulate the abnormal features by replacing the features of randomly selected nodes with random Gaussian noise. Then the performance of node classification on abnormal features and normal features are examined separately. From our preliminary study in Section 2, we reveal two interesting observations: (1) Feature aggregation can boost the resilience to abnormal features, but too many aggregations could hurt the performance on both normal and abnormal features; and (2) Residual connection helps GNNs benefit from more layers for normal features, while making GNNs more fragile to abnormal features. We then provide possible explanations to understand these observed phenomena from the perspective of graph Laplacian smoothing. Our analyses imply that there might exist an intrinsic tension between feature aggregation and residual connection, which results in a performance tradeoff between normal features and abnormal features.
+
+Motivated by these findings and understandings, we aim to design new GNNs with stronger resilience to abnormal features while largely maintaining the performance on normal features. Our contributions can be summarized as follows:
+
+• We discover an intrinsic tension between feature aggregation and residual connection in GNNs, and the corresponding performance tradeoff between abnormal and normal features. We also analyze possible reasons to explain and understand these findings.   
+• We propose a simple, efficient, principled and adaptive message passing scheme, which leads to a novel GNN model with adaptive residual, named as AirGNN.   
+• Extensive experiments under various abnormal feature scenarios demonstrate the superiority of the proposed algorithm. The ablation study demonstrates how the adaptive residuals mitigate the impact of abnormal features.
+
+# 2 Preliminary
+
+Before introducing the preliminary study, we first define the notations used throughout the paper.
+
+Notations. We use bold upper-case letters such as $\mathbf { X }$ to denote matrices. Given a matrix $\mathbf { X } \in \mathbb { R } ^ { n \times d }$ , we use $\mathbf { X } _ { i }$ to denote its $i$ -th row and $\mathbf { X } _ { i j }$ to denote its element in $i$ -th row and $j$ -th column. The Frobenius norm and $\ell _ { 2 1 }$ norm of a matrix $\mathbf { X }$ are defined as $\Vert \mathbf { X } \Vert _ { F } = \sqrt { \sum _ { i j } \mathbf { X } _ { i j } ^ { 2 } }$ and $\| \mathbf { X } \| _ { 2 1 } =$ $\begin{array} { r } { \sum _ { i } \| \mathbf { X } _ { i } \| _ { 2 } = \sum _ { i } \sqrt { \sum _ { j } \mathbf { X } _ { i j } ^ { 2 } } } \end{array}$ , respectively. We define $\| \mathbf { X } \| _ { 2 } = \sigma _ { \operatorname* { m a x } } ( \mathbf { X } )$ where $\sigma _ { \mathrm { m a x } } ( \mathbf { X } )$ is the largest singular value of $\mathbf { X }$ .
+
+Let $\mathcal { G } = \{ \nu , \mathcal { E } \}$ be a graph with the node set $\mathcal { V } = \{ v _ { 1 } , \ldots , v _ { n } \}$ and the undirected edge set $\mathcal { E } = \{ e _ { 1 } , \ldots , e _ { m } \}$ . We use $\mathcal { N } ( v _ { i } )$ to denote the neighboring nodes of node $v _ { i }$ , including $v _ { i }$ itself. Suppose that each node is associated with a $d$ -dimensional feature vector, and the features for all nodes are denoted as $\mathbf { X } _ { \mathrm { f e a } } \in \mathbb { R } ^ { n \times d }$ . The graph structure $\mathcal { G }$ can be represented as an adjacent matrix $\mathbf { A } \in \mathbb { R } ^ { n \times n }$ , where $\mathbf { A } _ { i j } ~ = ~ 1$ when there exists an edge between nodes $v _ { i }$ and $v _ { j }$ , and $\mathbf { A } _ { i j } \ = \ 0$ otherwise. The graph Laplacian matrix is defined as $\mathbf { L } = \mathbf { D } - \mathbf { A }$ , where $\mathbf { D }$ is the diagonal degree matrix. Let us denote the commonly used feature aggregation matrix in GNNs [3] as $\tilde { \bf A } = \hat { \bf D } ^ { - \frac { 1 } { 2 } } \bar { \hat { \bf A } } \hat { \bf D } ^ { - \frac { 1 } { 2 } }$ where $\hat { \mathbf { A } } = \mathbf { A } + \mathbf { I }$ is the adjacent matrix with self-loop and its degree matrix is $\hat { \bf D }$ . The corresponding Laplacian matrix is defined as $\tilde { \mathbf { L } } = \mathbf { I } - \tilde { \mathbf { A } }$ .
+
+In this work, we focus on the setting where a subset of nodes in the graph contain abnormal features, while the remaining nodes have normal features. In the remaining of this paper, we use abnormal/normal features to denote nodes with abnormal/normal features, for simplicity.
+
+# 2.1 Preliminary Study
+
+Experimental setup. To investigate how GNNs behave on abnormal and normal node features, we design semi-supervised node classification experiments on three common datasets (i.e., Cora,
+
+CiteSeer and PubMed), following the data splits in the work [3]. Moreover, we simulate the abnormal features by assigning $1 0 \%$ of the nodes with random features sampled from a standard Gaussian distribution. The experiments are performed on representative GNN models covering coupled and decoupled architectures, including GCN [3], GCNII [9], APPNP [10], and their variants with or without residual connections in feature aggregations, denoted as w/Res and wo/Res. All methods follow the hyperparameter settings in their original papers. We examine how these models perform when the number of layers increases. Note that for the decoupled architectures such as APPNP, we fix the 2-layer MLP and increase the number of propagation layers. While for the coupled architectures such as GCN and GCNII, we increase the number of feature transformation and propagation layers simultaneously. We report the average performance over 10 times of random selection of the noise node sets. The node classification accuracy (mean and standard variance) on nodes with abnormal and normal features is illustrated in Figure 1 and Figure. 2, separately.
+
+![](images/00d120485edd7da85f1457dd4c00230b18d99c238c177b5cb16e29a69a61afb9.jpg)  
+Figure 1: Node classification accuracy on abnormal nodes (Cora)
+
+![](images/08499e09f3e29a9b457146ea9c203108450fafd94446152fa1b7aada0f5024ce.jpg)  
+Figure 2: Node classification accuracy on normal nodes (Cora)
+
+Observations. From Figure 1 and Figure 2, we can make the following observations: (1) Without residual connection, more layers (e.g., $> 2$ for GCN and GCNII, $> 1 0$ for APPNP) hurt the accuracy on nodes with normal features. However, more layers boost the accuracy on nodes with abnormal features significantly, before finally starting to decrease; (2) With residual connection, the accuracy on nodes with normal features keeps increasing with more layers2. However, the accuracy on nodes with abnormal features only increases marginally when stacking more layers, and then starts to decrease. While we only present the experiments on Cora, we defer the results on other datasets to Appendix C, which provide similar observations. To conclude, we can summarize these observations into two major findings:
+
+• Finding I: Feature aggregation can boost the resilience to abnormal features, but too many aggregations could hurt the performance on both normal and abnormal nodes;
+
+• Finding II: Residual connection helps GNNs benefit from more layers for nodes with normal features, while making GNNs more fragile to abnormal features.
+
+# 2.2 Understandings
+
+In this subsection, we provide the understanding and explanation for aforementioned findings, from the perspective of graph Laplacian smoothing.
+
+# Understanding Finding I: Feature aggregation as Laplacian smoothing
+
+The message passing in GCN [3], GCNII wo/ residual and APPNP wo/ residual (as well as many popular GNN models), follows the feature aggregation
+
+$$
+\mathbf { X } _ { \mathrm { o u t } } = \tilde { \mathbf { A } } \mathbf { X } _ { \mathrm { i n } } ,
+$$
+
+where ${ \bf X } _ { \mathrm { i n } }$ and $\mathbf { X _ { o u t } }$ represent the features before and after message passing layer, respectively. It can be interpreted as one gradient descent step for the Laplacian smoothing problem [11]
+
+$$
+\underset { \mathbf { X } \in \mathbb { R } ^ { n \times d } } { \arg \operatorname* { m i n } } \mathcal { L } _ { 1 } ( \mathbf { X } ) : = \frac { 1 } { 2 } \mathrm { t r } \Big ( \mathbf { X } ^ { \top } ( \mathbf { I } - \tilde { \mathbf { A } } ) \mathbf { X } \Big ) = \frac { 1 } { 2 } \sum _ { ( v _ { i } , v _ { j } ) \in \mathcal { E } } \| \frac { \mathbf { X } _ { i } } { \sqrt { d _ { i } + 1 } } - \frac { \mathbf { X } _ { j } } { \sqrt { d _ { j } + 1 } } \| _ { 2 } ^ { 2 } ,
+$$
+
+where $d _ { i }$ is the node degree of node $v _ { i }$ . Eq. (2) can be derived from $\mathbf { X } _ { \mathrm { o u t } } = \mathbf { X } _ { \mathrm { i n } } - ( \mathbf { I } - \tilde { \mathbf { A } } ) \mathbf { X } _ { \mathrm { i n } } = \tilde { \mathbf { A } } \mathbf { X } _ { \mathrm { i n } }$ , with the initialization $\mathbf { X } = \mathbf { X } _ { \mathrm { i n } }$ and stepsize $\gamma = 1$ . The Laplacian smoothing problem penalizes the feature difference between neighboring nodes. To reduce this penalty, the feature aggregation in Eq. (2) smooths the node features by taking the average of local neighbors, and thus can be considered as low-pass filter which gradually filters out high-frequency signals [12, 13]. Therefore, it increases the resilience to abnormal features which are likely to be high-frequency signals. In other words, the local neighboring nodes help to correct the abnormal features. Unfortunately, if applied too many times, these low-pass filters could overly smooth the features (well-known as oversmoothing [14, 15]) such that nodes are not distinguishable enough, providing an explanation to the degraded performance on both abnormal and normal features when stacking too many layers.
+
+# Understanding Finding II: Residual connection maintains feature proximity
+
+To adjust the feature smoothness for better performance, APPNP [10] utilizes residual connections in message passing as follows
+
+$$
+\mathbf { X } ^ { k + 1 } = ( 1 - \alpha ) \tilde { \mathbf { A } } \mathbf { X } ^ { k } + \alpha \mathbf { X _ { \mathrm { i n } } } ,
+$$
+
+where ${ \bf X } ^ { 0 } = { \bf X } _ { \mathrm { i n } }$ . It can be considered as an iterative solution for the regularized Laplacian smoothing problem [11]
+
+$$
+\underset { { \substack { \mathbf { X } \in \mathbb { R } ^ { n \times d } } } } { \arg \operatorname* { m i n } } \ \mathcal { L } _ { 2 } ( { \mathbf { X } } ) : = \frac { \alpha } { 2 ( 1 - \alpha ) } \| \mathbf { X } - \mathbf { X } _ { \mathrm { i n } } \| _ { F } ^ { 2 } + \frac { 1 } { 2 } \mathrm { t r } \Big ( \mathbf { X } ^ { \top } ( { \mathbf { I } } - \tilde { \mathbf { A } } ) \mathbf { X } \Big ) ,
+$$
+
+with initialization $\mathbf { X } = \mathbf { X } _ { \mathrm { i n } }$ and stepsize $\gamma = 1 - \alpha$ due to
+
+$$
+\mathbf { X } ^ { k + 1 } = \mathbf { X } ^ { k } - ( 1 - \alpha ) \bigg ( \frac { \alpha } { 1 - \alpha } ( \mathbf { X } ^ { k } - \mathbf { X _ { \mathrm { i n } } } ) + ( \mathbf { I } - \tilde { \mathbf { A } } ) \mathbf { X } ^ { k } \bigg ) = ( 1 - \alpha ) \tilde { \mathbf { A } } \mathbf { X } ^ { k } + \alpha \mathbf { X _ { \mathrm { i n } } } .
+$$
+
+GCNII [9] adopts a similar message passing but further combines a feature transformation layer in each message passing step, which leads to a coupled architecture, as contrast to the decoupled architecture of APPNP. The residual connection naturally arises when regularizing the proximity between input and output features, as showed in the first term of $\mathcal { L } _ { 2 } ( \mathbf { X } )$ . Such proximity can help avoid the trivial solution for the problem in Eq. (3), i.e., totally oversmoothed features only depending on node degrees, and consequently mitigates the oversmoothing issue. More intuitively, residual connections in GNNs provide direct information flows between layers that can preserve some necessary high-frequency signals for better discrimination between classes. More layers with residual provide a more accurate solution to Eq. (5), which explains the performance gain from deeper GNNs. Unfortunately, these residual connections also undesirably carry on abnormal features which are detrimental, leading to the inferior performance on abnormal features.
+
+# 3 The Proposed Framework
+
+In this section, we first motivate the proposed adaptive message passing scheme (AMP) with further discussions on our preliminary study. We then introduce more details about AMP, its interpretations, convergence guarantee and computation complexity, as well as the model architecture of AirGNN.
+
+# 3.1 Design Motivation
+
+Our preliminary study in Section 2 reveals an intrinsic tension between feature aggregation and residual connection: (1) feature aggregation helps smooth out abnormal features, while it could cause inappropriate smoothing for normal features; (2) residual connection is essential for adjusting the feature smoothness, but it could be detrimental for abnormal features. Although this conflict can be partially mitigated by adjusting the residual connection such as the residual weight $\alpha$ in GCNII [9] and APPNP [10], such global adjustment cannot be adaptive to a subset of the nodes, e.g., the nodes with abnormal features. This is crucial because in practice we often encounter the scenario where only a subset of nodes contain abnormal features. Therefore, how to reconcile this dilemma still desires dedicated efforts. We then naturally ask a question: Can we design a better message passing scheme with node-wise adaptive feature aggregation and residual connection?
+
+The motivation of the proposed idea builds upon the following intuition: while it is important to maintain the proximity between input and output features as in Eq. (5), it could be over aggressive to penalize their deviations by the square of Frobenius norm, i.e., $\begin{array} { r } { \| \dot { \bf X } - \dot { \bf X } _ { \mathrm { i n } } \| _ { F } ^ { 2 } = \sum _ { i = 1 } ^ { n } \| \dot { \bf X } _ { i } - ( { \bf X } _ { \mathrm { i n } } ) _ { i } \| _ { 2 } ^ { 2 } } \end{array}$ The fact that this penalty does not tolerate large deviations weakens the capability to remove abnormal features through Laplacian smoothing. This motivates us to consider an alternative proximity penalty
+
+$$
+\| { \bf X } - { \bf X } _ { \mathrm { i n } } \| _ { 2 1 } : = \sum _ { i = 1 } ^ { n } \| { \bf X } _ { i } - ( { \bf X } _ { \mathrm { i n } } ) _ { i } \| _ { 2 } ,
+$$
+
+which instead penalizes the deviations by the $\ell _ { 1 }$ norm of row-wise $\ell _ { 2 }$ norms, namely $\ell _ { 2 1 }$ norm. The $\ell _ { 2 1 }$ norm promotes row sparsity in $\mathbf { X } - \mathbf { X } _ { \mathrm { i n } }$ , and it also allows large deviations because the penalty on large values is less aggressive, leading to the potential removal of abnormal features. Therefore, we propose the following Laplacian smoothing problem regularized by $\ell _ { 2 1 }$ norm proximity control:
+
+$$
+\underset { \mathbf { X } \in \mathbb { R } ^ { n \times d } } { \arg \operatorname* { m i n } } \lambda \| \mathbf { X } - \mathbf { X } _ { \mathrm { i n } } \| _ { 2 1 } + \frac { 1 } { 2 } \mathrm { t r } ( \mathbf { X } ^ { \top } ( \mathbf { I } - \tilde { \mathbf { A } } ) \mathbf { X } ) ,
+$$
+
+where $\lambda \in [ 0 , \infty )$ is a parameter to adjust the balance between proximity and Laplacian smoothing. In order to easy the tuning of $\lambda$ , we made a modification of Eq. (7):
+
+$$
+\underset { \mathbf { X } \in \mathbb { R } ^ { n \times d } } { \arg \operatorname* { m i n } } \ \mathcal { L } ( \mathbf { X } ) : = \lambda \| \mathbf { X } - \mathbf { X _ { \mathrm { i n } } } \| _ { 2 1 } + ( 1 - \lambda ) \mathrm { t r } ( \mathbf { X } ^ { \top } ( \mathbf { I } - \tilde { \mathbf { A } } ) \mathbf { X } ) ,
+$$
+
+where $\lambda \in [ 0 , 1 ]$ controls the balance.
+
+# 3.2 Adaptive Message Passing
+
+![](images/b9c08a90235cf9dc7aa82eaeface75a6b91e84c8306c75e6acc04630e39b84db.jpg)  
+Figure 3: Diagram of Adaptive Message Passing
+
+$\mathcal { L } ( \mathbf { X } )$ is a composite objective with non-smooth and smooth components. We optimize it by proximal gradient descent [16] and obtain the following iterations as the adaptive message passing (AMP):
+
+$$
+\begin{array} { r l } { { \displaystyle { \bf Y } ^ { k } = { \bf X } ^ { k } - 2 \gamma ( 1 - \lambda ) ( { \bf I } - \tilde { \bf A } ) { \bf X } ^ { k } = \left( 1 - 2 \gamma ( 1 - \lambda ) \right) { \bf X } ^ { k } + 2 \gamma ( 1 - \lambda ) \tilde { \bf A } { \bf X } ^ { k } } } & { { } { } { } } \\ { { \displaystyle { \bf X } ^ { k + 1 } = \arg \operatorname* { m i n } \left\{ \lambda \| { \bf X } - { \bf X } _ { \mathrm { i n } } \| _ { 2 1 } + \frac { 1 } { 2 \gamma } \| { \bf X } - { \bf Y } ^ { k } \| _ { F } ^ { 2 } \right\} } } & { { } { } { } } \end{array}
+$$
+
+where ${ \bf X } ^ { 0 } = { \bf X } _ { \mathrm { i n } }$ and $\gamma$ is the stepsize to be specified later. Let $\mathbf { Z } = \mathbf { X } - \mathbf { X } _ { \mathrm { i n } }$ , and Eq. (10) can be rewritten as:
+
+$$
+\begin{array} { r l } {  { \mathbf { Z } ^ { k + 1 } = \arg \operatorname* { m i n } \{ \lambda \| \mathbf { Z } \| _ { 2 1 } + \frac { 1 } { 2 \gamma } \| \mathbf { Z } - ( \mathbf { Y } ^ { k } - \mathbf { X } _ { \mathrm { i n } } ) \| _ { F } ^ { 2 } \} } } \\ & { = \mathbf { p r o x } _ { \gamma \lambda \| \cdot \| _ { 2 1 } } ( \mathbf { Y } ^ { k } - \mathbf { X } _ { \mathrm { i n } } ) } \\ & { \mathbf { X } ^ { k + 1 } = \mathbf { X } _ { \mathrm { i n } } + \mathbf { Z } ^ { k + 1 } . } \end{array}
+$$
+
+The $i$ -th row of the proximal operator in Eq. (11) can be computed analytically
+
+$$
+\left( \mathbf { p r o x } _ { \gamma \lambda \parallel \cdot \parallel _ { 2 1 } } ( \mathbf { X } ) \right) _ { i } = \frac { \mathbf { X } _ { i } } { \parallel \mathbf { X } _ { i } \parallel _ { 2 } } \operatorname* { m a x } ( \parallel \mathbf { X } _ { i } \parallel _ { 2 } - \gamma \lambda , 0 ) = \operatorname* { m a x } ( 1 - \frac { \gamma \lambda } { \parallel \mathbf { X } _ { i } \parallel _ { 2 } } , 0 ) \cdot \mathbf { X } _ { i } .
+$$
+
+Note that the proximal operator returns 0 if the input vector is 0. Substituting $\mathbf { X }$ in Eq. (13) with $\mathbf { Y } ^ { k } - \mathbf { X } _ { \mathrm { i n } }$ and combining Eq. (11) and Eq. (12), then Eq. (12) becomes
+
+$$
+\mathbf { X } _ { i } ^ { k + 1 } = ( \mathbf { X } _ { \mathrm { i n } } ) _ { i } + \beta _ { i } ( \mathbf { Y } _ { i } ^ { k } - ( \mathbf { X } _ { \mathrm { i n } } ) _ { i } ) = ( 1 - \beta _ { i } ) ( \mathbf { X } _ { \mathrm { i n } } ) _ { i } + \beta _ { i } \mathbf { Y } _ { i } ^ { k } , \quad \forall i \in [ n ] ,
+$$
+
+where $\begin{array} { r } { \beta _ { i } : = \operatorname* { m a x } ( 1 - \frac { \gamma \lambda } { \| \mathbf { Y } _ { i } ^ { k } - ( \mathbf { X } _ { \mathrm { i n } } ) _ { i } \| _ { 2 } } , 0 ) } \end{array}$ . To summarize, the proposed adaptive message passing (AMP) scheme is showed in Figure 4, and a diagram is showed in Figure 3. In detail, AMP works as follows:
+
+• The first step takes a feature aggregation within the local neighbors with a self-loop weighted by $1 - 2 \gamma ( 1 - \lambda )$ ;   
+• The second step computes a weight $\beta _ { i } \in [ 0 , 1 ]$ for each node $v _ { i }$ depending on the local deviation $\| { \bf Y } _ { i } ^ { k } - ( { \bf X } _ { \mathrm { i n } } ) _ { i } \| _ { 2 }$ .   
+• The final step takes a linear combination of input features $\mathbf { X } _ { \mathrm { i n } }$ and the aggregated features $\mathbf { Y } ^ { k }$ , where the node-wise residual is adaptively weighted by $1 - \beta _ { i }$ for each node $v _ { i }$ .
+
+![](images/31b59335ec89ac9c9b7a99814a2a6a89348cd1cc224bfd947556babaafd3c58b.jpg)  
+Figure 4: Adaptive Message Passing (AMP)
+
+The convergence guarantee of AMP and parameter setting for the stepsize $\gamma$ are illustrated in Theorem 1 and proved in Appendix A. According to Theorem 1, if we set γ = 14(1−λ) or γ = 12(1−λ) , then the first step of AMP can be simplified as $\begin{array} { r } { \mathbf { Y } ^ { k } = \frac { 1 } { 2 } \mathbf { X } ^ { k } + \frac { 1 } { 2 } \tilde { \mathbf { A } } \mathbf { X } ^ { k } } \end{array}$ and $\mathbf { Y } ^ { k } = \tilde { \mathbf { A } } \mathbf { X } ^ { k }$ , respectively. The choice of stepsize will only impact the convergence speed but not the ultimate effect of AMP when it convergences to the fixed point solution. We also discuss the computation complexity per iteration of AMP in Remark 1.
+
+Theorem 1 (Convergence of AMP). Under the stepsize setting < 1(1−λ)kL˜k , the proposed adaptive message passing scheme (AMP) in Eq. (9) and Eq. (10) converges to the optimal solution of the problem defined in Eq. (8). In practice, it is sufficient to choose any $\begin{array} { r } { \gamma < \frac { 1 } { 2 ( 1 - \lambda ) } } \end{array}$ since $\Vert \tilde { \mathbf { L } } \Vert _ { 2 } \leq 2$ Moreover, if the connected components of the graph $\mathcal { G }$ are not bipartite graphs, it is sufficient to choose $\begin{array} { r } { \gamma = \frac { 1 } { 2 ( 1 - \lambda ) } } \end{array}$ since $\Vert \tilde { \mathbf { L } } \Vert _ { 2 } < 2$ .
+
+Remark 1 (Computation complexity). AMP is as efficient as simple feature aggregation $\mathbf { X } _ { o u t } =$ $\tilde { \mathbf { A } } \mathbf { X } _ { i n }$ because the additional computation cost from the second and third steps in Figure 4 is in the order $\mathcal { O } ( n d )$ , where $n$ is the number of nodes and $d$ is the feature dimension. This is negligible compared with the computation cost $\mathcal { O } ( m d )$ in feature aggregation, where m is the number of edges, due to the fact that usually there are many more edges than nodes in real-world graphs, i.e., $m \gg n$
+
+# 3.3 Interpretation of AMP
+
+Interestingly, the proposed AMP has a simple and intuitive interpretation as adaptive residual connection, which aligns well with our design motivation:
+
+• If the feature of node $v _ { i }$ , i.e., $( \mathbf { X } _ { \mathrm { i n } } ) _ { i }$ , is significantly inconsistent with its local neighbors, i.e., the aggregated feature $\mathbf { Y } _ { i } ^ { k }$ , then the local deviation $\| { \bf Y } _ { i } ^ { k } - ( { \bf X } _ { \mathrm { i n } } ) _ { i } \| _ { 2 }$ will be large, which leads to a $\beta _ { i }$ close to 1. Therefore, the final step will assign a small weight to the residual, i.e., $( 1 - \beta _ { i } ) ( \mathbf { X } _ { \mathrm { i n } } ) _ { i }$ , and the aggregated feature $\mathbf { Y } _ { i } ^ { k }$ will dominate.
+
+• On the contrary, if $( \mathbf { X } _ { \mathrm { i n } } ) _ { i }$ is already consistent with its local neighbors, $\| { \bf Y } _ { i } ^ { k } - ( { \bf X } _ { \mathrm { i n } } ) _ { i } \| _ { 2 }$ will be small, which leads to a $\beta _ { i }$ close to 0. Thus, the residual will dominate, which is reasonable since there is less need to aggregate features in this case.
+
+• To summarize, the local deviation $\| { \bf Y } _ { i } ^ { k } - ( { \bf X } _ { \mathrm { i n } } ) _ { i } \| _ { 2 }$ provides a natural transition from $\beta _ { i } \to 1$ to $\beta _ { i } \to 0$ , and the transition can be modulated by $\lambda$ which can be either learned or tuned as a hyperparameter through cross-validation. This transition provides an node-wise adaptive residual connection for the message passing scheme.
+
+Adaptivity for abnormal $\pmb { \& }$ normal features. According to the homophily assumption on graph structure data [17, 18, 19, 3], the feature representations of normal features should be more consistent with local neighbors than abnormal features. As a result, AMP will assign more residual (i.e., smaller $\beta$ ) to normal features but less residual (i.e., larger $\beta$ ) to abnormal features, providing a customized tradeoff between feature aggregation and residual connection. Consequently, it can promote both the resilience to abnormal features and the performance on normal features. Above discussion also implies a clear physical meaning for $\beta$ in AMP, and we formally define it as the adaptive score.
+
+Definition 1 (Adaptive score). The variables $\{ \beta _ { 1 } , \cdot \cdot \cdot , \beta _ { n } \}$ in the adaptive message passing scheme (AMP) are defined as the adaptive scores for nodes $\{ v _ { 1 } , \cdots , v _ { n } \}$ respectively in graph $\mathcal { G }$ . In particular, the larger $\beta _ { i }$ is, the more likely the feature of node $v _ { i }$ is abnormal.
+
+Remark 2 (Nonlinear smoother). Different from most existing message passing scheme which are linear smoothers, AMP is a nonlinear smoother because the weights $\{ \beta _ { i } \}$ are computed from $\mathbf { Y } ^ { k }$ and ${ \bf X } _ { i n }$ . This nonlinearity is the key to achieve adaptive residual connection for different nodes.
+
+# 3.4 The Model Architecture
+
+The proposed adaptive message passing (AMP) can be used as a building block in many GNN models to improve the resilience to abnormal node features. In this work, we choose the the decoupled architectures as APPNP [10] and DAGNN [20], and propose the Adaptive residual GNN (AirGNN):
+
+$$
+\begin{array} { r l } & { \mathbf { X } _ { \mathrm { i n } } = h _ { \theta } ( \mathbf { X } _ { \mathrm { f e a } } ) , } \\ & { \mathbf { Y } _ { \mathrm { p r e } } = \mathbf { A } \mathbf { M } \mathbf { P } \left( \mathbf { X } _ { \mathrm { i n } } , K , \lambda \right) . } \end{array}
+$$
+
+$h _ { \theta } ( \cdot )$ is any machine learning model parameterized by learnable parameters $\theta$ , such as multilayer perceptrons (MLPs). $\mathbf { X } _ { \mathrm { f e a } } \in \mathbb { R } ^ { n \times d }$ denotes the initial node features. The model $h _ { \theta } ( \cdot )$ will first transform the initial node features as $\mathbf { X } _ { \mathrm { i n } } = h _ { \theta } ( \mathbf { X } _ { \mathrm { f e a } } )$ . AMP takes $h _ { \theta } ( \mathbf { X } _ { \mathrm { f e a } } )$ as input, and performs $K$ steps of AMP with the hyperparameter $\lambda$ . Similar to the majority of existing GNN models, the training objective is the cross-entropy classification loss on the labeled nodes, and the whole model is trained in an end-to-end way. Note that AirGNN is very efficient as explained in Remark 1, and it only requires two hyperparameters $K$ and $\lambda$ without introducing additional parameters to learn, which could reduce the risk of overfitting.
+
+# 4 Experiment
+
+In this section, we aim to verify the effective of the proposed adaptive message passing scheme (AMP) and the AirGNN model through the semi-supervised node classification tasks. Specifically, we try to answer the following questions: (1) How does AirGNN perform on abnormal and normal features? (Section 4.2 and 4.3) and (2) How does AirGNN work by adjusting the adaptive residual? (Section 4.4)
+
+# 4.1 Experimental Settings
+
+Datasets and baselines. We conduct experiments on 8 real-world datasets including three citation graphs, i.e., Cora, Citeseer, Pubmed [21], two co-authorship graphs, i.e., Coauthor CS and Coauthor Physics [22], two co-purchase graphs, i.e., Amazon Computers and Amazon Photo [22], and one OGB dataset, i.e., ogbn-arxiv [23]. Due to the space limit, we only present the results on Cora, Citeseer, and Pubmed in this section, but defer the results on other datasets to Appendix D.1. More details about the data statistics and data splits are summarized in Appendix B. The proposed AirGNN is compared with representative GNNs, including GCN [3], GAT [6], APPNP [10] and GCNII [9]. We defer the comparison with the variants of APPNP and Robust GCN [24] to Appendix D.3 and D.4 respectively.
+
+Parameter settings. For all baselines, we follow the best hyperparameter settings in their original papers. Additionally, we tune a best residual weight $\alpha$ for APPNP and GCNII in the range $[ 0 , 1 ]$ . For AirGNN, we use a two-layer MLP as the base model $h _ { \theta } ( \cdot )$ , following APPNP. We fix the learning rate 0.01, dropout 0.8, and weight decay 0.0005. Moreover, we set $\begin{array} { r } { \gamma = \frac { 1 } { 2 ( 1 - \lambda ) } } \end{array}$ as suggested by Theorem 1. We choose $K = 1 0$ and tune $\lambda$ in the range $[ 0 , 1 ]$ . Adam optimizer [25] is used in all experiments. We run all experiments by 10 times, and report the mean and variance.
+
+Evaluation setting. We assess the performance of all models under two types of abnormal feature scenarios, including noisy features and adversarial features. The abnormal features are injected to randomly selected test nodes after model training. By default, all hyperparameters are tuned according to the performance on validation sets when the dataset is clean. If tuning the hyperparameter $\lambda$ of AirGNN according to the validation sets after injecting abnormal features, the performance will be even better, as discussed in Appendix D.2. The performance on clean data are showed in Appendix D.5 to demonstrate that AirGNN doesn’t need to sacrifice accuracy for better robustness against abnormal features.
+
+# 4.2 Performance Comparison with Noisy Features
+
+In this subsection, we consider the abnormal features in the noisy feature scenario. Specifically, we simulate the noisy features by assigning a subset of the nodes with random features sampled from a multivariate standard Gaussian distribution. Note that the selection of noise subsets has a apparent impact on the performance since some nodes are less vulnerable to abnormal features while others are more vulnerable. To reduce such variance, we report the average performance over 10 times of random selection of the noise node sets, similar to the settings in the preliminary study in Section 2. We report the node classification test accuracy on abnormal (noisy) features and normal features in Figure 5 and Figure 6, separately, under varying noisy ratio. From these figures, we can observe:
+
+• Figure 5 shows that AirGNN significantly outperforms all baselines on all datasets in terms of the performance on noisy nodes. This verifies that AMP is able to improve the resilience to noisy features, aligning well with the design motivation.   
+• Figure 6 shows that AirGNN promotes the performance on normal nodes when abnormal nodes exist. This is because AMP can remove some abnormal features which are detrimental to normal nodes.
+
+![](images/cb981f452a6f87e6cccc28935d8e1aa89643dc8d85a1008f917f9b4fedf8a508.jpg)  
+Figure 5: Node classification accuracy on abnormal (noisy) nodes
+
+# 4.3 Performance Comparison with Adversarial Features
+
+In this subsection, we consider the abnormal feature scenario when the node features are maliciously attacked by the attacker to manipulate the prediction of GNNs. We use the Nettack [26] implemented in DeepRobust3 [27], a PyTorch library for adversarial attacks and defenses, to generate the adversarial features. We randomly choose 40 test nodes as the targeted nodes, and assess the performance under increasing perturbation budgets $\{ 0 , 5 , 1 0 , 2 0 , 5 0 , 8 0 \}$ , where the perturbation numbers denote the number of feature dimensions that can be manipulated. The node classification accuracy on these attacked nodes are showed in Figure 7. From these figures, we can make the following observations:
+
+![](images/521af9135379cb9d9a4e04bfd77d43979bb91c8146837931dfc5f87ae829d691.jpg)  
+Figure 6: Node classification accuracy on normal nodes
+
+• AirGNN is significantly more robust against adversarially attacked features than all baselines. MLP is the most vulnerable model, which demonstrates the usefulness of graph structure information in combating against abnormal node features.
+
+• The advantages of AirGNN over the baselines become much stronger with larger perturbation budgets. This suggests that AMP can significantly improve the resilience to abnormal features.
+
+![](images/b4a84b017c1ab3aee2d1fd5a97a59af3692c895e3672220068ba8be20564b118.jpg)  
+Figure 7: Node classification accuracy on adversarial nodes
+
+# 4.4 Adaptive Residual for Abnormal & Normal Nodes
+
+To further understand and verify how AMP and AirGNN work, we investigate the adaptive score $\beta _ { i }$ for each node $v _ { i }$ . Specifically, the average adaptive scores for abnormal nodes and normal nodes in the last layer of AMP are computed separately. In the noisy feature scenario, we fix ratio of noisy nodes as $10 \%$ . In the adversarial feature scenario, we choose 40 target nodes and fix the perturbation number as 80. The results in noisy and adversarial feature scenarios are showed in Table 1 and Table 2, respectively. From these tables, we can observe:
+
+• On the one hand, it can be clearly observed that in both scenarios, the average adaptive scores for abnormal nodes are significantly higher than those for normal nodes. Therefore, it verifies our intuition that large adaptive scores are strongly related to abnormal features. • On the other hand, it also implies that the residual weights (i.e., $1 - \beta _ { i } )$ for abnormal nodes are much lower than those of normal nodes. This perfectly aligns with our motivation to remove abnormal features by reducing their residual connections.
+
+The study on adaptive scores verifies how the adaptive residuals in AMP and AirGNN work as designed. It corroborates that AirGNN not only tremendously boosts the resilience to abnormal features but also provides interpretable information for anomaly detection that will be useful in many security-critical scenarios since the adaptive score serves as a good indicator of abnormal nodes. Morever, it is expected that APPNP without residual will perform well on abnormal nodes but it will sacrifice the performance on normal nodes. We provide detailed comparison with APPNP w/Res and APPNP wo/Res in Appendix D.3 to show the advantages of adaptive residual of AirGNN.
+
+Table 1: Average adaptive score $( \beta )$ and residual weight $( 1 - \beta )$ in the noisy feature scenario.   
+
+<table><tr><td>Measure</td><td>Cora</td><td>CiteSeer</td><td>PubMed</td></tr><tr><td>Average adaptive score for abnormal nodes</td><td>0.998 ± 0.000</td><td>0.988 ± 0.000</td><td>0.996 ± 0.000</td></tr><tr><td>Average adaptive score for normal nodes Average residual weight for abnormal nodes</td><td>0.924 ± 0.002 0.002 ±0.000</td><td>0.807 ± 0.005 0.012 ± 0.000</td><td>0.869 ± 0.006</td></tr><tr><td>Average residual weight for normal nodes</td><td>0.076 ± 0.002</td><td>0.193 ± 0.005</td><td>0.004±0.000 0.131 ± 0.006</td></tr></table>
+
+Table 2: Average adaptive score $( \beta )$ and residual weight $( 1 - \beta )$ in the adversarial feature scenario.   
+
+<table><tr><td>Measure</td><td>Cora</td><td>CiteSeer</td><td>PubMed</td></tr><tr><td>Average adaptive score for abnormal nodes Average adaptive score for normal nodes</td><td>0.987 ±0.000</td><td>0.930 ± 0.007</td><td>0.959 ± 0.005</td></tr><tr><td>Average residual weight for abnormal nodes</td><td>0.922 ± 0.004</td><td>0.689 ± 0.024</td><td>0.826 ± 0.016</td></tr><tr><td></td><td>0.013 ±0.000</td><td>0.070±0.007</td><td>0.041 ±0.005</td></tr><tr><td>Average residual weight for normal nodes</td><td>0.078 ± 0.004</td><td>0.311 ± 0.024</td><td>0.174 ± 0.016</td></tr></table>
+
+# 5 Related Work
+
+GNNs generalize convolutional neural networks (CNN) to graph structure data through the message passing framework [1, 2, 7]. The design of message passing and GNN architectures are majorly motivated in spectral domain [3, 4] and spatial domain [5, 6, 7, 2]. Recent works have shown that the message passing in GNNs can be regarded as low-pass graph filters [12, 13]. More generally, it has been proven that message passing in many GNNs can be uniformly derived from graph signal denoising [11, 28, 29, 30]. Classic GNNs such as GCN [3] and GAT [6] achieve their best performance with shallow models, but their performance degrades when stacking more layers, which can be partially explained through oversmoothing analyses [14, 15]. Recent works propose to use residual connections or skip connections to mitigate the oversmoothing issues, and they demonstrate the potential benefits from more feature aggregations. Examples include but not limited to DeepGCNs [31], JKNet [32], GCNII [9], APPNP [10] and DeeperGNN [20]. These models use global residual connection that can not be adaptive for each node, which significantly differ from the proposed AirGNN.
+
+Recently, there are growing interests in reducing GNNs’ vulnerability to the graph structure noise, such as Robust GCN [24], GCN-SVD [33], Pro-GNN [34], IDGL [35], ElasticGNN [36], etc. Please refer to the comprehensive surveys [37, 38] for more details. However, how to design GNNs with strong resilience to abnormal node features remains to be developed. To the best of our knowledge, AirGNN is the first GNN model that is intrinsically robust to many types of abnormal node features by design. It improves the performance in various kinds of abnormal scenarios without needing to sacrifice clean accuracy in normal settings.
+
+# 6 Conclusion
+
+In this work, we discover an intrinsic tension between feature aggregation and residual connection in the message passing scheme of GNNs, as well as the corresponding performance tradeoff between nodes with abnormal and normal features. We analyze possible reasons to explain these findings from the perspective of graph Laplacian smoothing. Our understandings further motivate us to propose a simple, efficient, interpretable and adaptive message passing scheme as well as a new GNN model with adaptive residual, named AirGNN. AirGNN provides a node-wise adaptive transition between feature aggregation and residual connection, and the significant advantages of AirGNN are demonstrated through extensive experiments.
+
+# Acknowledgments and Disclosure of Funding
+
+This research is supported by the National Science Foundation (NSF) under grant numbers IIS1714741, CNS1815636, IIS1845081, IIS1907704, DRL2025244, IIS1928278, IIS1955285,
+
+IOS2107215, IOS2035472 and Army Research Office (ARO) under grant number W911NF-21- 1-0198.
+
+# Societal Impact and Limitations
+
+The methodology proposed in this paper might have significant positive societal impact since it reduces machine learning models’ vulnerability to abnormal datasets that generally exist in real-world applications, especially in many security-critical scenarios. In practice, for a given graph, we do not have the prior knowledge about if the graph is clean, has noisy features or adversarial features. Therefore, algorithms like the proposed AirGNN that can work under both the clean and various abnormal feature settings are appealing. While we are unaware of any potential negative society impact, we point out two limitations of this work: (1) this paper focuses on abnormal node features and has not evaluated the performance of the proposed method when the dataset contains both abnormal node features and edges; (2) it is unclear how it performs on heterophilic graphs. It will be interesting to investigate these problems in future works.
+
+# References
+
+[1] Yao Ma and Jiliang Tang. Deep Learning on Graphs. Cambridge University Press, 2020.   
+[2] Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In International Conference on Machine Learning, pages 1263–1272. PMLR, 2017.   
+[3] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.   
+[4] Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In Proceedings of the 30th International Conference on Neural Information Processing Systems, pages 3844–3852, 2016.   
+[5] William L Hamilton, Rex Ying, and Jure Leskovec. Inductive representation learning on large graphs. arXiv preprint arXiv:1706.02216, 2017.   
+[6] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.   
+[7] 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.   
+[8] Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. A comprehensive survey on graph neural networks. IEEE transactions on neural networks and learning systems, 2020.   
+[9] Ming Chen, Zhewei Wei, Zengfeng Huang, Bolin Ding, and Yaliang Li. Simple and deep graph convolutional networks. In Hal Daumé III and Aarti Singh, editors, Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 1725–1735. PMLR, 13–18 Jul 2020.   
+[10] Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. arXiv preprint arXiv:1810.05997, 2018.   
+[11] Yao Ma, Xiaorui Liu, Tong Zhao, Yozen Liu, Jiliang Tang, and Neil Shah. A unified view on graph neural networks as graph signal denoising. Proceedings of the 30th ACM International Conference on Information and Knowledge Management, 2021.   
+[12] Hoang Nt and Takanori Maehara. Revisiting graph neural networks: All we have is low-pass filters. arXiv preprint arXiv:1905.09550, 2019.   
+[13] Lingxiao Zhao and Leman Akoglu. Pairnorm: Tackling oversmoothing in gnns. In International Conference on Learning Representations, 2019.   
+[14] Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018.   
+[15] Kenta Oono and Taiji Suzuki. Graph neural networks exponentially lose expressive power for node classification. In International Conference on Learning Representations, 2020.   
+[16] Stephen Boyd and Lieven Vandenberghe. Convex optimization. Cambridge university press, 2004.   
+[17] Miller McPherson, Lynn Smith-Lovin, and James M Cook. Birds of a feather: Homophily in social networks. Annual review of sociology, 27(1):415–444, 2001.   
+[18] Xiaojin Zhu and Zoubin Ghahramani. Learning from labeled and unlabeled data with label propagation.   
+[19] Dengyong Zhou, Olivier Bousquet, Thomas Navin Lal, Jason Weston, and Bernhard Schölkopf. Learning with local and global consistency. 2004.   
+[20] Meng Liu, Hongyang Gao, and Shuiwang Ji. Towards deeper graph neural networks. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining. ACM, 2020.   
+[21] Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina EliassiRad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.   
+[22] Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Günnemann. Pitfalls of graph neural network evaluation. arXiv preprint arXiv:1811.05868, 2018.   
+[23] Marinka Zitnik Yuxiao Dong Hongyu Ren Bowen Liu Michele Catasta Jure Leskovec Weihua Hu, Matthias Fey. Open graph benchmark: Datasets for machine learning on graphs. arXiv preprint arXiv:2005.00687, 2020.   
+[24] Dingyuan Zhu, Ziwei Zhang, Peng Cui, and Wenwu Zhu. Robust graph convolutional networks against adversarial attacks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1399–1407, 2019.   
+[25] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+[26] Daniel Zügner, Amir Akbarnejad, and Stephan Günnemann. Adversarial attacks on neural networks for graph data. In KDD. ACM, 2018.   
+[27] Yaxin Li, Wei Jin, Han Xu, and Jiliang Tang. Deeprobust: A pytorch library for adversarial attacks and defenses, 2020.   
+[28] Xuran Pan, Song Shiji, and Huang Gao. A unified framework for convolution-based graph neural networks. https://openreview.net/forum?id=zUMD–Fb9Bt, 2020.   
+[29] Meiqi Zhu, Xiao Wang, Chuan Shi, Houye Ji, and Peng Cui. Interpreting and unifying graph neural networks with an optimization framework, 2021.   
+[30] Siheng Chen, Yonina C. Eldar, and Lingxiao Zhao. Graph unrolling networks: Interpretable neural networks for graph signal denoising, 2020.   
+[31] Guohao Li, Matthias Müller, Ali Thabet, and Bernard Ghanem. Deepgcns: Can gcns go as deep as cnns? In The IEEE International Conference on Computer Vision (ICCV), 2019.   
+[32] Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation learning on graphs with jumping knowledge networks. In Jennifer Dy and Andreas Krause, editors, Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 5453–5462. PMLR, 10–15 Jul 2018.   
+[33] Negin Entezari, Saba A Al-Sayouri, Amirali Darvishzadeh, and Evangelos E Papalexakis. All you need is low (rank) defending against adversarial attacks on graphs. In Proceedings of the 13th International Conference on Web Search and Data Mining, pages 169–177, 2020.   
+[34] Wei Jin, Yao Ma, Xiaorui Liu, Xianfeng Tang, Suhang Wang, and Jiliang Tang. Graph structure learning for robust graph neural networks. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 66–74, 2020.   
+[35] Yu Chen, Lingfei Wu, and Mohammed Zaki. Iterative deep graph learning for graph neural networks: Better and robust node embeddings. Advances in Neural Information Processing Systems, 33, 2020.   
+[36] Xiaorui Liu, Wei Jin, Yao Ma, Yaxin Li, Hua Liu, Yiqi Wang, Ming Yan, and Jiliang Tang. Elastic graph neural networks. In Marina Meila and Tong Zhang, editors, Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pages 6837–6849. PMLR, 18–24 Jul 2021.   
+[37] Wei Jin, Yaxing Li, Han Xu, Yiqi Wang, Shuiwang Ji, Charu Aggarwal, and Jiliang Tang. Adversarial attacks and defenses on graphs. ACM SIGKDD Explorations Newsletter, 22(2):19– 34, 2021.   
+[38] Yanqiao Zhu, Weizhi Xu, Jinghao Zhang, Qiang Liu, Shu Wu, and Liang Wang. Deep graph structure learning for robust representations: A survey. arXiv preprint arXiv:2103.03036, 2021.   
+[39] Laurent Condat. A primal–dual splitting method for convex optimization involving lipschitzian, proximable and linear composite terms. Journal of optimization theory and applications, 158(2):460–479, 2013.   
+[40] Fan RK Chung and Fan Chung Graham. Spectral graph theory. Number 92. American Mathematical Soc., 1997.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [No]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [No]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/hfkER_KJiNw/hfkER_KJiNw_content_list.json

@@ -0,0 +1,1577 @@
+[
+    {
+        "type": "text",
+        "text": "Graph Neural Networks with Adaptive Residual ",
+        "text_level": 1,
+        "bbox": [
+            205,
+            122,
+            794,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xiaorui Liu1 xiaorui@msu.edu ",
+        "bbox": [
+            232,
+            200,
+            364,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jiayuan Ding1 dingjia5@msu.edu ",
+        "bbox": [
+            428,
+            200,
+            568,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wei Jin1 jinwei2@msu.edu ",
+        "bbox": [
+            633,
+            200,
+            764,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Han Xu1 xuhan1@msu.edu ",
+        "bbox": [
+            187,
+            250,
+            308,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yao Ma2 yao.ma@njit.edu ",
+        "bbox": [
+            331,
+            250,
+            460,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zitao Liu3 liuzitao@100tal.com ",
+        "bbox": [
+            488,
+            250,
+            643,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jiliang Tang1 tangjili@msu.edu ",
+        "bbox": [
+            669,
+            250,
+            808,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Michigan State University, East Lansing, MI, USA 2New Jersey Institute of Technology, Newark, NJ, USA 3TAL Education Group, Beijing, China ",
+        "bbox": [
+            315,
+            296,
+            681,
+            339
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            375,
+            535,
+            391
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph neural networks (GNNs) have shown the power in graph representation learning for numerous tasks. In this work, we discover an interesting phenomenon that although residual connections in the message passing of GNNs help improve the performance, they immensely amplify GNNs’ vulnerability against abnormal node features. This is undesirable because in real-world applications, node features in graphs could often be abnormal such as being naturally noisy or adversarially manipulated. We analyze possible reasons to understand this phenomenon and aim to design GNNs with stronger resilience to abnormal features. Our understandings motivate us to propose and derive a simple, efficient, interpretable, and adaptive message passing scheme, leading to a novel GNN with Adaptive residual, AirGNN1. Extensive experiments under various abnormal feature scenarios demonstrate the effectiveness of the proposed algorithm. ",
+        "bbox": [
+            233,
+            406,
+            766,
+            571
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            597,
+            310,
+            614
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent years have witnessed the great success of graph neural networks (GNNs) in representation learning for graph structure data [1]. Essentially, GNNs generalize deep neural networks (DNNs) from regular grids, such as image, video and text, to irregular data such as social, energy, transportation, citation, and biological networks. Such data can be naturally represented as graphs with nodes and edges. The key building block for such generalization is the neural message passing framework [2]: ",
+        "bbox": [
+            173,
+            628,
+            825,
+            699
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6f9e56a3d9b3fdbb7f89623ce9d7ae036869e671c7b87fc24582e7a11728195c.jpg",
+        "text": "$$\n\\mathbf { x } _ { u } ^ { ( k + 1 ) } = \\mathrm { U P D A T E } ^ { ( k ) } \\left( \\mathbf { x } _ { u } ^ { ( k ) } , \\mathbf { m } _ { \\mathcal { N } ( u ) } ^ { ( k ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            704,
+            620,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "where x(ku $\\mathbf { x } _ { u } ^ { ( k ) } \\in \\mathbb { R } ^ { d }$ denotes the feature vector of node $u$ in the $k$ -th iteration of message passing, and $\\mathbf { m } _ { \\mathcal { N } ( u ) } ^ { ( k ) }$ is the message aggregated from $u$ ’s neighborhood $\\mathcal { N } ( u )$ . The specific design of message passing scheme can be motivated from spectral domain [3, 4] or spatial domain [5, 6, 7, 2]. It usually linearly smooths the features in a local neighborhood on the graph. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            801
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "GNNs have achieved superior performance in a large number of benchmark datasets [8] where the node features are assumed to be complete and informative. However, in real-world applications, some node features could be abnormal from various aspects. For instance, in social networks, new users might not have complete profile before they make connections with others, leading to missing user features. In transportation networks, node features can be noisy since there exist certain uncertainty and dynamics in the observation of the traffic information. What is worse, node features can be adversarially chosen by the attacker to maliciously manipulate the prediction made by GNNs. Therefore, it is greatly desired to design GNN models with stronger resilience to abnormal node features. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            877
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we first perform empirical investigations on how representative GNN models behave on graphs with abnormal features. Specifically, based upon standard benchmark datasets, we simulate the abnormal features by replacing the features of randomly selected nodes with random Gaussian noise. Then the performance of node classification on abnormal features and normal features are examined separately. From our preliminary study in Section 2, we reveal two interesting observations: (1) Feature aggregation can boost the resilience to abnormal features, but too many aggregations could hurt the performance on both normal and abnormal features; and (2) Residual connection helps GNNs benefit from more layers for normal features, while making GNNs more fragile to abnormal features. We then provide possible explanations to understand these observed phenomena from the perspective of graph Laplacian smoothing. Our analyses imply that there might exist an intrinsic tension between feature aggregation and residual connection, which results in a performance tradeoff between normal features and abnormal features. ",
+        "bbox": [
+            173,
+            154,
+            825,
+            319
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Motivated by these findings and understandings, we aim to design new GNNs with stronger resilience to abnormal features while largely maintaining the performance on normal features. Our contributions can be summarized as follows: ",
+        "bbox": [
+            176,
+            325,
+            825,
+            367
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We discover an intrinsic tension between feature aggregation and residual connection in GNNs, and the corresponding performance tradeoff between abnormal and normal features. We also analyze possible reasons to explain and understand these findings.   \n• We propose a simple, efficient, principled and adaptive message passing scheme, which leads to a novel GNN model with adaptive residual, named as AirGNN.   \n• Extensive experiments under various abnormal feature scenarios demonstrate the superiority of the proposed algorithm. The ablation study demonstrates how the adaptive residuals mitigate the impact of abnormal features. ",
+        "bbox": [
+            194,
+            378,
+            826,
+            498
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Preliminary ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            516,
+            305,
+            534
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Before introducing the preliminary study, we first define the notations used throughout the paper. ",
+        "bbox": [
+            173,
+            546,
+            805,
+            563
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Notations. We use bold upper-case letters such as $\\mathbf { X }$ to denote matrices. Given a matrix $\\mathbf { X } \\in \\mathbb { R } ^ { n \\times d }$ , we use $\\mathbf { X } _ { i }$ to denote its $i$ -th row and $\\mathbf { X } _ { i j }$ to denote its element in $i$ -th row and $j$ -th column. The Frobenius norm and $\\ell _ { 2 1 }$ norm of a matrix $\\mathbf { X }$ are defined as $\\Vert \\mathbf { X } \\Vert _ { F } = \\sqrt { \\sum _ { i j } \\mathbf { X } _ { i j } ^ { 2 } }$ and $\\| \\mathbf { X } \\| _ { 2 1 } =$ $\\begin{array} { r } { \\sum _ { i } \\| \\mathbf { X } _ { i } \\| _ { 2 } = \\sum _ { i } \\sqrt { \\sum _ { j } \\mathbf { X } _ { i j } ^ { 2 } } } \\end{array}$ , respectively. We define $\\| \\mathbf { X } \\| _ { 2 } = \\sigma _ { \\operatorname* { m a x } } ( \\mathbf { X } )$ where $\\sigma _ { \\mathrm { m a x } } ( \\mathbf { X } )$ is the largest singular value of $\\mathbf { X }$ . ",
+        "bbox": [
+            173,
+            568,
+            825,
+            659
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathcal { G } = \\{ \\nu , \\mathcal { E } \\}$ be a graph with the node set $\\mathcal { V } = \\{ v _ { 1 } , \\ldots , v _ { n } \\}$ and the undirected edge set $\\mathcal { E } = \\{ e _ { 1 } , \\ldots , e _ { m } \\}$ . We use $\\mathcal { N } ( v _ { i } )$ to denote the neighboring nodes of node $v _ { i }$ , including $v _ { i }$ itself. Suppose that each node is associated with a $d$ -dimensional feature vector, and the features for all nodes are denoted as $\\mathbf { X } _ { \\mathrm { f e a } } \\in \\mathbb { R } ^ { n \\times d }$ . The graph structure $\\mathcal { G }$ can be represented as an adjacent matrix $\\mathbf { A } \\in \\mathbb { R } ^ { n \\times n }$ , where $\\mathbf { A } _ { i j } ~ = ~ 1$ when there exists an edge between nodes $v _ { i }$ and $v _ { j }$ , and $\\mathbf { A } _ { i j } \\ = \\ 0$ otherwise. The graph Laplacian matrix is defined as $\\mathbf { L } = \\mathbf { D } - \\mathbf { A }$ , where $\\mathbf { D }$ is the diagonal degree matrix. Let us denote the commonly used feature aggregation matrix in GNNs [3] as $\\tilde { \\bf A } = \\hat { \\bf D } ^ { - \\frac { 1 } { 2 } } \\bar { \\hat { \\bf A } } \\hat { \\bf D } ^ { - \\frac { 1 } { 2 } }$ where $\\hat { \\mathbf { A } } = \\mathbf { A } + \\mathbf { I }$ is the adjacent matrix with self-loop and its degree matrix is $\\hat { \\bf D }$ . The corresponding Laplacian matrix is defined as $\\tilde { \\mathbf { L } } = \\mathbf { I } - \\tilde { \\mathbf { A } }$ . ",
+        "bbox": [
+            173,
+            664,
+            825,
+            794
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on the setting where a subset of nodes in the graph contain abnormal features, while the remaining nodes have normal features. In the remaining of this paper, we use abnormal/normal features to denote nodes with abnormal/normal features, for simplicity. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            842
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Preliminary Study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            857,
+            341,
+            872
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Experimental setup. To investigate how GNNs behave on abnormal and normal node features, we design semi-supervised node classification experiments on three common datasets (i.e., Cora, ",
+        "bbox": [
+            173,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "CiteSeer and PubMed), following the data splits in the work [3]. Moreover, we simulate the abnormal features by assigning $1 0 \\%$ of the nodes with random features sampled from a standard Gaussian distribution. The experiments are performed on representative GNN models covering coupled and decoupled architectures, including GCN [3], GCNII [9], APPNP [10], and their variants with or without residual connections in feature aggregations, denoted as w/Res and wo/Res. All methods follow the hyperparameter settings in their original papers. We examine how these models perform when the number of layers increases. Note that for the decoupled architectures such as APPNP, we fix the 2-layer MLP and increase the number of propagation layers. While for the coupled architectures such as GCN and GCNII, we increase the number of feature transformation and propagation layers simultaneously. We report the average performance over 10 times of random selection of the noise node sets. The node classification accuracy (mean and standard variance) on nodes with abnormal and normal features is illustrated in Figure 1 and Figure. 2, separately. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            257
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/00d120485edd7da85f1457dd4c00230b18d99c238c177b5cb16e29a69a61afb9.jpg",
+        "image_caption": [
+            "Figure 1: Node classification accuracy on abnormal nodes (Cora) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            280,
+            812,
+            415
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/08499e09f3e29a9b457146ea9c203108450fafd94446152fa1b7aada0f5024ce.jpg",
+        "image_caption": [
+            "Figure 2: Node classification accuracy on normal nodes (Cora) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            474,
+            812,
+            613
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Observations. From Figure 1 and Figure 2, we can make the following observations: (1) Without residual connection, more layers (e.g., $> 2$ for GCN and GCNII, $> 1 0$ for APPNP) hurt the accuracy on nodes with normal features. However, more layers boost the accuracy on nodes with abnormal features significantly, before finally starting to decrease; (2) With residual connection, the accuracy on nodes with normal features keeps increasing with more layers2. However, the accuracy on nodes with abnormal features only increases marginally when stacking more layers, and then starts to decrease. While we only present the experiments on Cora, we defer the results on other datasets to Appendix C, which provide similar observations. To conclude, we can summarize these observations into two major findings: ",
+        "bbox": [
+            173,
+            657,
+            825,
+            782
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Finding I: Feature aggregation can boost the resilience to abnormal features, but too many aggregations could hurt the performance on both normal and abnormal nodes; ",
+        "bbox": [
+            191,
+            797,
+            823,
+            825
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Finding II: Residual connection helps GNNs benefit from more layers for nodes with normal features, while making GNNs more fragile to abnormal features. ",
+        "bbox": [
+            192,
+            837,
+            820,
+            864
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Understandings ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            323,
+            106
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we provide the understanding and explanation for aforementioned findings, from the perspective of graph Laplacian smoothing. ",
+        "bbox": [
+            173,
+            116,
+            823,
+            145
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Understanding Finding I: Feature aggregation as Laplacian smoothing ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            150,
+            669,
+            166
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The message passing in GCN [3], GCNII wo/ residual and APPNP wo/ residual (as well as many popular GNN models), follows the feature aggregation ",
+        "bbox": [
+            174,
+            171,
+            825,
+            200
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5be41b7d9771905b48713d3d8dca4d437d51c9c6e6be8231f4869bf05b49f235.jpg",
+        "text": "$$\n\\mathbf { X } _ { \\mathrm { o u t } } = \\tilde { \\mathbf { A } } \\mathbf { X } _ { \\mathrm { i n } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            449,
+            205,
+            547,
+            224
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\bf X } _ { \\mathrm { i n } }$ and $\\mathbf { X _ { o u t } }$ represent the features before and after message passing layer, respectively. It can be interpreted as one gradient descent step for the Laplacian smoothing problem [11] ",
+        "bbox": [
+            166,
+            231,
+            823,
+            260
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a8ba35e5f2a5c87dc5a4f1ef62b9e0fcb76a09d3a2e3b4ba8193f99725d8ad32.jpg",
+        "text": "$$\n\\underset { \\mathbf { X } \\in \\mathbb { R } ^ { n \\times d } } { \\arg \\operatorname* { m i n } } \\mathcal { L } _ { 1 } ( \\mathbf { X } ) : = \\frac { 1 } { 2 } \\mathrm { t r } \\Big ( \\mathbf { X } ^ { \\top } ( \\mathbf { I } - \\tilde { \\mathbf { A } } ) \\mathbf { X } \\Big ) = \\frac { 1 } { 2 } \\sum _ { ( v _ { i } , v _ { j } ) \\in \\mathcal { E } } \\| \\frac { \\mathbf { X } _ { i } } { \\sqrt { d _ { i } + 1 } } - \\frac { \\mathbf { X } _ { j } } { \\sqrt { d _ { j } + 1 } } \\| _ { 2 } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            225,
+            263,
+            769,
+            305
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $d _ { i }$ is the node degree of node $v _ { i }$ . Eq. (2) can be derived from $\\mathbf { X } _ { \\mathrm { o u t } } = \\mathbf { X } _ { \\mathrm { i n } } - ( \\mathbf { I } - \\tilde { \\mathbf { A } } ) \\mathbf { X } _ { \\mathrm { i n } } = \\tilde { \\mathbf { A } } \\mathbf { X } _ { \\mathrm { i n } }$ , with the initialization $\\mathbf { X } = \\mathbf { X } _ { \\mathrm { i n } }$ and stepsize $\\gamma = 1$ . The Laplacian smoothing problem penalizes the feature difference between neighboring nodes. To reduce this penalty, the feature aggregation in Eq. (2) smooths the node features by taking the average of local neighbors, and thus can be considered as low-pass filter which gradually filters out high-frequency signals [12, 13]. Therefore, it increases the resilience to abnormal features which are likely to be high-frequency signals. In other words, the local neighboring nodes help to correct the abnormal features. Unfortunately, if applied too many times, these low-pass filters could overly smooth the features (well-known as oversmoothing [14, 15]) such that nodes are not distinguishable enough, providing an explanation to the degraded performance on both abnormal and normal features when stacking too many layers. ",
+        "bbox": [
+            173,
+            313,
+            825,
+            452
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Understanding Finding II: Residual connection maintains feature proximity ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            458,
+            704,
+            473
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To adjust the feature smoothness for better performance, APPNP [10] utilizes residual connections in message passing as follows ",
+        "bbox": [
+            173,
+            478,
+            823,
+            507
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4bd63d5a2bf0fef5bca13df83fe1b77403e60662228148abd44885dde98f7b30.jpg",
+        "text": "$$\n\\mathbf { X } ^ { k + 1 } = ( 1 - \\alpha ) \\tilde { \\mathbf { A } } \\mathbf { X } ^ { k } + \\alpha \\mathbf { X _ { \\mathrm { i n } } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            512,
+            602,
+            531
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\bf X } ^ { 0 } = { \\bf X } _ { \\mathrm { i n } }$ . It can be considered as an iterative solution for the regularized Laplacian smoothing problem [11] ",
+        "bbox": [
+            173,
+            539,
+            825,
+            569
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dc684fa92c8954def72ee007cc1a50155f45d52e5b35867cbf9e129b802e67a4.jpg",
+        "text": "$$\n\\underset { { \\substack { \\mathbf { X } \\in \\mathbb { R } ^ { n \\times d } } } } { \\arg \\operatorname* { m i n } } \\ \\mathcal { L } _ { 2 } ( { \\mathbf { X } } ) : = \\frac { \\alpha } { 2 ( 1 - \\alpha ) } \\| \\mathbf { X } - \\mathbf { X } _ { \\mathrm { i n } } \\| _ { F } ^ { 2 } + \\frac { 1 } { 2 } \\mathrm { t r } \\Big ( \\mathbf { X } ^ { \\top } ( { \\mathbf { I } } - \\tilde { \\mathbf { A } } ) \\mathbf { X } \\Big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            573,
+            722,
+            608
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "with initialization $\\mathbf { X } = \\mathbf { X } _ { \\mathrm { i n } }$ and stepsize $\\gamma = 1 - \\alpha$ due to ",
+        "bbox": [
+            173,
+            613,
+            557,
+            628
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b21d10dc68f05ed9a814f9fe8eb81efce214601248cf9f4bc15d2afa481cfc3d.jpg",
+        "text": "$$\n\\mathbf { X } ^ { k + 1 } = \\mathbf { X } ^ { k } - ( 1 - \\alpha ) \\bigg ( \\frac { \\alpha } { 1 - \\alpha } ( \\mathbf { X } ^ { k } - \\mathbf { X _ { \\mathrm { i n } } } ) + ( \\mathbf { I } - \\tilde { \\mathbf { A } } ) \\mathbf { X } ^ { k } \\bigg ) = ( 1 - \\alpha ) \\tilde { \\mathbf { A } } \\mathbf { X } ^ { k } + \\alpha \\mathbf { X _ { \\mathrm { i n } } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            632,
+            782,
+            662
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "GCNII [9] adopts a similar message passing but further combines a feature transformation layer in each message passing step, which leads to a coupled architecture, as contrast to the decoupled architecture of APPNP. The residual connection naturally arises when regularizing the proximity between input and output features, as showed in the first term of $\\mathcal { L } _ { 2 } ( \\mathbf { X } )$ . Such proximity can help avoid the trivial solution for the problem in Eq. (3), i.e., totally oversmoothed features only depending on node degrees, and consequently mitigates the oversmoothing issue. More intuitively, residual connections in GNNs provide direct information flows between layers that can preserve some necessary high-frequency signals for better discrimination between classes. More layers with residual provide a more accurate solution to Eq. (5), which explains the performance gain from deeper GNNs. Unfortunately, these residual connections also undesirably carry on abnormal features which are detrimental, leading to the inferior performance on abnormal features. ",
+        "bbox": [
+            173,
+            666,
+            826,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 The Proposed Framework ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            838,
+            424,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first motivate the proposed adaptive message passing scheme (AMP) with further discussions on our preliminary study. We then introduce more details about AMP, its interpretations, convergence guarantee and computation complexity, as well as the model architecture of AirGNN. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Design Motivation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            341,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our preliminary study in Section 2 reveals an intrinsic tension between feature aggregation and residual connection: (1) feature aggregation helps smooth out abnormal features, while it could cause inappropriate smoothing for normal features; (2) residual connection is essential for adjusting the feature smoothness, but it could be detrimental for abnormal features. Although this conflict can be partially mitigated by adjusting the residual connection such as the residual weight $\\alpha$ in GCNII [9] and APPNP [10], such global adjustment cannot be adaptive to a subset of the nodes, e.g., the nodes with abnormal features. This is crucial because in practice we often encounter the scenario where only a subset of nodes contain abnormal features. Therefore, how to reconcile this dilemma still desires dedicated efforts. We then naturally ask a question: Can we design a better message passing scheme with node-wise adaptive feature aggregation and residual connection? ",
+        "bbox": [
+            173,
+            116,
+            825,
+            256
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The motivation of the proposed idea builds upon the following intuition: while it is important to maintain the proximity between input and output features as in Eq. (5), it could be over aggressive to penalize their deviations by the square of Frobenius norm, i.e., $\\begin{array} { r } { \\| \\dot { \\bf X } - \\dot { \\bf X } _ { \\mathrm { i n } } \\| _ { F } ^ { 2 } = \\sum _ { i = 1 } ^ { n } \\| \\dot { \\bf X } _ { i } - ( { \\bf X } _ { \\mathrm { i n } } ) _ { i } \\| _ { 2 } ^ { 2 } } \\end{array}$ The fact that this penalty does not tolerate large deviations weakens the capability to remove abnormal features through Laplacian smoothing. This motivates us to consider an alternative proximity penalty ",
+        "bbox": [
+            173,
+            260,
+            825,
+            332
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2f28e684de6375dcb669923823ae95ee31b28bb7d9ad48bed4a2a0043c2958b9.jpg",
+        "text": "$$\n\\| { \\bf X } - { \\bf X } _ { \\mathrm { i n } } \\| _ { 2 1 } : = \\sum _ { i = 1 } ^ { n } \\| { \\bf X } _ { i } - ( { \\bf X } _ { \\mathrm { i n } } ) _ { i } \\| _ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            334,
+            624,
+            376
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "which instead penalizes the deviations by the $\\ell _ { 1 }$ norm of row-wise $\\ell _ { 2 }$ norms, namely $\\ell _ { 2 1 }$ norm. The $\\ell _ { 2 1 }$ norm promotes row sparsity in $\\mathbf { X } - \\mathbf { X } _ { \\mathrm { i n } }$ , and it also allows large deviations because the penalty on large values is less aggressive, leading to the potential removal of abnormal features. Therefore, we propose the following Laplacian smoothing problem regularized by $\\ell _ { 2 1 }$ norm proximity control: ",
+        "bbox": [
+            173,
+            378,
+            825,
+            435
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b26e0b4245ae411a1f22ecbedf9e93e2abbac5e9c18379c4b68de77e7bd76391.jpg",
+        "text": "$$\n\\underset { \\mathbf { X } \\in \\mathbb { R } ^ { n \\times d } } { \\arg \\operatorname* { m i n } } \\lambda \\| \\mathbf { X } - \\mathbf { X } _ { \\mathrm { i n } } \\| _ { 2 1 } + \\frac { 1 } { 2 } \\mathrm { t r } ( \\mathbf { X } ^ { \\top } ( \\mathbf { I } - \\tilde { \\mathbf { A } } ) \\mathbf { X } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            438,
+            655,
+            473
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda \\in [ 0 , \\infty )$ is a parameter to adjust the balance between proximity and Laplacian smoothing. In order to easy the tuning of $\\lambda$ , we made a modification of Eq. (7): ",
+        "bbox": [
+            171,
+            477,
+            823,
+            506
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1e2687fdb8986a4f9b310d05308855779adba69c619b7a25128f76c35752f2d4.jpg",
+        "text": "$$\n\\underset { \\mathbf { X } \\in \\mathbb { R } ^ { n \\times d } } { \\arg \\operatorname* { m i n } } \\ \\mathcal { L } ( \\mathbf { X } ) : = \\lambda \\| \\mathbf { X } - \\mathbf { X _ { \\mathrm { i n } } } \\| _ { 2 1 } + ( 1 - \\lambda ) \\mathrm { t r } ( \\mathbf { X } ^ { \\top } ( \\mathbf { I } - \\tilde { \\mathbf { A } } ) \\mathbf { X } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            510,
+            707,
+            537
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda \\in [ 0 , 1 ]$ controls the balance. ",
+        "bbox": [
+            174,
+            542,
+            419,
+            558
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Adaptive Message Passing ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            573,
+            397,
+            588
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/b9c08a90235cf9dc7aa82eaeface75a6b91e84c8306c75e6acc04630e39b84db.jpg",
+        "image_caption": [
+            "Figure 3: Diagram of Adaptive Message Passing "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            601,
+            754,
+            672
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\mathcal { L } ( \\mathbf { X } )$ is a composite objective with non-smooth and smooth components. We optimize it by proximal gradient descent [16] and obtain the following iterations as the adaptive message passing (AMP): ",
+        "bbox": [
+            168,
+            713,
+            823,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/04047c793794adee67acacd26cda21357adc84912531b7a797e778030c221957.jpg",
+        "text": "$$\n\\begin{array} { r l } { { \\displaystyle { \\bf Y } ^ { k } = { \\bf X } ^ { k } - 2 \\gamma ( 1 - \\lambda ) ( { \\bf I } - \\tilde { \\bf A } ) { \\bf X } ^ { k } = \\left( 1 - 2 \\gamma ( 1 - \\lambda ) \\right) { \\bf X } ^ { k } + 2 \\gamma ( 1 - \\lambda ) \\tilde { \\bf A } { \\bf X } ^ { k } } } & { { } { } { } } \\\\ { { \\displaystyle { \\bf X } ^ { k + 1 } = \\arg \\operatorname* { m i n } \\left\\{ \\lambda \\| { \\bf X } - { \\bf X } _ { \\mathrm { i n } } \\| _ { 2 1 } + \\frac { 1 } { 2 \\gamma } \\| { \\bf X } - { \\bf Y } ^ { k } \\| _ { F } ^ { 2 } \\right\\} } } & { { } { } { } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            746,
+            764,
+            801
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\bf X } ^ { 0 } = { \\bf X } _ { \\mathrm { i n } }$ and $\\gamma$ is the stepsize to be specified later. Let $\\mathbf { Z } = \\mathbf { X } - \\mathbf { X } _ { \\mathrm { i n } }$ , and Eq. (10) can be rewritten as: ",
+        "bbox": [
+            174,
+            804,
+            825,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/68fda391e9e91a1ee7340bf5b8ef9ec4653a491d169bc42f8f524ca1be439353.jpg",
+        "text": "$$\n\\begin{array} { r l } {  { \\mathbf { Z } ^ { k + 1 } = \\arg \\operatorname* { m i n } \\{ \\lambda \\| \\mathbf { Z } \\| _ { 2 1 } + \\frac { 1 } { 2 \\gamma } \\| \\mathbf { Z } - ( \\mathbf { Y } ^ { k } - \\mathbf { X } _ { \\mathrm { i n } } ) \\| _ { F } ^ { 2 } \\} } } \\\\ & { = \\mathbf { p r o x } _ { \\gamma \\lambda \\| \\cdot \\| _ { 2 1 } } ( \\mathbf { Y } ^ { k } - \\mathbf { X } _ { \\mathrm { i n } } ) } \\\\ & { \\mathbf { X } ^ { k + 1 } = \\mathbf { X } _ { \\mathrm { i n } } + \\mathbf { Z } ^ { k + 1 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            833,
+            684,
+            910
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The $i$ -th row of the proximal operator in Eq. (11) can be computed analytically ",
+        "bbox": [
+            173,
+            90,
+            691,
+            107
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2f99296051acdd82ba233470d0b60b0f2eed6592b1b372eecf8968426e2607f2.jpg",
+        "text": "$$\n\\left( \\mathbf { p r o x } _ { \\gamma \\lambda \\parallel \\cdot \\parallel _ { 2 1 } } ( \\mathbf { X } ) \\right) _ { i } = \\frac { \\mathbf { X } _ { i } } { \\parallel \\mathbf { X } _ { i } \\parallel _ { 2 } } \\operatorname* { m a x } ( \\parallel \\mathbf { X } _ { i } \\parallel _ { 2 } - \\gamma \\lambda , 0 ) = \\operatorname* { m a x } ( 1 - \\frac { \\gamma \\lambda } { \\parallel \\mathbf { X } _ { i } \\parallel _ { 2 } } , 0 ) \\cdot \\mathbf { X } _ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            109,
+            766,
+            143
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that the proximal operator returns 0 if the input vector is 0. Substituting $\\mathbf { X }$ in Eq. (13) with $\\mathbf { Y } ^ { k } - \\mathbf { X } _ { \\mathrm { i n } }$ and combining Eq. (11) and Eq. (12), then Eq. (12) becomes ",
+        "bbox": [
+            171,
+            147,
+            830,
+            176
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ddd1e17c5d829c98938c8b1388cd54b3e08aa5daae1060e5eac9a190d0f7b2f6.jpg",
+        "text": "$$\n\\mathbf { X } _ { i } ^ { k + 1 } = ( \\mathbf { X } _ { \\mathrm { i n } } ) _ { i } + \\beta _ { i } ( \\mathbf { Y } _ { i } ^ { k } - ( \\mathbf { X } _ { \\mathrm { i n } } ) _ { i } ) = ( 1 - \\beta _ { i } ) ( \\mathbf { X } _ { \\mathrm { i n } } ) _ { i } + \\beta _ { i } \\mathbf { Y } _ { i } ^ { k } , \\quad \\forall i \\in [ n ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            180,
+            746,
+            200
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\beta _ { i } : = \\operatorname* { m a x } ( 1 - \\frac { \\gamma \\lambda } { \\| \\mathbf { Y } _ { i } ^ { k } - ( \\mathbf { X } _ { \\mathrm { i n } } ) _ { i } \\| _ { 2 } } , 0 ) } \\end{array}$ . To summarize, the proposed adaptive message passing (AMP) scheme is showed in Figure 4, and a diagram is showed in Figure 3. In detail, AMP works as follows: ",
+        "bbox": [
+            174,
+            205,
+            825,
+            253
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• The first step takes a feature aggregation within the local neighbors with a self-loop weighted by $1 - 2 \\gamma ( 1 - \\lambda )$ ;   \n• The second step computes a weight $\\beta _ { i } \\in [ 0 , 1 ]$ for each node $v _ { i }$ depending on the local deviation $\\| { \\bf Y } _ { i } ^ { k } - ( { \\bf X } _ { \\mathrm { i n } } ) _ { i } \\| _ { 2 }$ .   \n• The final step takes a linear combination of input features $\\mathbf { X } _ { \\mathrm { i n } }$ and the aggregated features $\\mathbf { Y } ^ { k }$ , where the node-wise residual is adaptively weighted by $1 - \\beta _ { i }$ for each node $v _ { i }$ . ",
+        "bbox": [
+            194,
+            263,
+            826,
+            361
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/31b59335ec89ac9c9b7a99814a2a6a89348cd1cc224bfd947556babaafd3c58b.jpg",
+        "image_caption": [
+            "Figure 4: Adaptive Message Passing (AMP) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            385,
+            679,
+            486
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The convergence guarantee of AMP and parameter setting for the stepsize $\\gamma$ are illustrated in Theorem 1 and proved in Appendix A. According to Theorem 1, if we set γ = 14(1−λ) or γ = 12(1−λ) , then the first step of AMP can be simplified as $\\begin{array} { r } { \\mathbf { Y } ^ { k } = \\frac { 1 } { 2 } \\mathbf { X } ^ { k } + \\frac { 1 } { 2 } \\tilde { \\mathbf { A } } \\mathbf { X } ^ { k } } \\end{array}$ and $\\mathbf { Y } ^ { k } = \\tilde { \\mathbf { A } } \\mathbf { X } ^ { k }$ , respectively. The choice of stepsize will only impact the convergence speed but not the ultimate effect of AMP when it convergences to the fixed point solution. We also discuss the computation complexity per iteration of AMP in Remark 1. ",
+        "bbox": [
+            173,
+            522,
+            826,
+            613
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 (Convergence of AMP). Under the stepsize setting < 1(1−λ)kL˜k , the proposed adaptive message passing scheme (AMP) in Eq. (9) and Eq. (10) converges to the optimal solution of the problem defined in Eq. (8). In practice, it is sufficient to choose any $\\begin{array} { r } { \\gamma < \\frac { 1 } { 2 ( 1 - \\lambda ) } } \\end{array}$ since $\\Vert \\tilde { \\mathbf { L } } \\Vert _ { 2 } \\leq 2$ Moreover, if the connected components of the graph $\\mathcal { G }$ are not bipartite graphs, it is sufficient to choose $\\begin{array} { r } { \\gamma = \\frac { 1 } { 2 ( 1 - \\lambda ) } } \\end{array}$ since $\\Vert \\tilde { \\mathbf { L } } \\Vert _ { 2 } < 2$ . ",
+        "bbox": [
+            173,
+            614,
+            825,
+            698
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Remark 1 (Computation complexity). AMP is as efficient as simple feature aggregation $\\mathbf { X } _ { o u t } =$ $\\tilde { \\mathbf { A } } \\mathbf { X } _ { i n }$ because the additional computation cost from the second and third steps in Figure 4 is in the order $\\mathcal { O } ( n d )$ , where $n$ is the number of nodes and $d$ is the feature dimension. This is negligible compared with the computation cost $\\mathcal { O } ( m d )$ in feature aggregation, where m is the number of edges, due to the fact that usually there are many more edges than nodes in real-world graphs, i.e., $m \\gg n$ ",
+        "bbox": [
+            173,
+            700,
+            825,
+            773
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 Interpretation of AMP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            789,
+            370,
+            804
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, the proposed AMP has a simple and intuitive interpretation as adaptive residual connection, which aligns well with our design motivation: ",
+        "bbox": [
+            173,
+            814,
+            825,
+            843
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• If the feature of node $v _ { i }$ , i.e., $( \\mathbf { X } _ { \\mathrm { i n } } ) _ { i }$ , is significantly inconsistent with its local neighbors, i.e., the aggregated feature $\\mathbf { Y } _ { i } ^ { k }$ , then the local deviation $\\| { \\bf Y } _ { i } ^ { k } - ( { \\bf X } _ { \\mathrm { i n } } ) _ { i } \\| _ { 2 }$ will be large, which leads to a $\\beta _ { i }$ close to 1. Therefore, the final step will assign a small weight to the residual, i.e., $( 1 - \\beta _ { i } ) ( \\mathbf { X } _ { \\mathrm { i n } } ) _ { i }$ , and the aggregated feature $\\mathbf { Y } _ { i } ^ { k }$ will dominate. ",
+        "bbox": [
+            183,
+            852,
+            825,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• On the contrary, if $( \\mathbf { X } _ { \\mathrm { i n } } ) _ { i }$ is already consistent with its local neighbors, $\\| { \\bf Y } _ { i } ^ { k } - ( { \\bf X } _ { \\mathrm { i n } } ) _ { i } \\| _ { 2 }$ will be small, which leads to a $\\beta _ { i }$ close to 0. Thus, the residual will dominate, which is reasonable since there is less need to aggregate features in this case. ",
+        "bbox": [
+            183,
+            90,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• To summarize, the local deviation $\\| { \\bf Y } _ { i } ^ { k } - ( { \\bf X } _ { \\mathrm { i n } } ) _ { i } \\| _ { 2 }$ provides a natural transition from $\\beta _ { i } \\to 1$ to $\\beta _ { i } \\to 0$ , and the transition can be modulated by $\\lambda$ which can be either learned or tuned as a hyperparameter through cross-validation. This transition provides an node-wise adaptive residual connection for the message passing scheme. ",
+        "bbox": [
+            183,
+            136,
+            825,
+            193
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Adaptivity for abnormal $\\pmb { \\& }$ normal features. According to the homophily assumption on graph structure data [17, 18, 19, 3], the feature representations of normal features should be more consistent with local neighbors than abnormal features. As a result, AMP will assign more residual (i.e., smaller $\\beta$ ) to normal features but less residual (i.e., larger $\\beta$ ) to abnormal features, providing a customized tradeoff between feature aggregation and residual connection. Consequently, it can promote both the resilience to abnormal features and the performance on normal features. Above discussion also implies a clear physical meaning for $\\beta$ in AMP, and we formally define it as the adaptive score. ",
+        "bbox": [
+            173,
+            202,
+            825,
+            300
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 (Adaptive score). The variables $\\{ \\beta _ { 1 } , \\cdot \\cdot \\cdot , \\beta _ { n } \\}$ in the adaptive message passing scheme (AMP) are defined as the adaptive scores for nodes $\\{ v _ { 1 } , \\cdots , v _ { n } \\}$ respectively in graph $\\mathcal { G }$ . In particular, the larger $\\beta _ { i }$ is, the more likely the feature of node $v _ { i }$ is abnormal. ",
+        "bbox": [
+            173,
+            303,
+            823,
+            345
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Remark 2 (Nonlinear smoother). Different from most existing message passing scheme which are linear smoothers, AMP is a nonlinear smoother because the weights $\\{ \\beta _ { i } \\}$ are computed from $\\mathbf { Y } ^ { k }$ and ${ \\bf X } _ { i n }$ . This nonlinearity is the key to achieve adaptive residual connection for different nodes. ",
+        "bbox": [
+            174,
+            348,
+            825,
+            390
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 The Model Architecture ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            405,
+            380,
+            420
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The proposed adaptive message passing (AMP) can be used as a building block in many GNN models to improve the resilience to abnormal node features. In this work, we choose the the decoupled architectures as APPNP [10] and DAGNN [20], and propose the Adaptive residual GNN (AirGNN): ",
+        "bbox": [
+            174,
+            431,
+            825,
+            473
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f62553c679b7785ed1d60b6a031508aaff7f04a8c520ca11429283397931d80c.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { X } _ { \\mathrm { i n } } = h _ { \\theta } ( \\mathbf { X } _ { \\mathrm { f e a } } ) , } \\\\ & { \\mathbf { Y } _ { \\mathrm { p r e } } = \\mathbf { A } \\mathbf { M } \\mathbf { P } \\left( \\mathbf { X } _ { \\mathrm { i n } } , K , \\lambda \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            476,
+            586,
+            512
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "$h _ { \\theta } ( \\cdot )$ is any machine learning model parameterized by learnable parameters $\\theta$ , such as multilayer perceptrons (MLPs). $\\mathbf { X } _ { \\mathrm { f e a } } \\in \\mathbb { R } ^ { n \\times d }$ denotes the initial node features. The model $h _ { \\theta } ( \\cdot )$ will first transform the initial node features as $\\mathbf { X } _ { \\mathrm { i n } } = h _ { \\theta } ( \\mathbf { X } _ { \\mathrm { f e a } } )$ . AMP takes $h _ { \\theta } ( \\mathbf { X } _ { \\mathrm { f e a } } )$ as input, and performs $K$ steps of AMP with the hyperparameter $\\lambda$ . Similar to the majority of existing GNN models, the training objective is the cross-entropy classification loss on the labeled nodes, and the whole model is trained in an end-to-end way. Note that AirGNN is very efficient as explained in Remark 1, and it only requires two hyperparameters $K$ and $\\lambda$ without introducing additional parameters to learn, which could reduce the risk of overfitting. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            627
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiment ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            645,
+            303,
+            662
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we aim to verify the effective of the proposed adaptive message passing scheme (AMP) and the AirGNN model through the semi-supervised node classification tasks. Specifically, we try to answer the following questions: (1) How does AirGNN perform on abnormal and normal features? (Section 4.2 and 4.3) and (2) How does AirGNN work by adjusting the adaptive residual? (Section 4.4) ",
+        "bbox": [
+            173,
+            675,
+            825,
+            744
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experimental Settings ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            761,
+            367,
+            776
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Datasets and baselines. We conduct experiments on 8 real-world datasets including three citation graphs, i.e., Cora, Citeseer, Pubmed [21], two co-authorship graphs, i.e., Coauthor CS and Coauthor Physics [22], two co-purchase graphs, i.e., Amazon Computers and Amazon Photo [22], and one OGB dataset, i.e., ogbn-arxiv [23]. Due to the space limit, we only present the results on Cora, Citeseer, and Pubmed in this section, but defer the results on other datasets to Appendix D.1. More details about the data statistics and data splits are summarized in Appendix B. The proposed AirGNN is compared with representative GNNs, including GCN [3], GAT [6], APPNP [10] and GCNII [9]. We defer the comparison with the variants of APPNP and Robust GCN [24] to Appendix D.3 and D.4 respectively. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Parameter settings. For all baselines, we follow the best hyperparameter settings in their original papers. Additionally, we tune a best residual weight $\\alpha$ for APPNP and GCNII in the range $[ 0 , 1 ]$ . For AirGNN, we use a two-layer MLP as the base model $h _ { \\theta } ( \\cdot )$ , following APPNP. We fix the learning rate 0.01, dropout 0.8, and weight decay 0.0005. Moreover, we set $\\begin{array} { r } { \\gamma = \\frac { 1 } { 2 ( 1 - \\lambda ) } } \\end{array}$ as suggested by Theorem 1. We choose $K = 1 0$ and tune $\\lambda$ in the range $[ 0 , 1 ]$ . Adam optimizer [25] is used in all experiments. We run all experiments by 10 times, and report the mean and variance. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            178
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Evaluation setting. We assess the performance of all models under two types of abnormal feature scenarios, including noisy features and adversarial features. The abnormal features are injected to randomly selected test nodes after model training. By default, all hyperparameters are tuned according to the performance on validation sets when the dataset is clean. If tuning the hyperparameter $\\lambda$ of AirGNN according to the validation sets after injecting abnormal features, the performance will be even better, as discussed in Appendix D.2. The performance on clean data are showed in Appendix D.5 to demonstrate that AirGNN doesn’t need to sacrifice accuracy for better robustness against abnormal features. ",
+        "bbox": [
+            173,
+            184,
+            825,
+            295
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Performance Comparison with Noisy Features ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            313,
+            534,
+            327
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we consider the abnormal features in the noisy feature scenario. Specifically, we simulate the noisy features by assigning a subset of the nodes with random features sampled from a multivariate standard Gaussian distribution. Note that the selection of noise subsets has a apparent impact on the performance since some nodes are less vulnerable to abnormal features while others are more vulnerable. To reduce such variance, we report the average performance over 10 times of random selection of the noise node sets, similar to the settings in the preliminary study in Section 2. We report the node classification test accuracy on abnormal (noisy) features and normal features in Figure 5 and Figure 6, separately, under varying noisy ratio. From these figures, we can observe: ",
+        "bbox": [
+            173,
+            338,
+            825,
+            450
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• Figure 5 shows that AirGNN significantly outperforms all baselines on all datasets in terms of the performance on noisy nodes. This verifies that AMP is able to improve the resilience to noisy features, aligning well with the design motivation.   \n• Figure 6 shows that AirGNN promotes the performance on normal nodes when abnormal nodes exist. This is because AMP can remove some abnormal features which are detrimental to normal nodes. ",
+        "bbox": [
+            189,
+            462,
+            825,
+            551
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/cb981f452a6f87e6cccc28935d8e1aa89643dc8d85a1008f917f9b4fedf8a508.jpg",
+        "image_caption": [
+            "Figure 5: Node classification accuracy on abnormal (noisy) nodes "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            165,
+            564,
+            812,
+            708
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Performance Comparison with Adversarial Features ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            762,
+            578,
+            776
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we consider the abnormal feature scenario when the node features are maliciously attacked by the attacker to manipulate the prediction of GNNs. We use the Nettack [26] implemented in DeepRobust3 [27], a PyTorch library for adversarial attacks and defenses, to generate the adversarial features. We randomly choose 40 test nodes as the targeted nodes, and assess the performance under increasing perturbation budgets $\\{ 0 , 5 , 1 0 , 2 0 , 5 0 , 8 0 \\}$ , where the perturbation numbers denote the number of feature dimensions that can be manipulated. The node classification accuracy on these attacked nodes are showed in Figure 7. From these figures, we can make the following observations: ",
+        "bbox": [
+            174,
+            787,
+            825,
+            885
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/521af9135379cb9d9a4e04bfd77d43979bb91c8146837931dfc5f87ae829d691.jpg",
+        "image_caption": [
+            "Figure 6: Node classification accuracy on normal nodes "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            163,
+            84,
+            836,
+            244
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• AirGNN is significantly more robust against adversarially attacked features than all baselines. MLP is the most vulnerable model, which demonstrates the usefulness of graph structure information in combating against abnormal node features. ",
+        "bbox": [
+            194,
+            286,
+            826,
+            327
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• The advantages of AirGNN over the baselines become much stronger with larger perturbation budgets. This suggests that AMP can significantly improve the resilience to abnormal features. ",
+        "bbox": [
+            192,
+            332,
+            825,
+            361
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/b4a84b017c1ab3aee2d1fd5a97a59af3692c895e3672220068ba8be20564b118.jpg",
+        "image_caption": [
+            "Figure 7: Node classification accuracy on adversarial nodes "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            165,
+            393,
+            816,
+            541
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 Adaptive Residual for Abnormal & Normal Nodes ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            588,
+            562,
+            603
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To further understand and verify how AMP and AirGNN work, we investigate the adaptive score $\\beta _ { i }$ for each node $v _ { i }$ . Specifically, the average adaptive scores for abnormal nodes and normal nodes in the last layer of AMP are computed separately. In the noisy feature scenario, we fix ratio of noisy nodes as $10 \\%$ . In the adversarial feature scenario, we choose 40 target nodes and fix the perturbation number as 80. The results in noisy and adversarial feature scenarios are showed in Table 1 and Table 2, respectively. From these tables, we can observe: ",
+        "bbox": [
+            173,
+            613,
+            825,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• On the one hand, it can be clearly observed that in both scenarios, the average adaptive scores for abnormal nodes are significantly higher than those for normal nodes. Therefore, it verifies our intuition that large adaptive scores are strongly related to abnormal features. • On the other hand, it also implies that the residual weights (i.e., $1 - \\beta _ { i } )$ for abnormal nodes are much lower than those of normal nodes. This perfectly aligns with our motivation to remove abnormal features by reducing their residual connections. ",
+        "bbox": [
+            194,
+            708,
+            825,
+            797
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The study on adaptive scores verifies how the adaptive residuals in AMP and AirGNN work as designed. It corroborates that AirGNN not only tremendously boosts the resilience to abnormal features but also provides interpretable information for anomaly detection that will be useful in many security-critical scenarios since the adaptive score serves as a good indicator of abnormal nodes. Morever, it is expected that APPNP without residual will perform well on abnormal nodes but it will sacrifice the performance on normal nodes. We provide detailed comparison with APPNP w/Res and APPNP wo/Res in Appendix D.3 to show the advantages of adaptive residual of AirGNN. ",
+        "bbox": [
+            174,
+            808,
+            825,
+            906
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/d49a0a661a725cae61dfea576b2654826b85c9df4b3a4674a943e47200a74fd9.jpg",
+        "table_caption": [
+            "Table 1: Average adaptive score $( \\beta )$ and residual weight $( 1 - \\beta )$ in the noisy feature scenario. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Measure</td><td>Cora</td><td>CiteSeer</td><td>PubMed</td></tr><tr><td>Average adaptive score for abnormal nodes</td><td>0.998 ± 0.000</td><td>0.988 ± 0.000</td><td>0.996 ± 0.000</td></tr><tr><td>Average adaptive score for normal nodes Average residual weight for abnormal nodes</td><td>0.924 ± 0.002 0.002 ±0.000</td><td>0.807 ± 0.005 0.012 ± 0.000</td><td>0.869 ± 0.006</td></tr><tr><td>Average residual weight for normal nodes</td><td>0.076 ± 0.002</td><td>0.193 ± 0.005</td><td>0.004±0.000 0.131 ± 0.006</td></tr></table>",
+        "bbox": [
+            209,
+            114,
+            790,
+            195
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/bd195752ecb387a8a737f39dd60085cba6c171a851c3d77460489987040b8bfc.jpg",
+        "table_caption": [
+            "Table 2: Average adaptive score $( \\beta )$ and residual weight $( 1 - \\beta )$ in the adversarial feature scenario. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Measure</td><td>Cora</td><td>CiteSeer</td><td>PubMed</td></tr><tr><td>Average adaptive score for abnormal nodes Average adaptive score for normal nodes</td><td>0.987 ±0.000</td><td>0.930 ± 0.007</td><td>0.959 ± 0.005</td></tr><tr><td>Average residual weight for abnormal nodes</td><td>0.922 ± 0.004</td><td>0.689 ± 0.024</td><td>0.826 ± 0.016</td></tr><tr><td></td><td>0.013 ±0.000</td><td>0.070±0.007</td><td>0.041 ±0.005</td></tr><tr><td>Average residual weight for normal nodes</td><td>0.078 ± 0.004</td><td>0.311 ± 0.024</td><td>0.174 ± 0.016</td></tr></table>",
+        "bbox": [
+            209,
+            237,
+            789,
+            319
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            344,
+            321,
+            362
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "GNNs generalize convolutional neural networks (CNN) to graph structure data through the message passing framework [1, 2, 7]. The design of message passing and GNN architectures are majorly motivated in spectral domain [3, 4] and spatial domain [5, 6, 7, 2]. Recent works have shown that the message passing in GNNs can be regarded as low-pass graph filters [12, 13]. More generally, it has been proven that message passing in many GNNs can be uniformly derived from graph signal denoising [11, 28, 29, 30]. Classic GNNs such as GCN [3] and GAT [6] achieve their best performance with shallow models, but their performance degrades when stacking more layers, which can be partially explained through oversmoothing analyses [14, 15]. Recent works propose to use residual connections or skip connections to mitigate the oversmoothing issues, and they demonstrate the potential benefits from more feature aggregations. Examples include but not limited to DeepGCNs [31], JKNet [32], GCNII [9], APPNP [10] and DeeperGNN [20]. These models use global residual connection that can not be adaptive for each node, which significantly differ from the proposed AirGNN. ",
+        "bbox": [
+            174,
+            377,
+            825,
+            556
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Recently, there are growing interests in reducing GNNs’ vulnerability to the graph structure noise, such as Robust GCN [24], GCN-SVD [33], Pro-GNN [34], IDGL [35], ElasticGNN [36], etc. Please refer to the comprehensive surveys [37, 38] for more details. However, how to design GNNs with strong resilience to abnormal node features remains to be developed. To the best of our knowledge, AirGNN is the first GNN model that is intrinsically robust to many types of abnormal node features by design. It improves the performance in various kinds of abnormal scenarios without needing to sacrifice clean accuracy in normal settings. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            661
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            683,
+            299,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we discover an intrinsic tension between feature aggregation and residual connection in the message passing scheme of GNNs, as well as the corresponding performance tradeoff between nodes with abnormal and normal features. We analyze possible reasons to explain these findings from the perspective of graph Laplacian smoothing. Our understandings further motivate us to propose a simple, efficient, interpretable and adaptive message passing scheme as well as a new GNN model with adaptive residual, named AirGNN. AirGNN provides a node-wise adaptive transition between feature aggregation and residual connection, and the significant advantages of AirGNN are demonstrated through extensive experiments. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            828
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            849,
+            553,
+            867
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This research is supported by the National Science Foundation (NSF) under grant numbers IIS1714741, CNS1815636, IIS1845081, IIS1907704, DRL2025244, IIS1928278, IIS1955285, ",
+        "bbox": [
+            176,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "IOS2107215, IOS2035472 and Army Research Office (ARO) under grant number W911NF-21- 1-0198. ",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Societal Impact and Limitations ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            138,
+            442,
+            156
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The methodology proposed in this paper might have significant positive societal impact since it reduces machine learning models’ vulnerability to abnormal datasets that generally exist in real-world applications, especially in many security-critical scenarios. In practice, for a given graph, we do not have the prior knowledge about if the graph is clean, has noisy features or adversarial features. Therefore, algorithms like the proposed AirGNN that can work under both the clean and various abnormal feature settings are appealing. While we are unaware of any potential negative society impact, we point out two limitations of this work: (1) this paper focuses on abnormal node features and has not evaluated the performance of the proposed method when the dataset contains both abnormal node features and edges; (2) it is unclear how it performs on heterophilic graphs. It will be interesting to investigate these problems in future works. ",
+        "bbox": [
+            174,
+            171,
+            825,
+            309
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            329,
+            266,
+            345
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Yao Ma and Jiliang Tang. Deep Learning on Graphs. Cambridge University Press, 2020.   \n[2] Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In International Conference on Machine Learning, pages 1263–1272. PMLR, 2017.   \n[3] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.   \n[4] Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In Proceedings of the 30th International Conference on Neural Information Processing Systems, pages 3844–3852, 2016.   \n[5] William L Hamilton, Rex Ying, and Jure Leskovec. Inductive representation learning on large graphs. arXiv preprint arXiv:1706.02216, 2017.   \n[6] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.   \n[7] 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.   \n[8] Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. A comprehensive survey on graph neural networks. IEEE transactions on neural networks and learning systems, 2020.   \n[9] Ming Chen, Zhewei Wei, Zengfeng Huang, Bolin Ding, and Yaliang Li. Simple and deep graph convolutional networks. In Hal Daumé III and Aarti Singh, editors, Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 1725–1735. PMLR, 13–18 Jul 2020.   \n[10] Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. arXiv preprint arXiv:1810.05997, 2018.   \n[11] Yao Ma, Xiaorui Liu, Tong Zhao, Yozen Liu, Jiliang Tang, and Neil Shah. A unified view on graph neural networks as graph signal denoising. Proceedings of the 30th ACM International Conference on Information and Knowledge Management, 2021.   \n[12] Hoang Nt and Takanori Maehara. Revisiting graph neural networks: All we have is low-pass filters. arXiv preprint arXiv:1905.09550, 2019.   \n[13] Lingxiao Zhao and Leman Akoglu. Pairnorm: Tackling oversmoothing in gnns. In International Conference on Learning Representations, 2019.   \n[14] Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018.   \n[15] Kenta Oono and Taiji Suzuki. Graph neural networks exponentially lose expressive power for node classification. In International Conference on Learning Representations, 2020.   \n[16] Stephen Boyd and Lieven Vandenberghe. Convex optimization. Cambridge university press, 2004.   \n[17] Miller McPherson, Lynn Smith-Lovin, and James M Cook. Birds of a feather: Homophily in social networks. Annual review of sociology, 27(1):415–444, 2001.   \n[18] Xiaojin Zhu and Zoubin Ghahramani. Learning from labeled and unlabeled data with label propagation.   \n[19] Dengyong Zhou, Olivier Bousquet, Thomas Navin Lal, Jason Weston, and Bernhard Schölkopf. Learning with local and global consistency. 2004.   \n[20] Meng Liu, Hongyang Gao, and Shuiwang Ji. Towards deeper graph neural networks. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining. ACM, 2020.   \n[21] Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina EliassiRad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.   \n[22] Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Günnemann. Pitfalls of graph neural network evaluation. arXiv preprint arXiv:1811.05868, 2018.   \n[23] Marinka Zitnik Yuxiao Dong Hongyu Ren Bowen Liu Michele Catasta Jure Leskovec Weihua Hu, Matthias Fey. Open graph benchmark: Datasets for machine learning on graphs. arXiv preprint arXiv:2005.00687, 2020.   \n[24] Dingyuan Zhu, Ziwei Zhang, Peng Cui, and Wenwu Zhu. Robust graph convolutional networks against adversarial attacks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1399–1407, 2019.   \n[25] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \n[26] Daniel Zügner, Amir Akbarnejad, and Stephan Günnemann. Adversarial attacks on neural networks for graph data. In KDD. ACM, 2018.   \n[27] Yaxin Li, Wei Jin, Han Xu, and Jiliang Tang. Deeprobust: A pytorch library for adversarial attacks and defenses, 2020.   \n[28] Xuran Pan, Song Shiji, and Huang Gao. A unified framework for convolution-based graph neural networks. https://openreview.net/forum?id=zUMD–Fb9Bt, 2020.   \n[29] Meiqi Zhu, Xiao Wang, Chuan Shi, Houye Ji, and Peng Cui. Interpreting and unifying graph neural networks with an optimization framework, 2021.   \n[30] Siheng Chen, Yonina C. Eldar, and Lingxiao Zhao. Graph unrolling networks: Interpretable neural networks for graph signal denoising, 2020.   \n[31] Guohao Li, Matthias Müller, Ali Thabet, and Bernard Ghanem. Deepgcns: Can gcns go as deep as cnns? In The IEEE International Conference on Computer Vision (ICCV), 2019.   \n[32] Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation learning on graphs with jumping knowledge networks. In Jennifer Dy and Andreas Krause, editors, Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 5453–5462. PMLR, 10–15 Jul 2018.   \n[33] Negin Entezari, Saba A Al-Sayouri, Amirali Darvishzadeh, and Evangelos E Papalexakis. All you need is low (rank) defending against adversarial attacks on graphs. In Proceedings of the 13th International Conference on Web Search and Data Mining, pages 169–177, 2020.   \n[34] Wei Jin, Yao Ma, Xiaorui Liu, Xianfeng Tang, Suhang Wang, and Jiliang Tang. Graph structure learning for robust graph neural networks. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 66–74, 2020.   \n[35] Yu Chen, Lingfei Wu, and Mohammed Zaki. Iterative deep graph learning for graph neural networks: Better and robust node embeddings. Advances in Neural Information Processing Systems, 33, 2020.   \n[36] Xiaorui Liu, Wei Jin, Yao Ma, Yaxin Li, Hua Liu, Yiqi Wang, Ming Yan, and Jiliang Tang. Elastic graph neural networks. In Marina Meila and Tong Zhang, editors, Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pages 6837–6849. PMLR, 18–24 Jul 2021.   \n[37] Wei Jin, Yaxing Li, Han Xu, Yiqi Wang, Shuiwang Ji, Charu Aggarwal, and Jiliang Tang. Adversarial attacks and defenses on graphs. ACM SIGKDD Explorations Newsletter, 22(2):19– 34, 2021.   \n[38] Yanqiao Zhu, Weizhi Xu, Jinghao Zhang, Qiang Liu, Shu Wu, and Liang Wang. Deep graph structure learning for robust representations: A survey. arXiv preprint arXiv:2103.03036, 2021.   \n[39] Laurent Condat. A primal–dual splitting method for convex optimization involving lipschitzian, proximable and linear composite terms. Journal of optimization theory and applications, 158(2):460–479, 2013.   \n[40] Fan RK Chung and Fan Chung Graham. Spectral graph theory. Number 92. American Mathematical Soc., 1997. ",
+        "bbox": [
+            173,
+            349,
+            826,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            70,
+            828,
+            921
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            484
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            131
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            227
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            231,
+            493,
+            244
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] ",
+        "bbox": [
+            236,
+            248,
+            735,
+            280
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            285,
+            393,
+            299
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [No] ",
+        "bbox": [
+            238,
+            303,
+            826,
+            421
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            214,
+            426,
+            823,
+            440
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [No]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No] ",
+        "bbox": [
+            238,
+            444,
+            823,
+            551
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            556,
+            705,
+            570
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            574,
+            825,
+            665
+        ],
+        "page_idx": 13
+    }
+]