Add Batch 83dd53b2-57a0-4ee6-8f6e-b9b881631735

.gitattributes

@@ -7983,3 +7983,67 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 2002.09xxx/2002.09277/14e5ca3a-86de-4f52-bec0-96a32d06bc13_origin.pdf filter=lfs diff=lfs merge=lfs -text
 2002.09xxx/2002.09283/46414b69-89d5-4a99-b553-a19b8546a31d_origin.pdf filter=lfs diff=lfs merge=lfs -text
 2002.11xxx/2002.11770/cc1dc24f-cb28-4ab2-a86d-aff2d87643ab_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.06xxx/2002.06755/d54db34f-95c2-4379-a9af-7790d9ca3e0f_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.06xxx/2002.06757/f0a0cfca-5ae2-4300-ba52-9cc444c0761b_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.06xxx/2002.06789/742d8561-0e5e-4192-b15b-21fc92c86ee6_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.06xxx/2002.06805/79bedf52-9295-4f4a-afaa-d678c0f969e8_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.06xxx/2002.06820/b62d4baf-aeea-4bff-82d1-b6e4044e1482_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.06xxx/2002.06823/1208346c-943e-418a-bd6c-6ac7c06ca7ef_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.06xxx/2002.06838/b5f48312-e0e5-4d14-b736-57b539ada670_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.06xxx/2002.06910/5e70957f-dbc4-4f22-8541-fa2060314a2e_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.06xxx/2002.06961/6711267c-9526-4dc2-801e-2a2790de8e93_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07007/3abab6be-8659-4b7d-911f-b513175456fb_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07017/230038cb-d536-4720-b77e-69ae0422827a_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07028/97bba3ad-0144-4e16-aa17-68e508def7d8_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07063/14a7834e-f2c0-4c68-964d-2aed85a9a2a8_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07066/033b75dc-e4e4-4d70-b1d2-08ef37b54649_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07080/ef65fdce-ac8d-40db-bfb9-3f6c500e3a94_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07101/79dc6428-cecf-447c-ad8c-9102dc7e1949_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07264/31a0fa44-0c35-4a84-aa4f-30b1f666f4bf_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07366/973f5def-f5a2-4080-b422-95f9948315fb_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07367/a037b3ca-35a9-4af0-bacf-7ea1d03d2125_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07376/5ccbbaae-a5be-4b2d-a3b6-2ae5035a1fef_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07394/223cfdf4-7b09-42f6-969e-66de21cc6c5c_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07400/f480530a-a868-45e5-b657-065bd4e17911_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07420/51788a23-8489-411c-9010-dbbe0734af9e_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07442/a031468a-5b2d-4a65-ae0a-627584231319_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07510/0288afb0-ee51-47c3-8808-5fbebd8064bb_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07514/e76b13c2-31d1-437c-a527-d8de5dcb6511_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07526/9119f6c3-a847-45ad-ad90-ef7d55549ef5_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07530/f09c8b08-6304-4014-a761-4c4f91a5537f_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07656/8ba0d926-d839-444f-b339-9b314e762e4e_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07686/1646a2ff-97d2-4bdb-837e-a39b93942218_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07687/d892f5da-8732-4bdc-813f-2ec3d127e7f9_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07717/6971a97d-e404-42a3-bca7-5e910fb86442_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07764/5a850326-8b3a-4d72-befd-f6b9948a15af_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07772/c4c51162-ec04-410d-9b6b-ca963be3088a_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07793/fc4f8681-bd24-40b7-8c66-8b3a4760fac4_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07839/4d9c4dd4-5987-48c2-b39a-045e2a555118_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07842/24ace877-ccd2-4b21-a7b5-845c185b2619_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07867/c35f2498-8495-470b-911b-81a36efc0249_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07948/a6220a41-93bf-4589-9302-8c832de15e41_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07953/adb03530-b47f-4866-a126-98605a820182_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07962/164f7909-ef8a-4e49-b41e-081369e413f3_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07971/b99e13f0-4dbb-4b4d-bcdd-c12a836639ce_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07993/0dabdd04-242f-4c7a-bfb2-c2d0626627ee_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.07xxx/2002.07995/d9ac4aae-f82c-40d1-bc7b-8bd1271fde1c_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.08xxx/2002.08025/62e36cad-4bd9-4152-b987-caee7b69ad0c_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.08xxx/2002.08035/1086d534-e1d1-4de7-aef8-745fa3391581_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.08xxx/2002.08046/28a8bb75-4692-461e-979a-8d3059c89317_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.08xxx/2002.08053/3c057ed5-9045-402e-af96-125b30e9ad74_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.08xxx/2002.08071/81d5353e-8861-4a4b-9a9d-af41e9f19f9c_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.08xxx/2002.08087/c4561c1f-eed0-4dc3-9b23-e20c6d750fc3_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.08xxx/2002.08098/c5b95f40-f4d8-4d0b-bb45-5d74f93ba243_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.08xxx/2002.08111/a94c9f32-6747-4161-98aa-409afa57a13c_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.08xxx/2002.08118/e57a5fc2-cacf-4f78-8860-e7360b504701_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.08xxx/2002.08119/eb12bf9f-82c5-42ec-810b-3ad5ac212165_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.08xxx/2002.08129/256baaa8-da97-40e7-ae85-45ec954cc4a3_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.08xxx/2002.08136/b71f7d8a-ff8e-4bb3-bffd-0666b7ead69f_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.08xxx/2002.08768/1a4f3959-72a4-450a-be2a-88c22fa2c760_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.08xxx/2002.08953/a0e3775a-d20b-48cf-bb29-1feb854b03ab_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.10xxx/2002.10253/a5ca0c52-17db-46fc-a6fc-cbdeefc740ab_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.11xxx/2002.11635/bf09b06b-c84c-4cd2-b1b9-127baf66b403_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2002.11xxx/2002.11808/21e4e4bc-7b52-48b1-b0e7-5a2379614694_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2003.00xxx/2003.00819/b39bbd4e-7317-40d8-8735-52b4b4398563_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2003.02xxx/2003.02944/f014b1d2-4b4b-42b7-9ac1-536850ec0d4b_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2003.11xxx/2003.11632/0b731065-e248-486e-a6c5-d0c1ccd92810_origin.pdf filter=lfs diff=lfs merge=lfs -text

2002.06xxx/2002.06755/d54db34f-95c2-4379-a9af-7790d9ca3e0f_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f9d0145c30bdfb0c7d14cb12ce23dd27d6d2026af40ea409a9c99f87036dd7f
+size 507758

2002.06xxx/2002.06755/full.md

@@ -0,0 +1,603 @@
+# Unifying Graph Convolutional Neural Networks and Label Propagation
+
+Hongwei Wang<sup>1</sup> Jure Leskovec<sup>1</sup>
+
+# Abstract
+
+Label Propagation (LPA) and Graph Convolutional Neural Networks (GCN) are both message passing algorithms on graphs. Both solve the task of node classification but LPA propagates node label information across the edges of the graph, while GCN propagates and transforms node feature information. However, while conceptually similar, theoretical relation between LPA and GCN has not yet been investigated. Here we study the relationship between LPA and GCN in terms of two aspects: (1) feature/label smoothing where we analyze how the feature/label of one node is spread over its neighbors; And, (2) feature/label influence of how much the initial feature/label of one node influences the final feature/label of another node. Based on our theoretical analysis, we propose an end-to-end model that unifies GCN and LPA for node classification. In our unified model, edge weights are learnable, and the LPA serves as regularization to assist the GCN in learning proper edge weights that lead to improved classification performance. Our model can also be seen as learning attention weights based on node labels, which is more task-oriented than existing feature-based attention models. In a number of experiments on real-world graphs, our model shows superiority over state-of-the-art GCN-based methods in terms of node classification accuracy.
+
+# 1. Introduction
+
+Consider the problem of node classification in a graph, where the goal is to learn a mapping  $\mathcal{M}:\mathcal{V}\to \mathcal{L}$  from node set  $\mathcal{V}$  to label set  $\mathcal{L}$ . Solution to this problem is widely applicable to various scenarios, e.g., inferring income of users in a social network or classifying scientific articles in a citation network. Different from a generic machine
+
+<sup>1</sup>Computer Science Department, Stanford University, Stanford, CA 94305, United States. Correspondence to: Hongwei Wang <hongweiw@cs.stanford.edu>.
+
+learning problem where samples are independent from each other, nodes are connected by edges in the graph, which provide additional information and require more delicate modeling. To capture the graph information, researchers have mainly designed models on the assumption that labels and features vary smoothly over the edges of the graph. In particular, on the label side  $\mathcal{L}$ , node labels are propagated and aggregated along edges in the graph, which is known as Label Propagation Algorithm (LPA) (Zhu et al., 2005; Zhou et al., 2004; Zhang & Lee, 2007; Wang & Zhang, 2008; Karasuyama & Mamitsuka, 2013; Gong et al., 2017; Liu et al., 2019a); On the node side  $\mathcal{V}$ , node features are propagated along edges and transformed through neural network layers, which is known as Graph Convolutional Neural Networks (GCN) (Kipf & Welling, 2017; Hamilton et al., 2017; Li et al., 2018; Xu et al., 2018; Liao et al., 2019; Xu et al., 2019; Qu et al., 2019).
+
+GCN and LPA are related in that they propagate features and labels on the two sides of the mapping  $\mathcal{M}$ , respectively. However, the relationship between GCN and LPA has not yet been investigated. Specifically, what is the theoretical relationship between GCN and LPA, and how can they be combined to develop a more accurate model for node classification in graphs?
+
+Here we study the theoretical relationship between GCN and LPA from two viewpoints: (1) Feature/label smoothing, where we show that the intuition behind GCN/LPA is smoothing features/labels of nodes across the edges of the graph, i.e., one node's feature/label equals the weighted average of features/labels of its neighbors. We prove that if the weights of edges in a graph smooth the node features with high precision, they also smooth the node labels with guaranteed upper bound on the smoothing error. And, (2) feature/label influence, where we quantify how much the initial feature/label of node  $v_{b}$  influences the output feature/label of node  $v_{a}$  in GCN/LPA by studying the Jacobian/gradients of node  $v_{b}$  with respect to node  $v_{a}$ . We also prove the quantitative relationship between feature influence and label influence.
+
+Based on the above theoretical analysis, we propose a unified model GCN-LPA for node classification. We show that the key to improving the performance of GCN is to enable nodes within the same class/label to connect more strongly
+
+with each other by making edge weights/strengths trainable. Then we prove that increasing the strength of edges between the nodes of the same class is equivalent to increasing the accuracy of LPA's predictions. Therefore, we can first learn the optimal edge weights by minimizing the loss of predictions in LPA, then plug the optimal edge weights into a GCN to learn node representations and do final classification. In GCN-LPA, we further combine the two steps together and train the whole model in an end-to-end fashion, where the LPA part serves as regularization to assist the GCN part in learning proper edge weights that benefit the separation of different node classes. It is worth noticing that GCN-LPA can also be seen as learning attention weights for edges based on node label information, which requires less handcrafting and is more task-oriented than existing work that learns attention weights based on node feature similarity (Velicković et al., 2018; Thekumparampil et al., 2018; Zhang et al., 2018; Liu et al., 2019b).
+
+We conduct extensive experiments on five datasets, and the results indicate that our model outperforms state-of-the-art methods in terms of classification accuracy. The experimental results also show that combining GCN and LPA together is able to learn more informative edge weights thereby leading to better performance.
+
+# 2. Unifying GCN and LPA
+
+In this section, we first formulate the node classification problem and briefly introduce LPA and GCN. We then prove their relationship from the viewpoints of smoothing and influence. Based on the theoretical findings, we propose a unified model GCN-LPA, and analyze why our model is theoretically superior to vanilla GCN.
+
+# 2.1. Problem Formulation and Preliminaries
+
+We begin by describing the problem of node classification on graphs and introducing notation. Consider a graph  $\mathcal{G} = (\mathcal{V}, A, X, Y)$ , where  $\mathcal{V} = \{v_1, \dots, v_n\}$  is the set of nodes,  $A \in \mathbb{R}^{n \times n}$  is the adjacency matrix (self-loops are included),  $X$  is the feature matrix of nodes and  $Y$  is labels of nodes.  $a_{ij}$  (the  $ij$ -th entry of  $A$ ) is the weight of the edge connecting  $v_i$  and  $v_j$ .  $\mathcal{N}(v)$  denotes the set of immediate neighbors of node  $v$  in graph  $\mathcal{G}$ . Each node  $v_i$  has a feature vector  $\mathbf{x}_i$  which is the  $i$ -th row of  $X$ , while only the first  $m$  nodes have labels  $y_1, \dots, y_m$  from a label set  $\mathcal{L} = \{1, \dots, c\}$ . The goal is to learn a mapping  $\mathcal{M}: \mathcal{V} \to \mathcal{L}$  and predict labels of unlabeled nodes.
+
+Label Propagation Algorithm. LPA assumes that two connected nodes are likely to have the same label, and thus it propagates labels iteratively along the edges. Let  $Y^{(k)} = [y_1^{(k)}, \dots, y_n^{(k)}]^{\top} \in \mathbb{R}^{n \times c}$  be the soft label matrix in iteration  $k > 0$ , in which the  $i$ -th row  $y_i^{(k)\top}$  denotes the
+
+predicted label distribution for node  $v_{i}$  in iteration  $k$ . When  $k = 0$ , the initial label matrix  $Y^{(0)} = [y_1^{(0)},\dots ,y_n^{(0)}]^{\top}$  consists of one-hot label indicator vectors  $y_{i}^{(0)}$  for  $i = 1,\dots ,m$  (i.e., labeled nodes) or zero vectors otherwise (i.e., unlabeled nodes). Let  $D$  be the diagonal degree matrix for  $A$  with entries  $d_{ii} = \sum_j a_{ij}$ . Then LPA (Zhu et al., 2005) in iteration  $k$  is formulated as the following two steps:
+
+$$
+Y ^ {(k + 1)} = D ^ {- 1} A Y ^ {(k)}, \tag {1}
+$$
+
+$$
+y _ {i} ^ {(k + 1)} = y _ {i} ^ {(0)}, \forall i \leq m. \tag {2}
+$$
+
+In Eq. (1), all nodes propagate labels to their neighbors according to normalized edge weights. Then in Eq. (2), labels of all labeled nodes are reset to their initial values, because LPA wants to persist labels of nodes which are labeled so that unlabeled nodes do not overpower the labeled ones as the initial labels would otherwise fade away.
+
+Graph Convolutional Neural Network. GCN is a multi-layer feedforward neural network that propagates and transforms node features across the graph. The layer-wise propagation rule of GCN is  $X^{(k + 1)} = \sigma (D^{-\frac{1}{2}}AD^{-\frac{1}{2}}X^{(k)}W^{(k)})$ , where  $W^{(k)}$  is trainable weight matrix in the  $k$ -th layer,  $\sigma (\cdot)$  is an activation function such as ReLU, and  $X^{(k)} = [\mathbf{x}_1^{(k)},\dots ,\mathbf{x}_n^{(k)}]^\top$  are the  $k$ -th layer node representations with  $X^{(0)} = X$ . To align with the above LPA, we use  $D^{-1}A$  as the normalized adjacency matrix instead of the symmetric one  $D^{-\frac{1}{2}}AD^{-\frac{1}{2}}$  proposed by (Kipf & Welling, 2017). Therefore, the feature propagation scheme of GCN in layer  $k$  is:
+
+$$
+X ^ {(k + 1)} = \sigma \left(D ^ {- 1} A X ^ {(k)} W ^ {(k)}\right). \tag {3}
+$$
+
+Notice similarity between Eqs. (1) and (3). Next we shall study and uncover the relationship between the two equations.
+
+# 2.2. Feature Smoothing and Label Smoothing
+
+The intuition behind both LPA and GCN is smoothing (Zhu et al., 2003; Li et al., 2018): In LPA, the final label of a node is the weighted average of labels of its neighbors:
+
+$$
+y _ {i} ^ {(\infty)} = \frac {1}{d _ {i i}} \sum_ {j \in \mathcal {N} (i)} a _ {i j} y _ {j} ^ {(\infty)}. \tag {4}
+$$
+
+In GCN, the final node representation is also the weighted average of representations of its neighbors if we assume  $\sigma$  is identity function and  $W^{(\cdot)}$  are identity matrices:
+
+$$
+\mathbf {x} _ {i} ^ {(\infty)} = \frac {1}{d _ {i i}} \sum_ {j \in \mathcal {N} (i)} a _ {i j} \mathbf {x} _ {j} ^ {(\infty)}. \tag {5}
+$$
+
+Next we show the relationship between feature smoothing and label smoothing:
+
+Theorem 1 (Relationship between feature smoothing and label smoothing) Suppose that the latent ground-truth mapping  $\mathcal{M}:\mathbf{x}\rightarrow y$  from node features to node labels is differentiable and satisfies  $L$ -Lipschitz constraint, i.e.,  $|\mathcal{M}(\mathbf{x}_1) - \mathcal{M}(\mathbf{x}_2)|\leq L\| \mathbf{x}_1 - \mathbf{x}_2\| _2$  for any  $\mathbf{x}_1$  and  $\mathbf{x}_2$  ( $L$  is a constant). If the edge weights  $\{a_{ij}\}$  approximately smooth  $\mathbf{x}_i$  over its immediate neighbors with error  $\epsilon_{i}$ , i.e.,
+
+$$
+\mathbf {x} _ {i} = \frac {1}{d _ {i i}} \sum_ {j \in \mathcal {N} (i)} a _ {i j} \mathbf {x} _ {j} + \epsilon_ {i}, \tag {6}
+$$
+
+then the edge weights  $\{a_{ij}\}$  also approximately smooth  $y_{i}$  over its immediate neighbors with the following approximation error:
+
+$$
+\left| y _ {i} - \frac {1}{d _ {i i}} \sum_ {j \in \mathcal {N} (i)} a _ {i j} y _ {j} \right| \leq L \| \epsilon_ {i} \| _ {2} + o \left(\max  _ {j \in \mathcal {N} (i)} \left(\left\| \mathbf {x} _ {j} - \mathbf {x} _ {i} \right\| _ {2}\right)\right), \tag {7}
+$$
+
+where  $o(\alpha)$  denotes a higher order infinitesimal than  $\alpha$ .
+
+Proof of Theorem 1 is in Appendix A. Theorem 1 indicates that label smoothing is theoretically guaranteed by feature smoothing. Note that if we treat edge weights  $\{a_{ij}\}$  learnable, then feature smoothing (i.e.,  $\epsilon_i\rightarrow 0$ ) can be directly achieved by keeping node features  $\mathbf{x}_i$  fixed while setting  $\{a_{ij}\}$  appropriately, without resorting to feature propagation in a multi-layer GCN. Therefore, a simple approach to exploit this theorem would be to learn  $\{a_{ij}\}$  by reconstructing node feature  $\mathbf{x}_i$  from its neighbors, then use the learned  $\{a_{ij}\}$  to reconstruct node labels  $y_{i}$  (Karasuyama & Mamitsuka, 2013).
+
+As shown in Theorem 1, the approximation error of labels is dominated by  $L\| \epsilon_i\| _2$ . However, this error could be fairly large in practice because: (1) The number of immediate neighbors for a given node may be too small to reconstruct its features perfectly, especially in the case where node features are high-dimensional and sparse. For example, in a citation network where node features are one-hot bag-of-words vectors, the feature of one article can never be precisely reconstructed if none of its neighboring articles contains the specific word that appears in this article. As a result,  $\| \epsilon_i\| _2$  will be non-negligible. This explains why it is beneficial to apply LPA and GCN for multiple iterations/layers in order to include information from farther away neighbors. (2) The ground-truth mapping  $\mathcal{M}$  may not be sufficiently smooth due to the complex structure of latent manifold and possible noise, which fails to satisfy  $L$ -Lipschitz constraint. In other words, the constant  $L$  will be extremely large.
+
+# 2.3. Feature Influence and Label Influence
+
+To address the above concerns and extend our analysis, we next consider GCN and LPA with multiple layers/iterations,
+
+and do not impose any constraint on the ground-truth mapping  $\mathcal{M}$ .
+
+Consider two nodes  $v_{a}$  and  $v_{b}$  in a graph. Inspired by (Koh & Liang, 2017) and (Xu et al., 2018), we study the relationship between GCN and LPA in terms of influence, i.e., how the output feature/label of  $v_{a}$  will change if the initial feature/label of  $v_{b}$  is varied slightly. Technically, the feature/label influence is measured by the Jacobian/gradients of the output feature/label of  $v_{a}$  with respect to the initial feature/label of  $v_{b}$ . Denote  $\mathbf{x}_{a}^{(k)}$  as the  $k$ -th layer representation vector of  $v_{a}$  in GCN, and  $\mathbf{x}_{b}$  as the initial feature vector of  $v_{b}$ . We quantify the feature influence of  $v_{b}$  on  $v_{a}$  as follows:
+
+Definition 1 (Feature influence) The feature influence of node  $v_{b}$  on node  $v_{a}$  after  $k$  layers of GCN is the L1-norm of the expected Jacobian matrix  $\partial \mathbf{x}_a^{(k)} / \partial \mathbf{x}_b$ :
+
+$$
+I _ {f} \left(v _ {a}, v _ {b}; k\right) = \left\| \mathbb {E} \left[ \partial \mathbf {x} _ {a} ^ {(k)} / \partial \mathbf {x} _ {b} \right] \right\| _ {1}. \tag {8}
+$$
+
+The normalized feature influence is then defined as
+
+$$
+\tilde {I} _ {f} \left(v _ {a}, v _ {b}; k\right) = \frac {I _ {f} \left(v _ {a} , v _ {b} ; k\right)}{\sum_ {v _ {i} \in \mathcal {V}} I _ {f} \left(v _ {a} , v _ {i} ; k\right)}. \tag {9}
+$$
+
+We also consider the label influence of node  $v_{b}$  on node  $v_{a}$  in LPA (this implies that  $v_{a}$  is unlabeled and  $v_{b}$  is labeled). Since different label dimensions of  $y_{i}^{(\cdot)}$  do not interact with each other in LPA, we assume that all  $y_{i}$  and  $y_{i}^{(\cdot)}$  are scalars within [0, 1] (i.e., a binary classification) for simplicity. Label influence is defined as follows:
+
+Definition 2 (Label influence) The label influence of labeled node  $v_{b}$  on unlabeled node  $v_{a}$  after  $k$  iterations of LPA is the gradient of  $y_{a}^{(k)}$  with respect to  $y_{b}$ :
+
+$$
+I _ {l} \left(v _ {a}, v _ {b}; k\right) = \partial y _ {a} ^ {(k)} / \partial y _ {b}. \tag {10}
+$$
+
+The following theorem shows the relationship between feature influence and label influence:
+
+Theorem 2 (Relationship between feature influence and label influence) Assume the activation function used in GCN is ReLU. Denote  $v_{a}$  as an unlabeled node,  $v_{b}$  as a labeled node, and  $\beta$  as the fraction of unlabeled nodes. Then the label influence of  $v_{b}$  on  $v_{a}$  after  $k$  iterations of LPA equals, in expectation, to the cumulative normalized feature influence of  $v_{b}$  on  $v_{a}$  after  $k$  layers of GCN:
+
+$$
+\mathbb {E} \left[ I _ {l} \left(v _ {a}, v _ {b}; k\right) \right] = \sum_ {j = 1} ^ {k} \beta^ {j} \tilde {I} _ {f} \left(v _ {a}, v _ {b}; j\right). \tag {11}
+$$
+
+Proof of Theorem 2 is in Appendix B. Intuitively, Theorem 2 shows that if  $v_{b}$  has high label influence on  $v_{a}$ , then the initial feature vector of  $v_{b}$  will also affect the output feature vector of  $v_{a}$  to a large extent. Theorem 2 provides the theoretical guideline for designing our unified model in the next subsection.
+
+# 2.4. The Unified Model
+
+Before introducing the proposed model, we first rethink the GCN method and see what an ideal node representation should be like. Since we aim to classify nodes, the perfect node representation would be such that nodes with the same label are embedded close together, which would give a large separation between different classes. Intuitively, the key to achieve this goal is to enable nodes within the same class to connect more strongly with each other, so that they are pushed together by the GCN. We can therefore make edge strengths/weights trainable, then learn to increase the intraclass feature influence for each class  $i$ :
+
+$$
+\sum_ {v _ {a}, v _ {b}: y _ {a} = i, y _ {b} = i} \tilde {I} _ {f} \left(v _ {a}, v _ {b}\right) \tag {12}
+$$
+
+by adjusting edge weights. However, this requires operating on Jacobian matrices with the size of  $d^{(0)} \times d^{(K)}$  ( $d^{(0)}$  and  $d^{(K)}$  are the dimensions of initial and output features, respectively), which is impractical if initial node features are high-dimensional. Fortunately, we can turn to optimizing the intra-class label influence instead of Eq. (12), i.e.,
+
+$$
+\sum_ {v _ {a}, v _ {b}: y _ {a} = i, y _ {b} = i} I _ {l} \left(v _ {a}, v _ {b}\right), \tag {13}
+$$
+
+according to Theorem 2. We further show that, by the following theorem, the total intra-class label influence on a given node  $v_{a}$  is proportional to the probability that  $v_{a}$  is classified correctly by LPA:
+
+Theorem 3 (Relationship between label influence and LPA's prediction) Consider a given node  $v_{a}$  and its label  $y_{a}$ . If we treat node  $v_{a}$  as unlabeled, then the total label influence of nodes with label  $y_{a}$  on node  $v_{a}$  is proportional to the probability that node  $v_{a}$  is classified as  $y_{a}$  by LPA:
+
+$$
+\sum_ {v _ {b}: y _ {b} = y _ {a}} I _ {l} \left(v _ {a}, v _ {b}; k\right) \propto \Pr \left(\hat {y} _ {a} ^ {l p a} = y _ {a}\right), \tag {14}
+$$
+
+where  $\hat{y}_a^{lpa}$  is the predicted label of  $v_{a}$  using a  $k$ -iteration LPA.
+
+Proof of Theorem 3 is in Appendix C. Theorem 3 indicates that, if edge weights  $\{a_{ij}\}$  maximize the probability that  $v_{a}$  is correctly classified by LPA, then they also maximize the intra-class label influence on node  $v_{a}$ . We can therefore first learn the optimal edge weights  $A^{*}$  by minimizing the loss of predicted labels by LPA:
+
+$$
+\begin{array}{l} A ^ {*} = \underset {A} {\arg \min } L _ {l p a} (A) \\ = \arg \min  _ {A} \frac {1}{m} \sum_ {v _ {a}: a \leq m} J \left(\hat {y} _ {a} ^ {l p a}, y _ {a}\right), \tag {15} \\ \end{array}
+$$
+
+![](images/2409f316a6a98860ae32fbe72276eebb6baf6cf3726e11b824c6677d72077ae2.jpg)  
+(a) A graph with two classes of nodes (red vs. blue)
+
+![](images/5194ff291832bfe5c26d03805dab5e288937858f3ac701319944d3c67c958a5c.jpg)  
+(b) Potential intra-class edges (bold links)
+
+Figure 1: A graph with two classes of nodes, while white nodes are unlabeled (Figure 1a). To ease the separation of the two classes, our model will increase the connecting strength among nodes within the same class (i.e., within one dotted circle), thereby increasing their feature/label influence on each other. In this way, our model is able to identify potential intra-class edges (bold links in Figure 1b) and strengthen their weights.
+
+where  $J$  is the cross-entropy loss,  $\hat{y}_a^{lpa}$  and  $y_{a}$  are the predicted label distribution of  $v_{a}$  using LPA and the true one-hot label of  $v_{a}$ , respectively.  $a \leq m$  means  $v_{a}$  is labeled. The optimal  $A^{*}$  maximize the probability that each node is correctly labeled by LPA, thus also increasing the intra-class label influence (by Theorem 3) and intra-class feature influence (by Theorem 2). Then we can apply  $A^{*}$  and the corresponding  $D^{*}$  to a GCN to predict labels:
+
+$$
+X ^ {(k + 1)} = \sigma \left(D ^ {* - 1} A ^ {*} X ^ {(k)} W ^ {(k)}\right), k = 0, 1, \dots , K - 1. \tag {16}
+$$
+
+We use  $\hat{y}_a^{gcn}$ , the  $a$ -th row of  $X^{(K)}$ , to denote the predicted label distribution of  $v_a$  using the GCN specified in Eq. (16). The optimal transformation matrices in the GCN can be learned by minimizing the loss of predicted labels by GCN:
+
+$$
+\begin{array}{l} W ^ {*} = \underset {W} {\arg \min } L _ {g c n} (W, A ^ {*}) \\ = \arg \min  _ {W} \frac {1}{m} \sum_ {v _ {a}: a \leq m} J \left(\hat {y} _ {a} ^ {g c n}, y _ {a}\right), \tag {17} \\ \end{array}
+$$
+
+In practice, it is generally better to combine the above two steps together and train the whole model in an end-to-end fashion:
+
+$$
+W ^ {*}, A ^ {*} = \underset {W, A} {\arg \min } L _ {g c n} (W, A) + \lambda L _ {l p a} (A), \tag {18}
+$$
+
+where  $\lambda$  is the balancing hyper-parameter. In this way,  $L_{lpa}(A)$  serves as a regularization term that assists the learning of edge weights  $A$ , since it is hard for the GCN to learn
+
+![](images/ca1949c8f321cd6af9b54d215410bf7846b487af6069220b82fb31e7fff0cab3.jpg)  
+(a) Karate club network with noisy edges
+
+![](images/c9b1c8b64b0aedad6510e38c05706f1dd2c3c24972297c87cc0d07a3eb588067.jpg)  
+(b) GCN on the original network  
+Figure 2: Node embeddings of Zachary's karate club network trained on a node classification task (red vs. blue). Figure 2a visualizes the graph. Node coordinates in Figure 2b-2e are the embedding coordinates. Notice that GCN does not produce linearly separable embeddings (Figure 2b vs. Figure 2c), while GCN-LPA performs much better even in the presence of noisy edges (Figure 2d vs. Figure 2e). Additional visualizations are included in Appendix E.
+
+![](images/a017e140f81641ae536e4953053b73fcfe5adea16077b72db2bc0b17025dfdcb.jpg)  
+(c) GCN-LPA on the original network
+
+![](images/43bc2a335c1d8e5e6814fa4310a1e52c94ab461676ef3096b784e82b373e6973.jpg)  
+(d) GCN on the noisy network
+
+![](images/37480dbf00315f5325213c466e3fec1f76ecc4dfae5676fb843dd7f91491ec19.jpg)  
+(e) GCN-LPA on the noisy network
+
+both  $W$  and  $A$  simultaneously due to overfitting. The proposed GCN-LPA approach can also be seen as learning the importance of edges that can be used to reconstruct node labels accurately by LPA, then transferring this knowledge from label space to feature space for the GCN. From this perspective, GCN-LPA also connects to Theorem 1 except that the knowledge transfer is in the other direction.
+
+It is also worth noticing how the optimal  $A^{*}$  is configured. The principle here is that we do not modify the basic structure of the original graph (i.e., not adding or removing edges) but only adjusting weights of existing edges. This is equivalent to learning a positive mask matrix  $M$  for the adjacency matrix  $A$  and taking the Hadamard product  $M \circ A = A^{*}$ . Each element  $M_{ij}$  can be set as either a free variable or a function of the nodes at edge endpoints, for example,  $M_{ij} = \log \left(\exp (\mathbf{x}_i^\top \mathbf{H}\mathbf{x}_j) + 1\right)$  where  $\mathbf{H}$  is a learnable kernel matrix for measuring feature similarity.
+
+# 2.5. Analysis of GCN-LPA Model Behavior
+
+In this subsection, we show benefits of our unified model compared with GCN by analyzing properties of embeddings produced by the two models. We first analyze the update rule of GCN for node  $v_{i}$ :
+
+$$
+\mathbf {x} _ {i} ^ {(k + 1)} = \sigma \left(\sum_ {v _ {j} \in \mathcal {N} (v _ {i})} \tilde {a} _ {i j} \mathbf {x} _ {j} ^ {(k)} W ^ {(k)}\right), \tag {19}
+$$
+
+where  $\tilde{a}_{ij} = a_{ij} / d_{ii}$  is the normalized weight of edge  $(j,i)$ . This formula can be decomposed into the following two steps:
+
+(1) In aggregation step, we calculate the aggregated representation  $\mathbf{h}_i^{(k)}$  of all neighborhoods  $\mathcal{N}(v_i)$ :
+
+$$
+\mathbf {h} _ {i} ^ {(k)} = \sum_ {v _ {j} \in \mathcal {N} (v _ {i})} \tilde {a} _ {i j} \mathbf {x} _ {j} ^ {(k)}. \tag {20}
+$$
+
+(2) In transformation step, the aggregated representation  $\mathbf{h}_i^{(k)}$  is mapped to a new space by a transformation matrix
+
+and nonlinear function:
+
+$$
+\mathbf {x} _ {i} ^ {(k + 1)} = \sigma \left(\mathbf {h} _ {i} ^ {(k)} W ^ {(k)}\right). \tag {21}
+$$
+
+We show by the following theorem that the aggregation step reduces the overall distance in the embedding space between the nodes that are connected in the graph:
+
+Theorem 4 (Shrinking property in GCN) Let  $D(\mathbf{x}) = \frac{1}{2}\sum_{v_i,v_j}\tilde{a}_{ij}\| \mathbf{x}_i - \mathbf{x}_j\| _2^2$  be a distance metric over node embeddings  $\mathbf{x}$ . Then we have
+
+$$
+D (\mathbf {h} ^ {(k)}) \leq D (\mathbf {x} ^ {(k)}).
+$$
+
+Proof of Theorem 4 is in Appendix D. Theorem 4 indicates that the overall distance among connected nodes is reduced after taking one aggregation step, which implies that connected components in the graph "shrink" and nodes within each connected component get closer to each other in the embedding space. In an ideal case where edges only connect nodes with the same label, the aggregation step will push nodes within the same class together, which greatly benefits the transformation step that acts like a hyperplane  $W^{(k)}$  for classification. However, two connected nodes may have different labels. These "noisy" edges will impede the formation of clusters and make the inter-class boundary less clear.
+
+Fortunately, in GCN-LPA, edge weights are learned by minimizing the difference between ground-truth labels and labels reconstructed from multi-hop neighbors. This will force the model to increase weight/bandwidth of possible paths that connect nodes with the same label, so that labels can "flow" easily along these paths for the purpose of label reconstruction. In this way, GCN-LPA is able to identify potential intra-class edges and increase their weights to assist learning clustering structures. Figure 1 gives a toy example illustrating how our model works intuitively.
+
+To empirically justify our claim, we apply a two-layer untrained GCN with randomly initialized transformation matrices to the well-known Zachary's karate club network
+
+<table><tr><td></td><td>Cora</td><td>Citeseer</td><td>Pubmed</td><td>Coauthor-CS</td><td>Coauthor-Phy</td></tr><tr><td># nodes</td><td>2,708</td><td>3,327</td><td>19,717</td><td>18,333</td><td>34,493</td></tr><tr><td># edges</td><td>5,278</td><td>4,552</td><td>44,324</td><td>81,894</td><td>247,962</td></tr><tr><td># features</td><td>1,433</td><td>3,703</td><td>500</td><td>6,805</td><td>8,415</td></tr><tr><td># classes</td><td>7</td><td>6</td><td>3</td><td>15</td><td>5</td></tr><tr><td>Intra-class edge rate</td><td>81.0%</td><td>73.6%</td><td>80.2%</td><td>80.8%</td><td>93.1%</td></tr></table>
+
+Table 1: Dataset statistics after removing self-loops and duplicate edges.
+
+(Zachary, 1977) as shown in Figure 2a, which contains 34 nodes of 2 classes and 78 unweighted edges (grey solid lines). We then increase the weights of intra-class edges by ten times to simulate GCN-LPA. We find that GCN works well on this network (Figure 2b), but GCN-LPA performs even better than GCN because the node embeddings are completely linearly separable as shown in Figure 2c. To further justify our claim, we randomly add 20 "noisy" inter-class edges (grey dotted lines) to the original network, from which we observe that GCN is misled by noise and mixes nodes of two classes together (Figure 2d), but GCN-LPA still distinguishes the two clusters (Figure 2e) because it is better at "denoising" undesirable edges based on the supervised signal of labels.
+
+# 3. Connection to Existing Work
+
+Edge weights play a key role in graph-based node classification as well as representation learning. In this section, we discuss three lines of related work that learn edge weights adaptively.
+
+# 3.1. Locally Linear Embedding
+
+Locally linear embedding (LLE) (Roweis & Saul, 2000) and its variants (Zhang & Wang, 2007; Kong et al., 2012) learn edge weights by constructing a linear dependency between a node and its neighbors, then use the learned edge weights to embed high-dimensional nodes into a low-dimensional space. Our work is similar to LLE in the aspect of transferring the knowledge of edge importance from one space to another, but the difference is that LLE is an unsupervised dimension reduction method that learns the graph structure based on local proximity only, while our work is semi-supervised and explores high-order relationship among nodes.
+
+# 3.2. Label Propagation Algorithm
+
+Classical LPA (Zhu et al., 2005; Zhou et al., 2004) can only make use of node labels rather than node features. In contrast, adaptive LPA considers node features by making edge weights learnable. Typical techniques of learning edge weights include adopting kernel functions (Zhu et al., 2003; Liu et al., 2019a) (e.g.,  $a_{ij} = \exp(-\sum_d (x_{id} - x_{jd})^2 / \sigma_d^2)$ )
+
+where  $d$  is dimensionality of features), minimizing neighborhood reconstruction error (Wang & Zhang, 2008; Karasuyama & Mamitsuka, 2013), using leave-one-out loss (Zhang & Lee, 2007), or imposing sparseness on edge weights (Hong et al., 2009). However, in these LPA variants, node features are only used to assist learning the graph structure rather than explicitly mapped to node labels, which limits their capability in node classification. Another notable difference is that adaptive LPA learns edge weights by introducing the regularizations above, while our work takes LPA itself as regularization to learn edge weights.
+
+# 3.3. Attention Mechanism on Graphs
+
+Our method is also conceptually connected to attention mechanism on graphs (Veličković et al., 2018; Thekumparampil et al., 2018; Zhang et al., 2018; Liu et al., 2019b), in which an attention weight  $\alpha_{ij}$  is learned between node  $v_i$  and  $v_j$ . For example,  $\alpha_{ij} = \text{LeakyReLU}(\boldsymbol{a}^\top[W\mathbf{x}_i||W\mathbf{x}_j])$  in GAT (Veličković et al., 2018),  $\alpha_{ij} = a \cdot \cos(W\mathbf{x}_i, W\mathbf{x}_j)$  in AGNN (Thekumparampil et al., 2018),  $\alpha_{ij} = (W_1\mathbf{x}_i)^\top W_2\mathbf{x}_j$  in GaAN (Zhang et al., 2018), and  $\alpha_{ij} = \boldsymbol{a}^\top \tanh(W_1\mathbf{x}_i + W_2\mathbf{x}_j)$  in GeniePath (Liu et al., 2019b), where  $a$  and  $W$  are trainable variables. A significant difference between these attention mechanisms and our work is that attention weights are learned based merely on feature similarity, while we propose that edge weights should be consistent with the distribution of labels on the graph, which requires less handcrafting of the attention function and is more task-oriented. Nevertheless, all the above formulas for calculating attentions can also be used in our model as the implementation of edge weights.
+
+# 4. Experiments
+
+We evaluate our model and present its performance on five datasets including citation networks and coauthor networks. We also study the hyper-parameter sensitivity and provide training time analysis.
+
+# 4.1. Datasets
+
+We use the following five datasets in our experiments:
+
+Citation networks: We consider three citation network
+
+<table><tr><td>Method</td><td>Cora</td><td>Citeseer</td><td>Pubmed</td><td>Coauthor-CS</td><td>Coauthor-Phy</td></tr><tr><td>MLP</td><td>64.6 ± 1.7</td><td>62.0 ± 1.8</td><td>85.9 ± 0.3</td><td>91.7 ± 1.4</td><td>94.1 ± 1.2</td></tr><tr><td>LR</td><td>77.3 ± 1.8</td><td>71.2 ± 1.8</td><td>86.0 ± 0.6</td><td>91.1 ± 0.6</td><td>93.8 ± 1.1</td></tr><tr><td>LPA</td><td>85.3 ± 0.9</td><td>70.0 ± 1.7</td><td>82.6 ± 0.6</td><td>91.3 ± 0.2</td><td>94.9 ± 0.4</td></tr><tr><td>GCN</td><td>88.2 ± 0.8</td><td>77.3 ± 1.5</td><td>87.2 ± 0.4</td><td>93.6 ± 1.5</td><td>96.2 ± 0.2</td></tr><tr><td>GAT</td><td>87.7 ± 0.3</td><td>76.2 ± 0.9</td><td>86.9 ± 0.5</td><td>93.8 ± 0.4</td><td>96.3 ± 0.7</td></tr><tr><td>JK-Net</td><td>89.1 ± 1.2</td><td>78.3 ± 0.9</td><td>85.8 ± 1.1</td><td>92.4 ± 0.4</td><td>94.8 ± 0.4</td></tr><tr><td>GraphSAGE</td><td>86.8 ± 1.9</td><td>75.2 ± 1.1</td><td>84.7 ± 1.6</td><td>92.6 ± 1.6</td><td>94.5 ± 1.1</td></tr><tr><td>GCN-LPA</td><td>88.5 ± 1.5</td><td>78.7 ± 0.6</td><td>87.8 ± 0.6</td><td>94.8 ± 0.4</td><td>96.9 ± 0.2</td></tr></table>
+
+Table 2: Mean and the  ${95}\%$  confidence intervals of test set accuracy for all methods and datasets.
+
+datasets (Sen et al., 2008): Cora, Citeseer, and Pubmed. In these datasets, nodes correspond to documents, edges correspond to citation links, and each node has a sparse bag-of-words feature vector as well as a class label.
+
+Coauthor networks: We also use two co-authorship networks (Shchur et al., 2018), Coauthor-CS and Coauthor-Phy, based on Microsoft Academic Graph from the KDD Cup 2016 challenge. Here nodes are authors and an edge indicates that two authors co-authored a paper. Node features represent paper keywords for each author's papers, and class labels indicate most active fields of study for each author.
+
+Statistics of the five datasets are shown in Table 1. We also calculate the intra-class edge rate (the fraction of edges that connect two nodes within the same class), which is significantly higher than inter-class edge rate in all networks. The finding supports our claim in Section 2.5 that node classification benefits from intra-class edges in a graph.
+
+# 4.2. Baselines
+
+We compare against the following baselines in our experiments. The first two baselines only utilize node features, the third baseline only utilizes graph structure, while the rest of baselines are GNN-based methods utilizing both node features and graph structure as input. Hyper-parameters of baselines are set as default in Python packages or their open-source codes unless otherwise stated.
+
+- Multi-layer Perceptron (MLP) and Logistic Regression (LR) are feature-based methods that do not consider the graph structure. We set solver='lbfgs' for LR and hidden_layer_sizes=50 for MLP using Python sklearnnn package.  
+- Label Propagation (LPA) (Zhu et al., 2005), on the other hand, only consider the graph structure and ignore node features. We set the iteration of LPA as 20 in our implementation.  
+- Graph Convolutional Network (GCN) (Kipf & Welling, 2017) proposes a first-order approximation to spectral graph convolutions.
+
+- Graph Attention Network (GAT) (Veličković et al., 2018) propose an attention mechanism to treat neighbors differently in the aggregation step.  
+- Jumping Knowledge Networks (JK-Net) (Xu et al., 2018) leverages different neighborhood ranges for each node to enable structure-aware representation. We use concat as the aggregator for JK-Net.  
+- Graph Sampling and Aggregation (GraphSAGE) (Hamilton et al., 2017) is a mini-batch implementation of GCN that uses neighborhood sampling strategy and different aggregation schemes. We use mean as the aggregator for GraphSAGE.
+
+# 4.3. Experimental Setup
+
+Our experiments focus on the transductive setting where we only know labels of part of nodes but have access to the entire graph as well as features of all nodes. The ratio of training, validation, and test set are set as  $6:2:2$ . The weight of each edge is treated as a free variable during training. We train our model for 200 epochs using Adam (Kingma & Ba, 2015) and report the test set accuracy when validation set accuracy is maximized. Each experiment is repeated three times and we report the mean and the  $95\%$  confidence interval. We initialize weights according to (Glorot & Bengio, 2010) and row-normalize input features. During training, we apply L2 regularization to the transformation matrices and use the dropout technique (Srivastava et al., 2014). The settings of all other hyper-parameters can be found in Appendix F.
+
+# 4.4. Results
+
+The results of node classification are summarized in Table 2. Table 2 indicates that only using node features (MLP, LR) or graph structure (LPA) will lead to information loss and can
+
+![](images/18da67f84abc459671f8395ca64af9b2e1a4783f2ce57bd1e1ac983d90496c0a.jpg)  
+Figure 3: Sensitivity to # LPA iterations on Citeseer dataset.
+
+![](images/d30894d0239476a3a8b3ecdca30a1d811d1698ea07867f6e01773adb71c75964.jpg)  
+Figure 4: Sensitivity to  $\lambda$  on Citeseer dataset.
+
+![](images/cdfa3cb05c37750c2314943e5be3993af30f045185a228c872a7be5c866f6a50.jpg)  
+Figure 5: Training time per epoch on random graphs.
+
+<table><tr><td>Ratio of labeled nodes</td><td>0%</td><td>20%</td><td>40%</td><td>60%</td><td>80%</td><td>100%</td></tr><tr><td>Accuracy</td><td>75.8 ± 1.0</td><td>76.3 ± 1.1</td><td>76.7 ± 0.8</td><td>77.3 ± 0.7</td><td>78.1 ± 0.6</td><td>78.7 ± 0.6</td></tr></table>
+
+Table 3: Result of GCN-LPA on Citeseer dataset with differet ratio of labeled nodes in LPA.
+
+not fully exploit datasets in general. The results demonstrate that our proposed GCN-LPA model surpasses state-of-the-art GCN/GNN baselines. We note that JK-Net is a strong baseline on Cora, but it does not perform consistently well on other datasets.
+
+We investigate the influence of the number of LPA iterations and the training weight of LPA loss term  $\lambda$  on the performance of classification. The results on Citeseer dataset are plotted in Figures 3 and 4, respectively, where each line corresponds to a given number of GCN layers in GCN-LPA. From Figure 3 we observe that the performance is boosted at first when the number of LPA iterations increases, then the accuracy stops increasing and decreases since a large number of LPA iterations will include more noisy nodes. Figure 4 shows that training without the LPA loss term (i.e.,  $\lambda = 0$ ) is more difficult than the case where  $\lambda = 1 \sim 5$ , which justifies our aforementioned claim that it is hard for the GCN part to learn both transformation matrices  $W$  and edge weights  $A$  simultaneously without the assistance of LPA regularization.
+
+To further show how much the LPA impacts the performance, we vary the ratio of labeled nodes in LPA from  $100\%$  to  $0\%$  during training, and report the result of accuracy on Citeseer dataset in Table 3. From Table 3 we observe that the performance of GCN-LPA gets worse when the ratio of labeled nodes in LPA decreases. In addition, using more labeled nodes in LPA also helps improve the model stability. Note that a ratio of  $0\%$  does not mean that GCN-LPA is equivalent to GCN (Kipf & Welling, 2017) because the edge weights in GCN-LPA is still trainable, which increases the risk of overfitting the training data.
+
+We study the training time of GCN-LPA on random graphs. We use the one-hot identity vector as feature and 0 as label for each node. The size of training set and validation set
+
+is 100 and 200, respectively, while the rest is test set. The average number of neighbors for each node is set as 5, and the number of nodes is varied from one thousand to one million. We run GCN-LPA and GCN for 100 epochs on a Microsoft Azure virtual machine with 1 NVIDIA Tesla M60 GPU, 12 Intel Xeon CPUs (E5-2690 v3 @2.60GHz), and 128GB of RAM, using the same hyper-parameter setting as in Cora. The training time per epoch of GCN-LPA and GCN is presented in Figure 5. Our result shows that GCN-LPA requires only  $9.2\%$  extra training time on average compared to GCN.
+
+# 5. Conclusion and Future Work
+
+We studied the theoretical relationship between two types of well-known graph-based models for node classification, Label Propagation Algorithm and Graph Convolutional Neural Networks, from the perspectives of feature/label smoothing and feature/label influence. We then propose a unified model GCN-LPA, which learns transformation matrices and edge weights simultaneously in GCN with the assistance of LPA regularizer. We also analyze why our unified model performs better than traditional GCN in node classification. Experiments on five datasets demonstrate that our model outperforms state-of-the-art baselines, and it is also highly time-efficient with respect to the size of a graph.
+
+We point out two avenues of possible directions for future work. First, our proposed model focuses on transductive setting where all node features and the entire graph structure are given. An interesting problem is how the model performs in inductive setting where we have no access to test nodes during training. Second, the question of how to generalize the idea of our model to GNNs with different aggregation functions (e.g., concatenation or max-pooling) is also a promising direction.
+
+# References
+
+Glorot, X. and Bengio, Y. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the 13th International Conference on Artificial Intelligence and Statistics, 2010.  
+Gong, C., Tao, D., Liu, W., Liu, L., and Yang, J. Label propagation via teaching-to-learn and learning-to-teach. IEEE Transactions on Neural Networks and Learning Lystems, 28(6), 2017.  
+Hamilton, W., Ying, Z., and Leskovec, J. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, 2017.  
+Hong, C., Liu, Z., and Yang, J. Sparsity induced similarity measure for label propagation. In Proceedings of the 12th IEEE International Conference on Computer Vision. IEEE, 2009.  
+Karasuyama, M. and Mamitsuka, H. Manifold-based similarity adaptation for label propagation. In Advances in Neural Information Processing Systems, 2013.  
+Kingma, D. P. and Ba, J. Adam: A method for stochastic optimization. In Proceedings of the 3rd International Conference on Learning Representations, 2015.  
+Kipf, T. N. and Welling, M. Semi-supervised classification with graph convolutional networks. In Proceedings of the 5th International Conference on Learning Representations, 2017.  
+Koh, P. W. and Liang, P. Understanding black-box predictions via influence functions. In Proceedings of the 34th International Conference on Machine Learning, 2017.  
+Kong, D., Ding, C., Huang, H., and Nie, F. An iterative locally linear embedding algorithm. In Proceedings of the 29th International Coherence on International Conference on Machine Learning. Omnipress, 2012.  
+Li, Q., Han, Z., and Wu, X.-M. Deeper insights into graph convolutional networks for semi-supervised learning. In The 32nd AAAI Conference on Artificial Intelligence, 2018.  
+Liao, R., Zhao, Z., Urtasun, R., and Zemel, R. S. Lanczosnet: Multi-scale deep graph convolutional networks. In Proceedings of the 7th International Conference on Learning Representations, 2019.  
+Liu, Y., Lee, J., Park, M., Kim, S., Yang, E., Hwang, S. J., and Yang, Y. Learning to propagate labels: Transductive propagation network for few-shot learning. In Proceedings of the 7th International Conference on Learning Representations, 2019a.
+
+Liu, Z., Chen, C., Li, L., Zhou, J., Li, X., Song, L., and Qi, Y. Geniepath: Graph neural networks with adaptive receptive paths. In The 33rd AAAI Conference on Artificial Intelligence, 2019b.  
+Qu, M., Bengio, Y., and Tang, J. Gmnn: Graph markov neural networks. In Proceedings of the 36th International Conference on Machine Learning, 2019.  
+Roweis, S. T. and Saul, L. K. Nonlinear dimensionality reduction by locally linear embedding. science, 290(5500), 2000.  
+Sen, P., Namata, G., Bilgic, M., Getoor, L., Galligher, B., and Eliassi-Rad, T. Collective classification in network data. AI magazine, 29(3), 2008.  
+Shchur, O., Mumme, M., Bojchevski, A., and Gunnemann, S. Pitfalls of graph neural network evaluation. In Neural Information Processing Systems Workshop on Relational Representation Learning, 2018.  
+Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I., and Salakhutdinov, R. Dropout: a simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1), 2014.  
+Thekumparamil, K. K., Wang, C., Oh, S., and Li, L.-J. Attention-based graph neural network for semi-supervised learning. arXiv preprint arXiv:1803.03735, 2018.  
+Veličković, P., Cucurull, G., Casanova, A., Romero, A., Lio, P., and Bengio, Y. Graph attention networks. In Proceedings of the 6th International Conference on Learning Representations, 2018.  
+Wang, F. and Zhang, C. Label propagation through linear neighborhoods. IEEE Transactions on Knowledge and Data Engineering, 20(1), 2008.  
+Xu, K., Li, C., Tian, Y., Sonobe, T., Kawarabayashi, K.-i., and Jegelka, S. Representation learning on graphs with jumping knowledge networks. In Proceedings of the 35th International Conference on Machine Learning, 2018.  
+Xu, K., Hu, W., Leskovec, J., and Jegelka, S. How powerful are graph neural networks? In Proceedings of the 7th International Conference on Learning Representations, 2019.  
+Zachary, W. W. An information flow model for conflict and fission in small groups. Journal of anthropological research, 33(4), 1977.  
+Zhang, J., Shi, X., Xie, J., Ma, H., King, I., and Yeung, D.-Y. Gaan: Gated attention networks for learning on large and spatiotemporal graphs. arXiv preprint arXiv:1803.07294, 2018.
+
+Zhang, X. and Lee, W. S. Hyperparameter learning for graph based semi-supervised learning algorithms. In Advances in Neural Information Processing Systems, 2007.  
+Zhang, Z. and Wang, J. Mlle: Modified locally linear embedding using multiple weights. In Advances in Neural Information Processing Systems, 2007.  
+Zhou, D., Bousquet, O., Lal, T. N., Weston, J., and Scholkopf, B. Learning with local and global consistency. In Advances in Neural Information Processing Systems, 2004.  
+Zhu, X., Ghahramani, Z., and Lafferty, J. D. Semi-supervised learning using gaussian fields and harmonic functions. In Proceedings of the 20th International Conference on Machine Learning, 2003.  
+Zhu, X., Lafferty, J., and Rosenfeld, R. Semi-supervised learning with graphs. PhD thesis, Carnegie Mellon University, school of language technologies institute, 2005.
+
+# Appendix
+
+# A. Proof of Theorem 1
+
+Proof. Denote  $\tilde{a}_{ij} = a_{ij} / d_{ii}$  as the normalized weight of edge  $(j,i)$ . It is clear that  $\sum_{j\in \mathcal{N}(i)}\tilde{a}_{ij} = 1$ . Given that  $\mathcal{M}$  is differentiable, we perform a first-order Taylor expansion with Peano's form of remainder at  $\mathbf{x}_i$  for  $\sum_{j\in \mathcal{N}(i)}\tilde{a}_{ij}y_j$ :
+
+$$
+\begin{array}{l} \sum_ {j \in \mathcal {N} (i)} \tilde {a} _ {i j} y _ {j} = \sum_ {j \in \mathcal {N} (i)} \tilde {a} _ {i j} \mathcal {M} (\mathbf {x} _ {j}) \\ = \sum_ {j \in \mathcal {N} (i)} \tilde {a} _ {i j} \left(\mathcal {M} (\mathbf {x} _ {i}) + \frac {\partial \mathcal {M} (\mathbf {x} _ {i})}{\partial \mathbf {x} ^ {\top}} (\mathbf {x} _ {j} - \mathbf {x} _ {i}) + o \left(\left\| \mathbf {x} _ {j} - \mathbf {x} _ {i} \right\| _ {2}\right)\right) \\ = \mathcal {M} \left(\mathbf {x} _ {i}\right) + \frac {\partial \mathcal {M} \left(\mathbf {x} _ {i}\right)}{\partial \mathbf {x} ^ {\top}} \sum_ {j \in \mathcal {N} (i)} \tilde {a} _ {i j} \left(\mathbf {x} _ {j} - \mathbf {x} _ {i}\right) + \sum_ {j \in \mathcal {N} (i)} \tilde {a} _ {i j} o \left(\left\| \mathbf {x} _ {j} - \mathbf {x} _ {i} \right\| _ {2}\right) \tag {22} \\ = y _ {i} - \frac {\partial \mathcal {M} (\mathbf {x} _ {i})}{\partial \mathbf {x} ^ {\top}} \epsilon_ {i} + \sum_ {j \in \mathcal {N} (i)} \tilde {a} _ {i j} o \left(\left\| \mathbf {x} _ {j} - \mathbf {x} _ {i} \right\| _ {2}\right). \\ \end{array}
+$$
+
+According to Cauchy-Schwarz inequality and  $L$ -Lipschitz property, we have
+
+$$
+\left| \frac {\partial \mathcal {M} \left(\mathbf {x} _ {i}\right)}{\partial \mathbf {x} ^ {\top}} \epsilon_ {i} \right| \leq \left\| \frac {\partial \mathcal {M} \left(\mathbf {x} _ {i}\right)}{\partial \mathbf {x} ^ {\top}} \right\| _ {2} \| \epsilon_ {i} \| _ {2} \leq L \| \epsilon_ {i} \| _ {2}. \tag {23}
+$$
+
+Therefore, the approximation of  $y_{i}$  is bounded by
+
+$$
+\begin{array}{l} \left| y _ {i} - \sum_ {j \in \mathcal {N} (i)} \tilde {a} _ {i j} y _ {j} \right| \\ = \left| \frac {\partial \mathcal {M} \left(\mathbf {x} _ {i}\right)}{\partial \mathbf {x} ^ {\top}} \epsilon_ {i} - \sum_ {j \in \mathcal {N} (i)} \tilde {a} _ {i j} o \left(\left\| \mathbf {x} _ {j} - \mathbf {x} _ {i} \right\| _ {2}\right) \right| \tag {24} \\ \leq \left| \frac {\partial \mathcal {M} (\mathbf {x} _ {i})}{\partial \mathbf {x} ^ {\top}} \epsilon_ {i} \right| + \left| \sum_ {j \in \mathcal {N} (i)} \tilde {a} _ {i j} o \left(\left\| \mathbf {x} _ {j} - \mathbf {x} _ {i} \right\| _ {2}\right) \right| \\ \leq L \| \epsilon_ {i} \| _ {2} + o \big (\max  _ {j \in \mathcal {N} (i)} \big (\| \mathbf {x} _ {j} - \mathbf {x} _ {i} \| _ {2} \big) \big). \\ \end{array}
+$$
+
+# B. Proof of Theorem 2
+
+Before proving Theorem 2, we first give two lemmas that demonstrate the exact form of feature influence and label influence defined in this paper. The relationship between feature influence and label influence can then be deduced from their exact forms.
+
+Lemma 1 Assume that the nonlinear activation function in GCN is ReLU. Let  $\mathcal{P}_k^{a\to b}$  be a path  $[v^{(k)},v^{(k - 1)},\dots ,v^{(0)}]$  of length  $k$  from node  $v_{a}$  to node  $v_{b}$ , where  $v^{(k)} = v_{a},v^{(0)} = v_{b}$ , and  $v^{(i - 1)}\in \mathcal{N}(v^{(i)})$  for  $i = k,\dots ,1$ . Then we have
+
+$$
+\tilde {I} _ {f} \left(v _ {a}, v _ {b}; k\right) = \sum_ {\mathcal {P} _ {k} ^ {a \rightarrow b}} \prod_ {i = k} ^ {1} \tilde {a} _ {v ^ {(i - 1)}, v ^ {(i)}}, \tag {25}
+$$
+
+where  $\tilde{a}_{v^{(i - 1)},v^{(i)}}$  is the normalized weight of edge  $(v^{(i)},v^{(i - 1)})$ .
+
+Proof. See (Xu et al., 2018) for the detailed proof.
+
+The product term in Eq. (25) is the probability of a given path  $\mathcal{P}_k^{a\to b}$ . Therefore, the right hand side in Eq. (25) is the sum over probabilities of all possible paths of length  $k$  from  $v_{a}$  to  $v_{b}$ , which is the probability that a random walk starting at  $v_{a}$  ends at  $v_{b}$  after taking  $k$  steps.
+
+![](images/31d252c8c4f55138d0318affcb675be92c85f2cb31d8847acd699bc83b775f78.jpg)
+
+![](images/36750eb1612e652ef712b3775e2f8e6d6d9e5e9dfaa73a769b6a941921b0de74.jpg)  
+(a) Iteration 1
+
+![](images/e9f60c70c71fd30ed84abc8a49021c8ef58f3d6f39c30ba17779bc1f1d7dc461.jpg)  
+(b) Iteration 2  
+Figure 6: An illustrating example of label propagation in LPA. Suppose labels are propagated for three iterations, and no self-loop exists. Blue nodes are labeled while white nodes are unlabeled. (a)  $v_{a}$ 's label propagates to  $v_{1}$  (yellow arrows). Note that the propagation of  $v_{a}$ 's label to  $v_{3}$  is cut off since  $v_{3}$  is labeled thus absorbing  $v_{a}$ 's label. (b)  $v_{a}$ 's label that propagated to  $v_{1}$  further propagates to  $v_{2}$  and  $v_{b}$  (yellow arrows). Meanwhile,  $v_{a}$ 's label is reset to its initial value then propagates from  $v_{a}$  again (green arrows). (c) Label propagation in iteration 3. Purple arrows denote the propagation of  $v_{a}$ 's label starting from  $v_{a}$  for the third time. (d) All possible paths of length no more than three from  $v_{a}$  to  $v_{b}$  containing unlabeled nodes only. Note that there is no path of length one from  $v_{a}$  to  $v_{b}$ .
+
+![](images/c1d1a54ceae06ad53e66a140f3589da4498298daa5f9c8bb776470fe24401598.jpg)  
+(c) Iteration 3
+
+![](images/8b7f69df6effed288fd5f80e4cf1052770be507033959044bab7544c38cd9552.jpg)  
+(d) Paths from  $v_{a}$  to  $v_{b}$
+
+Lemma 2 Let  $\mathcal{U}_j^{a\to b}$  be a path  $[v^{(j)},v^{(j - 1)},\dots ,v^{(0)}]$  of length  $j$  from node  $v_{a}$  to node  $v_{b}$ , where  $v^{(j)} = v_{a}$ ,  $v^{(0)} = v_{b}$ ,  $v^{(i - 1)}\in \mathcal{N}(v^{(i)})$  for  $i = j,\dots ,1$ , and all nodes along the path are unlabeled except  $v^{(0)}$ . Then we have
+
+$$
+I _ {l} \left(v _ {a}, v _ {b}; k\right) = \sum_ {j = 1} ^ {k} \sum_ {\mathcal {U} _ {j} ^ {a \rightarrow b}} \prod_ {i = j} ^ {1} \tilde {a} _ {v ^ {(i - 1)}, v ^ {(i)}}, \tag {26}
+$$
+
+where  $\tilde{a}_{v(i - 1),v(i)}$  is the normalized weight of edge  $(v^{(i)},v^{(i - 1)})$ .
+
+To intuitively understand this lemma, note that there are two differences between Lemma 1 and Lemma 2: (1) In Lemma 1,  $\tilde{I}_f(v_a,v_b;k)$  sums over all paths from  $v_{a}$  to  $v_{b}$  of length  $k$ , but in Lemma 2,  $I_l(v_a,v_b;k)$  sums over all paths from  $v_{a}$  to  $v_{b}$  of length no more than  $k$ . The is because in LPA,  $v_{b}$ 's label is reset to its initial value after each iteration, which means that the label of  $v_{b}$  serves as a constant signal that begins propagating in the graph again and again after each iteration. (2) In Lemma 1 we consider all possible paths from  $v_{a}$  to  $v_{b}$ , but in Lemma 2, the paths are restricted to contain unlabeled nodes only. The reason here is the same as above: Since the labels of labeled nodes are reset to their initial values after each iteration in LPA, the influence of  $v_{b}$ 's label will be absorbed in labeled nodes, and the propagation of  $v_{b}$ 's label will be cut off at these nodes. Therefore,  $v_{b}$ 's label can only flow to  $v_{a}$  along the paths with unlabeled nodes only. See Figure 6 for an illustrating example showing the label propagation in LPA.
+
+Proof. As mentioned above, a significant difference between LPA and GCN is that all labeled nodes are reset to its original labels after each iteration in LPA. This implies that the initial label  $y_{b}$  of node  $v_{b}$  appears not only as  $y_{b}^{(0)}$ , but also as every  $y_{b}^{(j)}$  for  $j = 1, \dots, k - 1$ . Therefore, the influence of  $y_{b}$  on  $y_{a}^{(k)}$  is the cumulative influence of  $y_{b}^{(j)}$  on  $y_{a}^{(k)}$  for  $j = 0, 1, \dots, k - 1$ :
+
+$$
+I _ {l} \left(v _ {a}, v _ {b}; k\right) = \frac {\partial y _ {a} ^ {(k)}}{\partial y _ {b}} = \sum_ {j = 0} ^ {k - 1} \frac {\partial y _ {a} ^ {(k)}}{\partial y _ {b} ^ {(j)}}. \tag {27}
+$$
+
+According to the updating rule of LPA, we have
+
+$$
+\frac {\partial y _ {a} ^ {(k)}}{\partial y _ {b} ^ {(j)}} = \frac {\partial \sum_ {v _ {z} \in \mathcal {N} (v _ {a})} \tilde {a} _ {a z} y _ {z} ^ {(k - 1)}}{\partial y _ {b} ^ {(j)}} = \sum_ {v _ {z} \in \mathcal {N} (v _ {a})} \tilde {a} _ {a z} \frac {\partial y _ {z} ^ {(k - 1)}}{\partial y _ {b} ^ {(j)}}. \tag {28}
+$$
+
+In the above equation, the derivative  $\frac{\partial y_a^{(k)}}{\partial y_b^{(j)}}$  is decomposed into the weighted average of  $\frac{\partial y_z^{(k - 1)}}{\partial y_b^{(j)}}$ , where  $v_{z}$  traverses all neighbors of  $v_{a}$ . For those  $v_{z}$ 's that are initially labeled,  $y_{z}^{(k - 1)}$  is reset to their initial labels in each iteration. Therefore, they are always constant and independent of  $y_{b}^{(j)}$ , meaning that their derivatives w.r.t.  $y_{b}^{(j)}$  are zero. So we only need to
+
+consider the terms where  $v_{z}$  is an unlabeled node:
+
+$$
+\frac {\partial y _ {a} ^ {(k)}}{\partial y _ {b} ^ {(j)}} = \sum_ {v _ {z} \in \mathcal {N} (v _ {a}), z > m} \tilde {a} _ {a z} \frac {\partial y _ {z} ^ {(k - 1)}}{\partial y _ {b} ^ {(j)}}, \tag {29}
+$$
+
+where  $z > m$  means  $v_{z}$  is unlabeled. To intuitively understand Eq. (29), one can imagine that we perform a random walk starting from node  $v_{a}$  for one step, where the "transition probability" is the edge weights  $\tilde{a}$ , and all nodes in this random walk are restricted to unlabeled nodes only. Note that we can further decompose every  $y_{z}^{(k-1)}$  in Eq. (29) in the way similar to what we do for  $y_{a}^{(k)}$  in Eq. (28). So the expansion in Eq. (29) can be performed iteratively until the index  $k$  decreases to  $j$ . This is equivalent to performing all possible random walks for  $k - j$  steps starting from  $v_{a}$ , where all nodes but the last in the random walk are restricted to be unlabeled nodes:
+
+$$
+\frac {\partial y _ {a} ^ {(k)}}{\partial y _ {b} ^ {(j)}} = \sum_ {v _ {z} \in \mathcal {V}} \sum_ {\mathcal {U} _ {k - j} ^ {a \rightarrow z}} \left(\prod_ {i = k - j} ^ {1} \tilde {a} _ {v ^ {(i - 1)}, v ^ {(i)}}\right) \frac {\partial y _ {z} ^ {(j)}}{\partial y _ {b} ^ {(j)}}, \tag {30}
+$$
+
+where  $v_{z}$  in the first summation term is the end node of a random walk,  $\mathcal{U}_{k - j}^{a\to z}$  in the second summation term is an unlabeled-nodes-only path from  $v_{a}$  to  $v_{z}$  of length  $k - j$ , and the product term is the probability of a given path  $\mathcal{U}_{k - j}^{a\to z}$ . Consider the last term  $\frac{\partial y_z^{(j)}}{\partial y_b^{(j)}}$  in Eq. (30). We know that  $\frac{\partial y_z^{(j)}}{\partial y_b^{(j)}} = 0$  for all  $z\neq b$  and  $\frac{\partial y_z^{(j)}}{\partial y_b^{(j)}} = 1$  for  $z = b$ , which means that only those random-walk paths that end exactly at  $v_{b}$  (i.e., the end node  $v_{z}$  is exactly  $v_{b}$ ) count for the computation in Eq. (30). Therefore, we have
+
+$$
+\frac {\partial y _ {a} ^ {(k)}}{\partial y _ {b} ^ {(j)}} = \sum_ {\mathcal {U} _ {k - j} ^ {a \rightarrow b}} \prod_ {i = k - j} ^ {1} \tilde {a} _ {v ^ {(i - 1)}, v ^ {(i)}}, \tag {31}
+$$
+
+where  $\mathcal{U}_{k - j}^{a\rightarrow b}$  is a path from  $v_{a}$  to  $v_{b}$  of length  $k - j$  containing only unlabeled nodes except  $v_{b}$ . Substituting the right hand term of Eq. (27) with Eq. (31), we obtain that
+
+$$
+I _ {l} \left(v _ {a}, v _ {b}; k\right) = \sum_ {j = 0} ^ {k - 1} \sum_ {\mathcal {U} _ {k - j} ^ {a \rightarrow b}} \prod_ {i = k - j} ^ {1} \tilde {a} _ {v ^ {(i - 1)}, v ^ {(i)}} = \sum_ {j = 1} ^ {k} \sum_ {\mathcal {U} _ {j} ^ {a \rightarrow b}} \prod_ {i = j} ^ {1} \tilde {a} _ {v ^ {(i - 1)}, v ^ {(i)}}. \tag {32}
+$$
+
+Now Theorem 2 can be proved by combining Lemma 1 and Lemma 2:
+
+Proof. Suppose that whether a node is labeled or not is independent of each other for the given graph. Then we have
+
+$$
+\begin{array}{l} \mathbb {E} \left[ I _ {l} (v _ {a}, v _ {b}; k) \right] = \mathbb {E} \left[ \sum_ {j = 1} ^ {k} \sum_ {\mathcal {U} _ {j} ^ {a \to b}} \prod_ {i = j} ^ {1} \tilde {a} _ {v ^ {(i - 1)}, v ^ {(i)}} \right] = \sum_ {j = 1} ^ {k} \mathbb {E} \left[ \sum_ {\mathcal {U} _ {j} ^ {a \to b}} \prod_ {i = j} ^ {1} \tilde {a} _ {v ^ {(i - 1)}, v ^ {(i)}} \right] \\ = \sum_ {j = 1} ^ {k} \sum_ {\mathcal {P} _ {j} ^ {a \rightarrow b}} \Pr \left(\mathcal {P} _ {j} ^ {a \rightarrow b} \text {i s a n u n l a b e l e d - n o d e s - o n l y p a t h}\right) \prod_ {i = j} ^ {1} \tilde {a} _ {v ^ {(i - 1)}, v ^ {(i)}} \tag {33} \\ = \sum_ {j = 1} ^ {k} \sum_ {\mathcal {P} _ {j} ^ {a \rightarrow b}} \beta^ {j} \prod_ {i = j} ^ {1} \tilde {a} _ {v (i - 1), v (i)} \\ = \sum_ {j = 1} ^ {k} \beta^ {j} \tilde {I} _ {f} (v _ {a}, v _ {b}; j). \\ \end{array}
+$$
+
+# C. Proof of Theorem 3
+
+Proof. Denote the set of labels as  $\mathcal{L}$ . Since different label dimensions in  $y_{a}^{(\cdot)}$  do not interact with each other when running LPA, the value of the  $y_{a}$ -th dimension in  $y_{a}^{(\cdot)}$  (denoted by  $y_{a}^{(\cdot)}[y_{a}]$ ) comes only from the nodes with initial label  $y_{a}$ . It is
+
+clear that
+
+$$
+y _ {a} ^ {(k)} [ y _ {a} ] = \sum_ {v _ {b}: y _ {b} = y _ {a}} \sum_ {j = 1} ^ {k} \sum_ {\mathcal {U} _ {j} ^ {a \rightarrow b}} \prod_ {i = j} ^ {1} \tilde {a} _ {v (i - 1), v ^ {(i)}}, \tag {34}
+$$
+
+which equals  $\sum_{v_b:y_b = y_a}I_l(v_a,v_b;k)$  according to Lemma 2. Therefore, we have
+
+$$
+\Pr \left(\hat {y} _ {a} = y _ {a}\right) = \frac {y _ {a} ^ {(k)} \left[ y _ {a} \right]}{\sum_ {i \in \mathcal {L}} y _ {\hat {a}} ^ {(k)} [ i ]} \propto y _ {a} ^ {(k)} [ y _ {a} ] = \sum_ {v _ {b}: y _ {b} = y _ {a}} I _ {l} \left(v _ {a}, v _ {b}; k\right) \tag {35}
+$$
+
+# D. Proof of Theorem 4
+
+In this proof we assume that the dimension of node representations is one, but note that the conclusion can be easily generalized to the case of multi-dimensional representations since the function  $D(\mathbf{x})$  can be decomposed into the sum of one-dimensional cases. In the following of this proof, we still use bold notations  $\mathbf{x}_i^{(k)}$  and  $\mathbf{h}_i^{(k)}$  to denote node representations, but keep in mind that they are scalars rather than vectors.
+
+We give two lemmas before proving Theorem 4. The first one is about the gradient of  $D(\mathbf{x})$ :
+
+Lemma 3  $\mathbf{h}_i^{(k)} = \mathbf{x}_i^{(k)} - \frac{\partial D(\mathbf{x}^{(k)})}{\partial\mathbf{x}_i^{(k)}}.$
+
+Proof.  $\mathbf{x}_i^{(k)} - \frac{\partial D(\mathbf{x}^{(k)})}{\partial \mathbf{x}_i^{(k)}} = \mathbf{x}_i^{(k)} - \sum_{v_j \in \mathcal{N}(v_i)} \tilde{a}_{ij} (\mathbf{x}_i^{(k)} - \mathbf{x}_j^{(k)}) = \sum_{v_j \in \mathcal{N}(v_i)} \tilde{a}_{ij} \mathbf{x}_j^{(k)} = \mathbf{h}_i^{(k)}.$
+
+It is interesting to see from Lemma 3 that the aggregation step in GCN is equivalent to running gradient descent for one step with a step size of one. However, this is not able to guarantee that  $D(\mathbf{h}^{(k)}) \leq D(\mathbf{x}^{(k)})$  because the step size may be too large to reduce the value of  $D$ .
+
+The second lemma is about the Hessian of  $D(\mathbf{x})$ :
+
+Lemma 4  $\nabla^2 D(\mathbf{x})\preceq 2I$  or equivalently,  $2I - \nabla^{2}D(\mathbf{x})$  is a positive semidefinite matrix.
+
+Proof. We first calculate the Hessian of  $D(\mathbf{x}) = \frac{1}{2}\sum_{v_i,v_j}\tilde{a}_{ij}\| \mathbf{x}_i - \mathbf{x}_j\| _2^2$ :
+
+$$
+\nabla^ {2} D (\mathbf {x}) = \left[ \begin{array}{c c c c} 1 - \tilde {a} _ {1 1} & - \tilde {a} _ {1 2} & \dots & - \tilde {a} _ {1 n} \\ - \tilde {a} _ {2 1} & 1 - \tilde {a} _ {2 2} & \dots & - \tilde {a} _ {2 n} \\ \vdots & \vdots & \ddots & \vdots \\ - \tilde {a} _ {n 1} & - \tilde {a} _ {n 2} & \dots & 1 - \tilde {a} _ {n n} \end{array} \right] = I - D ^ {- 1} A. \tag {36}
+$$
+
+Therefore,  $2I - \nabla^{2}D(\mathbf{x}) = I + D^{-1}A$ . Since  $D^{-1}A$  is Markov matrix (i.e., each entry is non-negative and the sum of each row is one), its eigenvalues are within the range [-1, 1], so the eigenvalues of  $I + D^{-1}A$  are within the range [0, 2]. Therefore,  $I + D^{-1}A$  is a positive semidefinite matrix, and we have  $\nabla^2 D(\mathbf{x}) \preceq 2I$ .
+
+We can now prove Theorem 4:
+
+Proof. Since  $D$  is a quadratic function, we perform a second-order Taylor expansion of  $D$  around  $\mathbf{x}^{(k)}$  and obtain the following inequality:
+
+$$
+\begin{array}{l} D (\mathbf {h} ^ {(k)}) = D (\mathbf {x} ^ {(k)}) + \nabla D (\mathbf {x} ^ {(k)}) ^ {\top} (\mathbf {h} ^ {(k)} - \mathbf {x} ^ {(k)}) + \frac {1}{2} (\mathbf {h} ^ {(k)} - \mathbf {x} ^ {(k)}) ^ {\top} \nabla^ {2} D (\mathbf {x}) (\mathbf {h} ^ {(k)} - \mathbf {x} ^ {(k)}) \\ = D \left(\mathbf {x} ^ {(k)}\right) - \nabla D \left(\mathbf {x} ^ {(k)}\right) ^ {\top} \nabla D \left(\mathbf {x} ^ {(k)}\right) + \frac {1}{2} \nabla D \left(\mathbf {x} ^ {(k)}\right) ^ {\top} \nabla^ {2} D (\mathbf {x}) \nabla D \left(\mathbf {x} ^ {(k)}\right) \tag {37} \\ \leq D (\mathbf {x} ^ {(k)}) - \nabla D (\mathbf {x} ^ {(k)}) ^ {\top} \nabla D (\mathbf {x} ^ {(k)}) + \nabla D (\mathbf {x} ^ {(k)}) ^ {\top} \nabla D (\mathbf {x} ^ {(k)}) = D (\mathbf {x} ^ {(k)}). \\ \end{array}
+$$
+
+![](images/bcc88b22ffc6b05eba16c6b467ac22a9eb4166813f668b0c77021204fa625696.jpg)
+
+# E. More Visualization Results on Karate Club Network
+
+Figure 7 illustrates more visualization of GCN and GCN-LPA on karate club network. In each subfigure, we vary the number of layers from 1 to 4 to examine how the learned representations evolve. The initial node features are one-hot identity vectors, and the dimension of hidden layers and output layer is 2. The transformation matrices are uniformly initialized within range [-1, 1]. We use sigmoid function as the nonlinear activation function. Comparing the four figures in each row, we conclude that the aggregation step and transformation step in GCN and GCN-LPA do benefit the separation of different classes. Comparing Figure 7a and 7c (or Figure 7b and 7d), we conclude that more inter-class edges will make the separation harder for GCN (or GCN-LPA). Comparing Figure 7a and 7b (or Figure 7c and 7d), we conclude that GCN-LPA is more noise-resistant than GCN, therefore, GCN-LPA can better differentiate classes and identify clustering substructures.
+
+# F. Hyper-parameter Settings
+
+The detailed hyper-parameter settings for all datasets are listed in Table 4. In GCN-LPA, we use the same dimension for all hidden layers. Note that the number of GCN layers and the number of LPA iterations can actually be different since GCN and LPA are implemented as two independent modules. We use grid search to determine hyper-parameters on Cora, and perform fine-tuning on other datasets, i.e., varying one hyper-parameter per time to see if the performance can be further improved. The search spaces for hyper-parameters are as follows:
+
+- Dimension of hidden layers:  $\{8, 16, 32\}$ ;  
+- # GCN layers:  $\{1,2,3,4,5,6\}$ ;  
+- # LPA iterations:  $\{1,2,3,4,5,6,7,8,9\}$ ;  
+- L2 weight:  $\{10^{-7}, 2 \times 10^{-7}, 5 \times 10^{-7}, 10^{-6}, 2 \times 10^{-6}, 5 \times 10^{-6}, 10^{-5}, 2 \times 10^{-5}, 5 \times 10^{-5}, 10^{-4}, 2 \times 10^{-4}, 5 \times 10^{-4}, 10^{-3}\}$ ;  
+- LPA weight  $(\lambda)$ :  $\{0,1,2,5,10,15,20\}$ ;  
+- Dropout rate:  $\{0, 0.1, 0.2, 0.3, 0.4, 0.5\}$ ;  
+- Learning rate:  $\{0.01, 0.02, 0.05, 0.1, 0.2, 0.5\}$ ;
+
+<table><tr><td></td><td>Cora</td><td>Citeseer</td><td>Pubmed</td><td>Coauthor-CS</td><td>Coauthor-Phy</td></tr><tr><td>Dimension of hidden layers</td><td>32</td><td>16</td><td>32</td><td>32</td><td>32</td></tr><tr><td># GCN layers</td><td>5</td><td>2</td><td>2</td><td>2</td><td>2</td></tr><tr><td># LPA iterations</td><td>5</td><td>5</td><td>1</td><td>2</td><td>3</td></tr><tr><td>L2 weight</td><td>\( 1 \times 10^{-4} \)</td><td>\( 5 \times 10^{-4} \)</td><td>\( 2 \times 10^{-4} \)</td><td>\( 1 \times 10^{-4} \)</td><td>\( 1 \times 10^{-4} \)</td></tr><tr><td>LPA weight (λ)</td><td>10</td><td>1</td><td>1</td><td>2</td><td>1</td></tr><tr><td>Dropout rate</td><td>0.2</td><td>0</td><td>0</td><td>0.2</td><td>0.2</td></tr><tr><td>Learning rate</td><td>0.05</td><td>0.2</td><td>0.1</td><td>0.1</td><td>0.05</td></tr></table>
+
+Table 4: Hyper-parameter settings for all datasets.
+
+![](images/7fb6f79a11024ca51d68935d07f35246dfff9e10e31aaf1edc2793f406fbe5cd.jpg)  
+1-layer
+
+![](images/9c20660505acbbc3e84ea3730857398373bfe3fea9282d794cb5d59f77e18ac5.jpg)  
+2-layer  
+(a) GCN on the original network
+
+![](images/c48744acc6833df4394e9363a6cf347872922c530bdbaecbc1638d70ccce1d84.jpg)  
+3-layer
+
+![](images/347201d06915846205e2e181f4e94ccdf2e98f7dec617c2d11535ed5dc9d788f.jpg)  
+4-layer
+
+![](images/efc4638bf54a6267238cc97eac26b81212b8988a7bb23eb95c78586baf0d37cf.jpg)  
+1-layer
+
+![](images/607cea6f1de5d3a7c6f3fdb15021d4935e134cac39ce9ea3f6a7df488bdbaed9.jpg)  
+2-layer  
+(b) GCN-LPA on the original network
+
+![](images/7b914b35dd9abb3f3b1d9297f8801e2c50183de7557f54966cd63a1b4e7db4d9.jpg)  
+3-layer
+
+![](images/deb272bb6a570f4088cede9545b6f50183efe743a2896cd275a7dba5ee538bc0.jpg)  
+4-layer
+
+![](images/c35395dad1bce9f5de8f38ad04a5ab814a0ae873cda6586cb0d6687f2ec15011.jpg)  
+1-layer
+
+![](images/a8718e8b921a464534f8066b51c368cd4bfa0b25a488ac14b5ed9d7c5be783dd.jpg)  
+2-layer  
+(c) GCN on the noisy network
+
+![](images/b801f7b7fd70fe0692004aa22a444b30b259e61f0abb7b7e703dc8b83b52f343.jpg)  
+3-layer
+
+![](images/d75aa276aac61efc50877821a0e998001620848f2ae28016a08901a249c13be2.jpg)  
+4-layer
+
+![](images/6c954f3524d2642d81390f12ef2e1ea064b61008f2c1263d425888930b126f08.jpg)  
+1-layer  
+Figure 7: Visualization of GCN and GCN-LPA with  $1\sim 4$  layers on karate club network.
+
+![](images/eea9a7e3a1bc0f6096894c436ff287f94592b38c363869b45ee1dbe3c4fe6d6d.jpg)  
+2-layer  
+(d) GCN-LPA on the noisy network
+
+![](images/536718506cc60cf1bf7db81bd59e23641aafbbb1fccaa7827dfa6711a9288600.jpg)  
+3-layer
+
+![](images/75566d2e08360999634e02ff956ff11584699d2ed48952fdda07e757b4dd49d4.jpg)  
+4-layer

2002.06xxx/2002.06755/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e4135d95f5593627202300d2d5b72e450b2bf5d9a75aaa362a032f3f823ceb9
+size 735083

2002.06xxx/2002.06757/f0a0cfca-5ae2-4300-ba52-9cc444c0761b_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49bc5b694cdea7d4b6eb82909dc75f597266096a86de9691b0d03e7f10bf9c82
+size 760516

2002.06xxx/2002.06757/full.md

@@ -0,0 +1,599 @@
+# Relational Message Passing for Knowledge Graph Completion
+
+Hongwei Wang
+
+Stanford University
+
+Stanford, California, United States
+
+hongweiw@cs.stanford.edu
+
+Hongyu Ren
+
+Stanford University
+
+Stanford, California, United States
+
+hyren@cs.stanford.edu
+
+Jure Leskovec
+
+Stanford University
+
+Stanford, California, United States
+
+jure@cs.stanford.edu
+
+# ABSTRACT
+
+Knowledge graph completion aims to predict missing relations between entities in a knowledge graph. In this work, we propose a relational message passing method for knowledge graph completion. Different from existing embedding-based methods, relational message passing only considers edge features (i.e., relation types) without entity IDs in the knowledge graph, and passes relational messages among edges iteratively to aggregate neighborhood information. Specifically, two kinds of neighborhood topology are modeled for a given entity pair under the relational message passing framework: (1) Relational context, which captures the relation types of edges adjacent to the given entity pair; (2) Relational paths, which characterize the relative position between the given two entities in the knowledge graph. The two message passing modules are combined together for relation prediction. Experimental results on knowledge graph benchmarks as well as our newly proposed dataset show that, our method PATHCon outperforms state-of-the-art knowledge graph completion methods by a large margin. PATHCon is also shown applicable to inductive settings where entities are not seen in training stage, and it is able to provide interpretable explanations for the predicted results. The code and all datasets are available at https://github.com/hwang55/PathCon.
+
+# CCS CONCEPTS
+
+- Computing methodologies  $\rightarrow$  Semantic networks; Statistical relational learning; - Mathematics of computing  $\rightarrow$  Graph algorithms.
+
+# KEYWORDS
+
+Knowledge graph completion; message passing; graph neural networks
+
+# ACM Reference Format:
+
+Hongwei Wang, Hongyu Ren, and Jure Leskovec. 2021. Relational Message Passing for Knowledge Graph Completion. In Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD '21), August 14-18, 2021, Virtual Event, Singapore. ACM, New York, NY, USA, 11 pages. https://doi.org/10.1145/3447548.3467247
+
+# 1 INTRODUCTION
+
+Knowledge graphs (KGs) store structured information of real-world entities and facts. A KG usually consists of a collection of triplets. Each triplet  $(h,r,t)$  indicates that head entity  $h$  is related to tail entity  $t$  through relationship type  $r$ . Nonetheless, KGs are often
+
+![](images/7d8fac2a5ed5670167a91f1d12869c9fd590f2709324cae0beaa1ddccbc8962d.jpg)
+
+(a) Consider we aim to predict whether Ron Weasley or Hedwig is a Pet of Harry Potter. Both entities have the same relational path (Lives with) to Harry Potter but they have distinct relational context: Ron Weasley has {Brother of, Lives with}, while Hedwig has {Bought, Lives with}. Capturing the relational context of entities allows our model to make a distinction between Ron Weasley, who is a person, and Hedwig, which is an owl.
+
+![](images/89bb4417558213d26845f4dd060c60550b0e326b0b895696f3ff95e18e451e14.jpg)  
+Figure 1: (a) Relational context of an entity and (b) relational paths between entities. Our model is able to capture both.
+
+(b) Two head entities Hermione Granger and Draco Malfoy have the same relational context  $\{\text{Occupation}, \text{House}\}$ , but different relational paths to the tail entity Harry Potter  $\{(\text{House}, \text{House}), (\text{Occupation}, \text{Occupation})\}$  vs.  $\{(\text{Occupation}, \text{Occupation})\}$ , which allows our model to predict friendship between Harry Potter and Hermione Granger vs. Draco Malfoy.
+
+incomplete and noisy. To address this issue, researchers have proposed a number of KG completion methods to predict missing links/relations in KGs [3, 9, 12, 13, 19, 22, 24, 35, 36, 39, 40].
+
+In general, relation types are not uniformly distributed over a KG but spatially correlated with each other. For example, the neighboring relations of "graduated from" in the KG are more likely to be "person.birthplace" and "university.location" rather than "movie.language". Therefore, for a given entity pair  $(h,t)$ , characterizing the relation types of neighboring links of  $h$  and  $t$  will provide valuable information when inferring the relation type between  $h$  and  $t$ . Inspired by recent success of graph neural networks [11, 15, 34], we propose using message passing to capture the neighborhood structure for a given entity pair. However, traditional message passing methods usually assume that messages
+
+are associated with nodes and messages are passed from nodes to nodes iteratively, which are not suitable for KGs where edge features (relation types) are more important.
+
+Relational message passing. To address the above limitation, we propose relational message passing for KG completion. Unlike traditional node-based message passing, relational message passing only considers edge features (relation types), and passes messages of an edge directly to its neighboring edges. Note that since relational message passing only models relations rather than entities, it brings three additional benefits compared with existing knowledge graph embedding methods [3, 13, 22, 24, 35, 39]: (1) it is inductive, since it can handle entities that do not appear in the training data during inference stage; (2) it is storage-efficient, since it does not calculate embeddings of entities; and (3) it is explainable, since it is able to provide explainability for predicted results by modeling the correlation strength among relation types. However, a potential issue of relational message passing is that its computational complexity is significantly higher than node-based message passing (Theorem 2). To solve this issue, we propose alternate relational message passing that passes relational messages between nodes and edges alternately over the KG. We prove that alternate message passing scheme greatly improves time efficiency and achieves the same order of computational complexity as traditional node-based message passing (Theorem 1 and 3).
+
+Relational context and relational paths. Under the alternate relational message passing framework, we explore two kinds of local subgraph topology for a given entity pair  $(h,t)$  (see Figure 1 for an illustrating example): (1) Relational context. It is important to capture the neighboring relations of a given entity in the KG, because neighboring relations provide us with valuable information about what is the nature or the "type" of the given entity (Figure 1a). Many entities in KGs are not typed or are very loosely typed, so being able to learn about the entity and its context in the KG is valuable. We design a multi-layer relational message passing scheme to aggregate information from multi-hop neighboring edges of  $(h,t)$ . (2) Relational paths. Note that modeling only relational context is not able to identify the relative position of  $(h,t)$ . It is also important to capture the set of relational paths between  $(h,t)$  (Figure 1b). Here different paths of connections between the entities reveal the nature of their relationship and help with the prediction. Therefore, we calculate all relational paths connecting  $h$  and  $t$  in the KG and pass relational messages along these paths. Finally, we use an attention mechanism to selectively aggregate representations of different relational paths, then combine the above two modules together for relation prediction.
+
+Experiments. We conduct extensive experiments on five well-known KGs as well as a new KG proposed by us, DDB14 dataset. Experimental results demonstrate that our proposed model PATHCON (short for relational PATHs and CONtext) significantly outperforms state-of-the-art KG completion methods, for example, the absolute Hit@1 gain over the best baseline is  $16.7\%$  and  $6.3\%$  on WN18RR and NELL995, respectively. Our ablation studies show the effectiveness of our approach and demonstrate the importance of relational context as well as relational paths. Our method is also shown to maintain strong performance in inductive KG completion, and it
+
+![](images/f1c9bceef7471d5522f31daee0f8f432caf3fe6f452ada205b0e53b9a6e099bb.jpg)  
+Figure 2: An example of PATHCon considering both the relational context within 2 hops of the head and the tail entities (denoted by red edges) and relational paths of length up to 3 relations that connect head to tail (denoted by green arrows). Context and paths are captured based on relation types (not entities) they contain. By combining the context and paths PATHCon predicts the probability of relation  $r$ .
+
+provides high explainability by identifying important relational context and relation paths for a given predicted relation.
+
+Contributions. Our key contributions are listed as follows:
+
+- We propose alternate relational message passing framework for KG completion, which is inductive, storage-efficient, explainable, and computationally efficient compared with existing embedding-based methods;  
+- Under the proposed framework, we explore two kinds of subgraph topology: relational context and relational paths, and show that they are critical to relation prediction;  
+- We propose a new KG dataset DDB14 (Disease Database with 14 relation types) that is suitable for KG-related research.
+
+# 2 PROBLEM FORMULATION
+
+Let  $\mathcal{G} = (\mathcal{V},\mathcal{E})$  be an instance of a knowledge graph, where  $\mathcal{V}$  is the set of nodes and  $\mathcal{E}$  is the set of edges. Each edge  $e$  has a relation type  $r\in \mathcal{R}$ . Our goal is to predict missing relations in  $\mathcal{G}$ , i.e., given an entity pair  $(h,t)$ , we aim to predict the relation of the edge between them. Specifically, we aim to model the distribution over relation types given a pair of entities  $(h,t)$ :  $p(r|h,t)$ . This is equivalent to modeling the following term
+
+$$
+p (r | h, t) \propto p (h, t | r) \cdot p (r) \tag {1}
+$$
+
+according to Bayes' theorem. In Eq. (1),  $p(r)$  is the prior distribution over relation types and serves as the regularization of the model. Then the first term can be further decomposed to
+
+$$
+p (h, t | r) = \frac {1}{2} \left(p (h | r) \cdot p (t | h, r) + p (t | r) \cdot p (h | t, r)\right). \tag {2}
+$$
+
+Eq. (2) sets up the guideline for designing our model. The term  $p(h|r)$  or  $p(t|r)$  measures the likelihood of an entity given a particular relation. Since our model does not consider the identity of entities, we use an entity's local relational subgraph instead to represent the entity itself, i.e.,  $p\big(C(h)|r\big)$  and  $p\big(C(t)|r\big)$  where  $C(\cdot)$
+
+<table><tr><td>Symbol</td><td>Description</td></tr><tr><td>h, t</td><td>Head entity and tail entity</td></tr><tr><td>r</td><td>Relation type</td></tr><tr><td>sei</td><td>Hidden state of edge e at iteration i</td></tr><tr><td>mi</td><td>Message of node v at iteration i</td></tr><tr><td>N(e)</td><td>Endpoint nodes of edge e</td></tr><tr><td>N(v)</td><td>Neighbor edges of node v</td></tr><tr><td>s(h,t)</td><td>Context representation of the entity pair (h,t)</td></tr><tr><td>sh→t</td><td>Path representation of all paths from h to t</td></tr><tr><td>αP</td><td>Attention weight of path P</td></tr><tr><td>Ph→t</td><td>Set of paths from h to t</td></tr></table>
+
+Table 1: Notation used in this paper.
+
+denotes the local relational subgraph of an entity. This is also known as relational context for  $h$  and  $t$ . The term  $p(t|h,r)$  or  $p(h|t,r)$  in Eq. (2) measures the likelihood of how  $t$  can be reached from  $h$  or the other way around given that there is a relation  $r$  between them. This inspires us to model the relational paths between  $h$  and  $t$  in the KG. In the following we show how to model the two factors in our method and how they contribute to relation prediction.
+
+# 3 OUR APPROACH
+
+In this section, we first introduce the relational message passing framework, then present two modules of the proposed PATHCON: relational context message passing and relational path message passing. Notations used in this paper are listed in Table 1.
+
+# 3.1 Relational Message Passing Framework
+
+Traditional node-based message passing. We first briefly review traditional node-based message passing method for general graphs. Assume that each node  $v$  is with feature  $x_{v}$ . Then the message passing runs for multiple timesteps over the graph, during which the hidden state  $s_{v}^{i}$  of each node  $v$  in iteration  $i$  is updated by
+
+$$
+m _ {v} ^ {i} = A \left(\left\{s _ {u} ^ {i} \right\} _ {u \in N (v)}\right), \tag {3}
+$$
+
+$$
+s _ {v} ^ {i + 1} = U \left(s _ {v} ^ {i}, m _ {v} ^ {i}\right), \tag {4}
+$$
+
+where  $m_v^i$  is the message received by node  $v$  in iteration  $i$ ,  $\mathcal{N}(v)$  denotes the set of neighbor nodes of  $v$  in the graph,  $A(\cdot)$  is message aggregation function, and  $U(\cdot)$  is node update function. The initial hidden state  $s_v^0 = x_v$ .
+
+The above framework, though popular for general graphs and has derived many variants such as GCN [15], GraphSAGE [11], and GIN [34], faces the following challenges when applied to knowledge graphs: (1) Unlike general graphs, in most KGs, edges have features (relation types) but nodes don't, which makes node-based message passing less natural for KGs. Though node features can be set as their identities (i.e., one-hot vectors), this will lead to another two issues: (2) Modeling identity of nodes cannot manage previously unseen nodes during inference and fails in inductive settings. (3) In real-world KGs, the number of entities are typically much larger than the number of relation types, which requires large memory for storing entity embeddings.
+
+Relational message passing. To address the above problems, a natural thought is to perform message passing over edges instead
+
+of nodes:
+
+$$
+m _ {e} ^ {i} = A \left(\left\{s _ {e ^ {\prime}} ^ {i} \right\} _ {e ^ {\prime} \in \mathcal {N} (e)}\right), \tag {5}
+$$
+
+$$
+s _ {e} ^ {i + 1} = U \left(s _ {e} ^ {i}, m _ {e} ^ {i}\right), \tag {6}
+$$
+
+where  $\mathcal{N}(e)$  denotes the set of neighbor edges of  $e$  (i.e., edges that share at least one common end-point with  $e$ ) in the graph, and  $s_e^0 = x_e$  is the initial edge feature of  $e$ , i.e., the relation type. Therefore, Eqs. (5) and (6) are called relational message passing.
+
+Relational message passing avoids the drawbacks of node-based message passing, however, it brings a new issue of computational efficiency when passing messages. To see this, we analyze the computational complexity of the two message passing schemes (proofs are given in Appendix A and B):
+
+THEOREM 1 (COMPLEXITY OF NODE-BASEDMESSAGE PASSING). Consider a graph with  $N$  nodes and  $M$  edges. The expected cost of node-based message passing (Eqs. (3) and (4)) in each iteration is  $2M + 2N$ .
+
+THEOREM 2 (COMPLEXITY OF RELATIONALMESSAGE PASSING). Consider a graph with  $N$  nodes and  $M$  edges. The expected cost of relational message passing (Eqs. (5) and (6)) in each iteration is  $N\cdot \operatorname {Var}[d] + \frac{4M^2}{N}$ , where  $\operatorname {Var}[d]$  is the variance of node degrees in the graph.
+
+Alternate relational message passing. According to the above theorems, the complexity of relational message passing is much higher than node-based message passing, especially in real-world graphs where node distribution follows the power law distribution whose variance  $(\mathrm{Var}[d])$  is extremely large due to the long tail. To reduce the redundant computation in relational message passing and improve its computational efficiency, we propose the following message passing scheme for KGs:
+
+$$
+m _ {v} ^ {i} = A _ {1} \left(\left\{s _ {e} ^ {i} \right\} _ {e \in \mathcal {N} (v)}\right), \tag {7}
+$$
+
+$$
+m _ {e} ^ {i} = A _ {2} \left(m _ {v} ^ {i}, m _ {u} ^ {i}\right), v, u \in \mathcal {N} (e), \tag {8}
+$$
+
+$$
+s _ {e} ^ {i + 1} = U \left(s _ {e} ^ {i}, m _ {e} ^ {i}\right). \tag {9}
+$$
+
+We decompose edge aggregation in Eq. (5) into two steps as Eqs. (7) and (8). In Eq. (7), for each node  $v$ , we aggregate all the edges that  $v$  connects to by an aggregation function  $A_{1}(\cdot)$  and get message  $m_v^i$ , where  $\mathcal{N}(v)$  denotes the set of neighbor edges for node  $v$ . Then in Eq. (8), we obtain message  $m_e^i$  of edge  $e$  by aggregating messages from its two end-points  $v$  and  $u$  using function  $A_{2}(\cdot)$ , where  $\mathcal{N}(e)$  denotes the set of neighbor nodes for edge  $e$ . The hidden state of edge  $e$  is finally updated using the message  $m_e^i$  as in Eq. (9).
+
+An intuitive understanding of alternate relational message passing is that nodes here serve as "distribution centers" that collect and temporarily store the messages from their neighbor edges, then propagate the aggregated messages back to each of their neighbor edges. Therefore, we call Eqs. (7)-(9) alternate relational message passing, as messages are passed alternately between nodes and edges.
+
+The complexity of alternate relational message passing is given as follows (proof is given in Appendix C):
+
+THEOREM 3 (COMPLEXITY OF ALTERNATE RELATIONALMESSAGE PASSING). Consider a graph with  $N$  nodes and  $M$  edges. The expected cost of alternate relational message passing (Eqs. (7)-(9)) in each iteration is  $6M$ .
+
+From Theorem 3 it is clear to see that alternate relational message passing greatly reduces the time overhead and achieves the same order of complexity as node-based message passing.
+
+Remarks. We present the following two remarks to provide more insight on the proposed framework:
+
+REMARK 1 (RELATIONSHIP WITH BELIEF PROPAGATION). Alternate relational message passing is conceptually related to belief propagation (BP) [37], which is also a message-passing algorithm that passes messages between nodes and edges. But note that they are significantly different in: (1) application fields. BP is used to calculate the marginal distribution of unobserved variables in a graphical model, while our method aims to predict the edge type in KGs; (2) the purpose of using edge-node alternate message passing. BP uses this because of the special structure of factor graphs, while we use this to reduce the computational overhead.
+
+REMARK 2 (UTILIZING NODE FEATURES). Though our proposed framework is claimed to only use edge features, it can be easily extended to the case where node features are present and assumed to be important, by additionally including the feature vector of node  $v$  in Eq. (7), i.e.,  $m_v^i = A_1\left(\{s_e^i\}_{e\in \mathcal{N}(v)},x_v\right)$ , where  $x_{v}$  is the feature of node  $v$ . As long as node features do not contain node identities, our proposed framework is still inductive. We do not empirically study the performance of our method on node-feature-aware cases, because node features are unavailable for all datasets used in this paper. We leave the exploration of this extension to future work.
+
+# 3.2 Relational Context
+
+For a KG triplet  $(h,r,t)$ , relational context of  $h$  and  $t$  is usually highly correlated with  $r$ . For example, if  $r$  is "graduated from", it's reasonable to guess that the surrounding relations of  $h$  are "person.birthplace", "person_gender", etc., and the surrounding relations of  $t$  are "institution.location", "university.founder", "university.president", etc. Therefore, the context of  $h$  and  $t$  will provide valuable clues when identifying the relation type of the edge between them, and here we use the proposed message passing method to learn from relational context.
+
+Denote  $s_e^i$  as the hidden state of edge  $e$  in iteration  $i$ , and  $m_v^i$  as the message stored at node  $v$  in iteration  $i$ . We instantiate the alternate relational message passing in Eqs. (7)-(9) to learn the representation of each edge:
+
+$$
+m _ {v} ^ {i} = \sum_ {e \in \mathcal {N} (v)} s _ {e} ^ {i}, \tag {10}
+$$
+
+$$
+s _ {e} ^ {i + 1} = \sigma \left(\left[ m _ {v} ^ {i}, m _ {u} ^ {i}, s _ {e} ^ {i} \right] \cdot W ^ {i} + b ^ {i}\right), v, u \in \mathcal {N} (e), \tag {11}
+$$
+
+where  $[\cdot ]$  is the concatenation function,  $W^{i},b^{i}$  , and  $\sigma (\cdot)$  are the learnable transformation matrix, bias, and nonlinear activation function, respectively.  $s_e^0 = x_e$  is initial feature of edge  $e$  , which
+
+can be taken as the one-hot identity vector of the relation type that  $e$  belongs to.
+
+Relational context message passing in Eqs. (10) and (11) are repeated for  $K$  times. The final message  $m_h^{K-1}$  and  $m_t^{K-1}$  are taken as the representation for head  $h$  and tail  $t$ , respectively. We also give an illustrative example of relational context message passing in Figure 2, where the red/pink edges denote the first-order/second-order contextual relations.
+
+# 3.3 Relational Paths
+
+We follow the discussion in Section 2 and discuss how to model the term  $p(t|h,r)$  or  $p(h|t,r)$ . Note that we do not consider node/edge identity in relational context message passing, which leads to a potential issue that our model is not able to identify the relative position between  $h$  and  $t$  in the KG. For example, suppose for a given entity pair  $(h,t)$ ,  $h$  is surrounded by "person.birthplace", "person.gender", etc., and  $t$  is surrounded by "institution.location", "university.founder", "university.president", etc. Then it can be inferred that  $h$  is probably a person and  $t$  is probably a university, and there should be a relation "graduated_from" between them because such a pattern appears frequently in the training data. However, the person may have no relationship with the university and they are far from each other in the KG. The reason why such false positive case happens is that relational context message passing can only detect the "type" of  $h$  and  $t$ , but is not aware of their relative position in the KG.
+
+To solve this problem, we propose to explore the connectivity pattern between  $h$  and  $t$ , which are represented by the paths connecting them in the KG. Specifically, a raw path from  $h$  to  $t$  in a KG is a sequence of entities and edges:  $h(v_0) \xrightarrow{e_0} v_1 \xrightarrow{e_1} v_2 \cdots v_{L-1} \xrightarrow{e_{L-1}} t(v_L)$ , in which two entities  $v_i$  and  $v_{i+1}$  are connected by edge  $e_i$ , and each entity in the path is unique. The corresponding relational path  $P$  is the sequence of relation types of all edges in the given raw path, i.e.,  $P = (r_{e_0}, r_{e_1}, \dots, r_{e_{L-1}})$ , where  $r_{e_i}$  is the relation type of edge  $e_i$ . Note that we do not use the identity of nodes when modeling relational paths, which is the same as for relational context.
+
+Denote  $\mathcal{P}_{h\to t}$  as the set of all relational paths from  $h$  to  $t$  in the KG. Our next step is to define and calculate the representation of relational paths. In PATHCON, we assign an independent embedding vector  $s_P$  for each relational path  $P\in \mathcal{P}_{h\rightarrow t}$ . A potential concern here is that the number of different paths increases exponentially with the path length (there are  $|r|^k$ $k$ -hop paths), however, in practice we observe that in real-world KGs most paths actually do not occur (e.g., only  $3.2\%$  of all possible paths of length 2 occur in FB15K dataset), and the number of different paths is actually quite manageable for relatively small values of  $k$  ( $k\leq 4$ ).
+
+An illustrative example of relational paths is shown in Figure 2, where the two green arrows denote the relational paths from head entity  $h$  to tail entity  $t$ .
+
+# 3.4 Combining Relational Context and Paths
+
+For relational context, we use massage passing scheme to calculate the final message  $m_h^{K-1}$  and  $m_t^{K-1}$  for  $h$  and  $t$ , which summarizes their context information, respectively.  $m_h^{K-1}$  and  $m_t^{K-1}$  are further combined together for calculating the context of  $(h, t)$  pair:
+
+$$
+s _ {(h, t)} = \sigma \left(\left[ m _ {h} ^ {K - 1}, m _ {t} ^ {K - 1} \right] \cdot W ^ {K - 1} + b ^ {K - 1}\right), \tag {12}
+$$
+
+where  $s_{(h,t)}$  denotes the context representation of the entity pair  $(h,t)$ . Note here that Eq. (12) should only take messages of  $h$  and  $t$  as input without their connecting edge  $r$ , since the ground truth relation  $r$  should be treated unobserved in the training stage.
+
+For relational paths, note that there may be a number of relational paths for a given  $(h,t)$  pair, but not all paths are logically related to the predicted relation  $r$ , and the importance of each path also varies. In PATHCON, since we have already known the context  $s_{(h,t)}$  for  $(h,t)$  pair and it can be seen as prior information for paths between  $h$  and  $t$ , we can calculate the importance scores of paths based on  $s_{(h,t)}$ . Therefore, we first calculate the attention weight of each path  $P$  with respect to the context  $s_{(h,t)}$ :
+
+$$
+\alpha_ {P} = \frac {\exp \left(s _ {P} ^ {\top} s _ {(h , t)}\right)}{\sum_ {P \in \mathcal {P} _ {h \rightarrow t}} \exp \left(s _ {P} ^ {\top} s _ {(h , t)}\right)}, \tag {13}
+$$
+
+where  $\mathcal{P}_{h\to t}$  is the set of all paths from  $t$  to  $t$ . Then the attention weights are used to average representations of all paths:
+
+$$
+s _ {h \rightarrow t} = \sum_ {P \in \mathcal {P} _ {h \rightarrow t}} \alpha_ {P} s _ {P}, \tag {14}
+$$
+
+where  $s_{h\to t}$  is the aggregated representation of relational paths for  $(h,t)$ . In this way, the context information  $s_{(h,t)}$  is used to assist in identifying the most important relational paths.
+
+Given the relational context representation  $s_{(h,t)}$  and the relational path representation  $s_{h\rightarrow t}$ , we can predict relations by first adding the two representation together and then taking softmax as follows:
+
+$$
+p (r \mid h, t) = \operatorname {S o F T M A X} \left(s _ {(h, t)} + s _ {h \rightarrow t}\right). \tag {15}
+$$
+
+Our model can be trained by minimizing the loss between predictions and ground truths over the training triplets:
+
+$$
+\min  \mathcal {L} = \sum_ {(h, r, t) \in \mathcal {D}} J (p (r | h, t), r), \tag {16}
+$$
+
+where  $\mathcal{D}$  is the training set and  $J(\cdot)$  is the cross-entropy loss.
+
+It is worth noticing that the context representation  $s_{(h,t)}$  plays two roles in the model: It directly contributes to the predicted relation distribution, and it also helps determine the importance of relational paths with respect to the predicted relation.
+
+# 3.5 Discussion on Model Explainability
+
+Since PATHCon only models relations without entities, it is able to capture pure relationship among different relation types thus can naturally be used to explain for predictions. The explainability of PATHCon is two-fold:
+
+On the one hand, modeling relational context captures the correlation between contextual relations and the predicted relation, which can be used to indicate important neighbor edges for the given relation. For example, "institution.location", "university.founder",
+
+and "university.president" can be identified as important contextual relations for "graduated from".
+
+On the other hand, modeling relational paths captures the correlation between paths and the predicted relation, which can indicate important relational paths for the given relation. For example, ("schoolmate of", "graduated from") can be identified as an important relational path for "graduated from".
+
+It is interesting to see that the explainability provided by relational paths is also connected to first-logic logical rules with the following form:
+
+$$
+B _ {1} (h, x _ {1}) \wedge B _ {2} (x _ {1}, x _ {2}) \wedge \dots \wedge B _ {L} (x _ {L - 1}, t) \Rightarrow r (h, t),
+$$
+
+where  $\bigwedge B_{i}$  is the conjunction of relations in a path and  $r(h,t)$  is the predicted relation. The above example of relational path can therefore be written as the following rule:
+
+$$
+\begin{array}{l} (h, \text {s c h o o l m a t e} f, x) \wedge (x, \text {g r a d u a t e d} f, t) \\ \Rightarrow (h, \text {g r a d u a t e d f r o m}, t). \\ \end{array}
+$$
+
+Therefore, PATHCON can also be used to learn logical rules from KGs just as prior work [9, 12, 19, 36, 40].
+
+# 3.6 Design Alternatives
+
+Next we discuss several design alternatives for PATHCon. In our ablation experiments we will compare PATHCon with the following alternative implementations.
+
+When modeling relational context, we propose two alternatives for context aggregator, instead of the Concatenation context aggregator in Eqs. (11) and (12):
+
+Mean context aggregator. It takes the element-wise mean of the input vectors, followed by a nonlinear transformation function:
+
+$$
+s _ {e} ^ {i + 1} = \sigma \left(\frac {1}{3} \left(m _ {v} ^ {i} + m _ {u} ^ {i} + s _ {e} ^ {i}\right) W + b\right), v, u \in \mathcal {N} (e), \tag {17}
+$$
+
+The output of Mean context aggregator is invariant to the permutation of its two input nodes, indicating that it treats the head and the tail equally in a triplet.
+
+Cross context aggregator. It is inspired by combinatorial features in recommender systems [31], which measure the interaction of unit features (e.g., AND(gender=female, language=English)). Note that Mean and Concatenation context aggregator simply transform messages from two input nodes separately and add them up together, without modeling the interaction between them that might be useful for link prediction. In Cross context aggregator, we first calculate all element-level pairwise interactions between messages from the head and the tail:
+
+$$
+m _ {v} ^ {i} m _ {u} ^ {i} ^ {\top} = \left[ \begin{array}{c c c} m _ {v} ^ {i} ^ {(1)} m _ {u} ^ {i} ^ {(1)} & \dots & m _ {v} ^ {i} ^ {(1)} m _ {u} ^ {i} ^ {(d)} \\ \dots & & \dots \\ m _ {v} ^ {i} ^ {(d)} m _ {u} ^ {i} ^ {(1)} & \dots & m _ {v} ^ {i} ^ {(d)} m _ {u} ^ {i} ^ {(d)} \end{array} \right], \tag {18}
+$$
+
+where we use superscript with parentheses to indicate the element index and  $d$  is the dimension of  $m_v^i$  and  $m_u^i$ . Then we summarize all interactions together via flattening the interaction matrix to a vector then multiplied by a transformation matrix:
+
+$$
+s _ {e} ^ {i + 1} = \sigma \left(\text {f l a t t e n} \left(m _ {v} ^ {i} m _ {u} ^ {i} ^ {\top}\right) W _ {1} ^ {i} + s _ {e} ^ {i} W _ {2} ^ {i} + b ^ {i}\right), v, u \in \mathcal {N} (e). \tag {19}
+$$
+
+It is worth noting that Cross context aggregator preserves the order of input nodes.
+
+Learning path representation with RNN. When modeling relational paths, recurrent neural network (RNN) can be used to learn the representation of relational path  $P = (r_1, r_2, \ldots)$ :
+
+$$
+s _ {P} = \operatorname {R N N} \left(r _ {1}, r _ {2}, \dots\right), \tag {20}
+$$
+
+instead of directly assigning an embedding vector to  $P$ . The advantage of RNN against path embedding is that its number of parameters is fixed and does not depend on the number of relational paths. Another potential benefit is that RNN can hopefully capture the similarity among different relational paths.
+
+Mean path aggregator. When calculating the final representation of relational paths for  $(h, t)$  pair, we can also simply average all the representations of paths from  $h$  to  $t$  instead of the Attention path aggregator in Eqs. (13) and (14):
+
+$$
+s _ {h \rightarrow t} = \sum_ {P \in \mathcal {P} _ {h \rightarrow t}} s p. \tag {21}
+$$
+
+Mean path aggregator can be used in the case where representation of relational context is unavailable, since it does not require attention weights as input.
+
+# 4 EXPERIMENTS
+
+In this section, we evaluate the proposed PATHCon model, and present its performance on six KG datasets.
+
+# 4.1 Experimental Setup
+
+Datasets. We conduct experiments on five standard KG benchmarks: FB15K, FB15K-237, WN18, WN18RR, NELL995, and one KG dataset proposed by us: DDB14.
+
+FB15K [4] is from Freebase [2], a large-scale KG of general human knowledge. FB15k-237 [23] is a subset of FB15K where inverse relations are removed. WN18 [4] contains conceptual-semantic and lexical relations among English words from WordNet [18]. WN18RR [6] is a subset of WN18 where inverse relations are removed. NELL995 [33] is extracted from the 995th iteration of the NELL system [5] containing general knowledge.
+
+In addition, we present a new dataset DDB14 that is suitable for KG-related tasks. DDB14 is collected from Disease Database<sup>6</sup>, which is a medical database containing terminologies and concepts such as diseases, symptoms, drugs, as well as their relationships. We randomly sample two subsets of 4,000 triplets from the original one as validation set and test set, respectively.
+
+The statistics of the six datasets are summarized in Table 2. We also calculate and present the mean and variance of node degree distribution (i.e.,  $\mathbb{E}[d]$  and  $\mathrm{Var}[d]$ ) for each KG. It is clear that  $\mathrm{Var}[d]$  is large for all KGs, which empirically demonstrates that the complexity of relational message passing is fairly high, thus alternate relational message passing is necessary for real graphs.
+
+Baselines. We compare PATHCON with several state-of-the-art models, including TransE [3], ComplEx [24], DistMult [35], RotatE [22], Simple [13], QuatE [39], and DRUM [19]. The first six
+
+<table><tr><td></td><td>FB15K</td><td>FB15K-237</td><td>WN18</td><td>WN18RR</td><td>NELL995</td><td>DDB14</td></tr><tr><td>#nodes</td><td>14,951</td><td>14,541</td><td>40,943</td><td>40,943</td><td>63,917</td><td>9,203</td></tr><tr><td>#relations</td><td>1,345</td><td>237</td><td>18</td><td>11</td><td>198</td><td>14</td></tr><tr><td>#training</td><td>483,142</td><td>272,115</td><td>141,442</td><td>86,835</td><td>137,465</td><td>36,561</td></tr><tr><td>#validation</td><td>50,000</td><td>17,535</td><td>5,000</td><td>3,034</td><td>5,000</td><td>4,000</td></tr><tr><td>#test</td><td>59,071</td><td>20,466</td><td>5,000</td><td>3,134</td><td>5,000</td><td>4,000</td></tr><tr><td>E[d]</td><td>64.6</td><td>37.4</td><td>6.9</td><td>4.2</td><td>4.3</td><td>7.9</td></tr><tr><td>Var[d]</td><td>32,441.8</td><td>12,336.0</td><td>236.4</td><td>64.3</td><td>750.6</td><td>978.8</td></tr></table>
+
+models are embedding-based methods, while DRUM only uses relational paths to make prediction. The implementation details of baselines (as well as our method) is provided in Appendix D.
+
+We also conduct extensive ablation study and propose two reduced versions of our model, CON and PATH, which only use relational context and relational paths, respectively, to test the performance of the two components separately.
+
+The number of parameters of each model on DDB14 are shown in Table 3. The result demonstrates that PATHCON is much more storage-efficient than embedding-based methods, since it does not need to calculate and store entity embeddings.
+
+Table 2: Statistics of all datasets.  $\mathbb{E}[d]$  and  $\operatorname {Var}[d]$  are mean and variance of the node degree distribution, respectively.  
+
+<table><tr><td>Method</td><td>TransE</td><td>ComplEx</td><td>DisMult</td><td>RotatE</td><td>SimpleE</td><td>QuatE</td><td>PATHCon</td></tr><tr><td>#param.</td><td>3.7M</td><td>7.4M</td><td>3.7M</td><td>7.4M</td><td>7.4M</td><td>14.7M</td><td>0.06M</td></tr></table>
+
+Table 3: Number of parameters of all models on DDB14.
+
+Evaluation Protocol. We evaluate all methods on relation prediction, i.e., for a given entity pair  $(h,t)$  in the test set, we rank the ground-truth relation type  $r$  against all other candidate relation types. It is worth noticing that most baselines are originally designed for head/tail prediction, therefore, their negative sampling strategy is to corrupt the head or the tail for a true triple  $(h,r,t)$ , i.e., replacing  $h$  or  $t$  with a randomly sampled entity  $h'$  or  $t'$  from KGs, and using  $(h',r,t)$  or  $(h,r,t')$  as the negative sample. In relation prediction, since the task is to predict the missing relation for a given pair  $(h,t)$ , we modify the negative sampling strategy accordingly by corrupting the relation  $r$  of each true triplet  $(h,r,t)$ , and use  $(h,r',t)$  as the negative sample where  $r'$  is randomly sampled from the set of relation types. This new negative sampling strategy can indeed improve the performance of baselines in relation prediction.
+
+We use MRR (mean reciprocal rank) and Hit@1, 3 (hit ratio with cut-off values of 1 and 3) as evaluation metrics.
+
+# 4.2 Main Results
+
+Comparison with baselines. The results of relation prediction on all datasets are reported in Table 4. In general, our method outperforms all baselines on all datasets. Specifically, the absolute Hit@1 gain of PATHCon against the best baseline in relation prediction task are  $0.2\%$ ,  $0.6\%$ ,  $0.9\%$ ,  $16.7\%$ ,  $6.3\%$ , and  $1.8\%$  in the six datasets, respectively. The improvement is rather significant for WN18RR and NELL995, which are exactly the two most sparse KGs according to the average node degree shown in Table 2. This empirically demonstrates that PATHCon maintains great performance for sparse KGs, and this is probably because PATHCon has much fewer parameters
+
+<table><tr><td rowspan="2"></td><td colspan="3">FB15K</td><td colspan="3">FB15K-237</td><td colspan="3">WN18</td><td colspan="3">WN18RR</td><td colspan="3">NELL995</td><td colspan="3">DDB14</td></tr><tr><td>MRR</td><td>Hit@1</td><td>Hit@3</td><td>MRR</td><td>Hit@1</td><td>Hit@3</td><td>MRR</td><td>Hit@1</td><td>Hit@3</td><td>MRR</td><td>Hit@1</td><td>Hit@3</td><td>MRR</td><td>Hit@1</td><td>Hit@3</td><td>MRR</td><td>Hit@1</td><td>Hit@3</td></tr><tr><td>TransE</td><td>0.962</td><td>0.940</td><td>0.982</td><td>0.966</td><td>0.946</td><td>0.984</td><td>0.971</td><td>0.955</td><td>0.984</td><td>0.784</td><td>0.669</td><td>0.870</td><td>0.841</td><td>0.781</td><td>0.889</td><td>0.966</td><td>0.948</td><td>0.980</td></tr><tr><td>ComplEx</td><td>0.901</td><td>0.844</td><td>0.952</td><td>0.924</td><td>0.879</td><td>0.970</td><td>0.985</td><td>0.979</td><td>0.991</td><td>0.840</td><td>0.777</td><td>0.880</td><td>0.703</td><td>0.625</td><td>0.765</td><td>0.953</td><td>0.931</td><td>0.968</td></tr><tr><td>DistMult</td><td>0.661</td><td>0.439</td><td>0.868</td><td>0.875</td><td>0.806</td><td>0.936</td><td>0.786</td><td>0.584</td><td>0.987</td><td>0.847</td><td>0.787</td><td>0.891</td><td>0.634</td><td>0.524</td><td>0.720</td><td>0.927</td><td>0.886</td><td>0.961</td></tr><tr><td>RotatE</td><td>0.979</td><td>0.967</td><td>0.986</td><td>0.970</td><td>0.951</td><td>0.980</td><td>0.984</td><td>0.979</td><td>0.986</td><td>0.799</td><td>0.735</td><td>0.823</td><td>0.729</td><td>0.691</td><td>0.756</td><td>0.953</td><td>0.934</td><td>0.964</td></tr><tr><td>Simple</td><td>0.983</td><td>0.972</td><td>0.991</td><td>0.971</td><td>0.955</td><td>0.987</td><td>0.972</td><td>0.964</td><td>0.976</td><td>0.730</td><td>0.659</td><td>0.755</td><td>0.716</td><td>0.671</td><td>0.748</td><td>0.924</td><td>0.892</td><td>0.948</td></tr><tr><td>QuatE</td><td>0.983</td><td>0.972</td><td>0.991</td><td>0.974</td><td>0.958</td><td>0.988</td><td>0.981</td><td>0.975</td><td>0.983</td><td>0.823</td><td>0.767</td><td>0.852</td><td>0.752</td><td>0.706</td><td>0.783</td><td>0.946</td><td>0.922</td><td>0.962</td></tr><tr><td>DRUM</td><td>0.945</td><td>0.945</td><td>0.978</td><td>0.959</td><td>0.905</td><td>0.958</td><td>0.969</td><td>0.956</td><td>0.980</td><td>0.854</td><td>0.778</td><td>0.912</td><td>0.715</td><td>0.640</td><td>0.740</td><td>0.958</td><td>0.930</td><td>0.987</td></tr><tr><td>CON</td><td>0.962± 0.000</td><td>0.934± 0.000</td><td>0.988± 0.000</td><td>0.978± 0.000</td><td>0.961± 0.001</td><td>0.995± 0.000</td><td>0.960± 0.002</td><td>0.927± 0.005</td><td>0.992± 0.001</td><td>0.943± 0.002</td><td>0.894± 0.004</td><td>0.993± 0.003</td><td>0.875± 0.003</td><td>0.815± 0.004</td><td>0.928± 0.003</td><td>0.977± 0.000</td><td>0.961± 0.001</td><td>0.994± 0.001</td></tr><tr><td>PATH</td><td>0.937± 0.001</td><td>0.918± 0.001</td><td>0.951± 0.001</td><td>0.972± 0.001</td><td>0.957± 0.001</td><td>0.986± 0.001</td><td>0.981± 0.000</td><td>0.971± 0.005</td><td>0.989± 0.001</td><td>0.933± 0.000</td><td>0.897± 0.001</td><td>0.961± 0.001</td><td>0.737± 0.001</td><td>0.685± 0.002</td><td>0.764± 0.002</td><td>0.969± 0.000</td><td>0.948± 0.001</td><td>0.991± 0.000</td></tr><tr><td>PATHCON</td><td>0.984± 0.001</td><td>0.974± 0.002</td><td>0.995± 0.001</td><td>0.979± 0.000</td><td>0.964± 0.001</td><td>0.994± 0.001</td><td>0.993± 0.001</td><td>0.988± 0.001</td><td>0.998± 0.000</td><td>0.974± 0.001</td><td>0.954± 0.002</td><td>0.994± 0.000</td><td>0.896± 0.001</td><td>0.844± 0.004</td><td>0.941± 0.001</td><td>0.980± 0.000</td><td>0.966± 0.001</td><td>0.995± 0.000</td></tr></table>
+
+Table 4: Results of relation prediction on all datasets. Best results are highlighted in bold, and best results of baselines are highlighted with underlines.
+
+than baselines and is less prone to overfitting. In contrast, performance gain of PATHCON on FB15K is less significant, which may be because the density of FB15K is very high so that it is much easier for baselines to handle.
+
+In addition, the results also demonstrate the stability of PATHCON as we observe that most of the standard deviations are quite small.
+
+Results in Tables 4 also show that, in many cases CON or PATH can already beat most baselines. Combining relational context and relational paths together usually leads to even better performance.
+
+Inductive KG completion. We also examine the performance of our method in inductive KG completion. We randomly sample a subset of nodes that appears in the test set, then remove these nodes along with their associated edges from the training set. The remaining training set is used to train the models, and we add back the removed edges during evaluation. The evaluation transforms from fully conductive to fully inductive when the ratio of removed nodes increases from 0 to 1. The results of PATHCon, DistMult, and RotatE on relation prediction task are plotted in Figure 3. We observe that the performance of our method decreases slightly in fully inductive setting (from 0.954 to 0.922), while DistMult and RotatE fall to a "randomly guessing" level. This is because the two baselines are embedding-based models that rely on modeling node identity, while our method does not consider node identity thus being naturally generalizable to inductive KG completion.
+
+# 4.3 Model Variants
+
+The number of context hops and maximum path length. We investigate the sensitivity of our model to the number of context hops and maximum path length. We vary the two numbers from 0 to 4 (0 means the corresponding module is not used), and report the results of all combinations (without  $(0,0)$ ) on WN18RR in Figure 4. It is clear to see that increasing the number of context hops and maximum path length can significantly improve the result when they are small, which demonstrates that including more neighbor edges or counting longer paths does benefit the performance. But the marginal benefit is diminishing with the increase of layer numbers. Similar trend is observed on other datasets too.
+
+Context aggregators. We study how different implementations of context aggregator affect the model performance. The results of Mean, Concat, and Cross context aggregator on four datasets are shown in Figure 5 (results on FB15K and WN18 are omitted as they are similar to FB15K-237 and WN18RR, respectively). The results show that Mean performs worst on all datasets, which indicates the importance of node orders when aggregating features from nodes to edges. It is also interesting to notice that the performance comparison between Concat and Cross varies on different datasets: Concat is better than Cross on NELL995 and is worse than Cross on WN18RR, while their performance is on par on FB15K-237 and DDB14. However, note that a significant defect of Cross is that it has much more parameters than Concat, which requires more running time and memory resource.
+
+Path representation types and path aggregators. We implement four combinations of path representation types and path aggregators: Embedding+Mean, Embedding+Attention, RNN+Mean, and RNN+Attention, of which the results are presented in Figure 6. Different from context aggregators, results on the six datasets are similar for path representation types and path aggregators, so we only report the results on WN18RR. We find that Embedding is consistently better than RNN, which is probably because the length of relational paths are generally short (no more than 4 in our experiments), so RNN can hardly demonstrate its strength in modeling sequences. The results also show that Attention aggregator performs slightly better than Mean aggregator. This demonstrates that the contextual information of head and tail entities indeed helps identify the importance of relational paths.
+
+Initial edge features. Here we examine three types of initial edge features: identity, BOW, and BERT embedding of relation types. We choose to test on NELL995 because its relation names consist of relatively more English words thus are semantically meaningful (e.g., "organization.headquartered.in.state.orprovince"). The results are reported in Figure 7, which shows that BOW features are slightly better than identity, but BERT embeddings perform significantly worse than the other two. We attribute this finding to that BERT embeddings are better at identifying semantic relationship among relation types, but our model aims to learn the mapping from BERT embeddings of context/paths to the identity of predicted relation
+
+![](images/e5f223116b869ee0ddaa3fed60667b58ee45239c0e243f9205ff6dcfd9a25a93.jpg)  
+Figure 3: Results of inductive KG completion on WN18RR.
+
+![](images/d2a0a4062ac5338758c47dd6fb966c2b5a1abb81ed9fd49c7cd56ff506d6ab14.jpg)  
+Figure 4: Results of PATHCon with different hops/length on WN18RR.
+
+![](images/d0c4ca29e891e5ae990b0c660862aa28a7bef6e98619474cc9301e0d6fffafb9.jpg)  
+Figure 5: Results of Con with different context aggregators.
+
+![](images/4bf667d44fabd6c6e155e31f8624a7082d76de3acb533cec5d7aed15eda0a12d.jpg)  
+Figure 6: Results of PATHCON with different path representation types and path aggregators on WN18RR.
+
+![](images/cf11192fb9eb29e0760a6aa0885760fb00e38d09ded310b9d15417dc543521ab.jpg)  
+Figure 7: Results of CON, PATH, and PATHCON with different initial features of relations on NELL995.
+
+types. In other words, BERT may perform better if the predicted relation types are also represented by BERT embeddings, so that this mapping is learned within the embedding space. We leave the exploration as future work.
+
+# 4.4 Case Study on Model Explainability
+
+We choose FB15K-237 and DDB14 as the datasets to show the explainability of PATHCon. The number of context hops is set to 1 and the maximum path length is set to 2. When training is completed, we choose three relations from each dataset and list the most important relational context/paths to them based on the transformation matrix of the context/path aggregator. The results are presented in Table 5, from which we find that most of the identified context/paths are logically meaningful. For example, "education campus of" can be inferred by "education institution in", and "is associated with" is found to be a transitive relation. In addition, more visualized results and discussion on DDB14 dataset are included in Appendix E.
+
+# 5 RELATED WORK
+
+# 5.1 Knowledge Graph Completion
+
+KGs provide external information for a variety of downstream tasks such as recommender systems [27-29] and semantic analysis [26]. Most existing methods of KG completion are based on embeddings, which normally assign an embedding vector to each entity and relation in the continuous embedding space and train the embeddings based on the observed facts. One line of KG embedding methods is translation-based, which treat entities as points in a continuous
+
+space and each relation translates the entity point. The objective is that the translated head entity should be close to the tail entity in real space [3], complex space [22], or quaternion space [39], which have shown capability to handle multiple relation patterns and achieve state-of-the-art result. Another line of work is multi-linear or bilinear models, where they calculate the semantic similarity by matrix or vector dot product in real [35] or complex space [24]. Besides, several embedding-based methods explore the architecture design that goes beyond point vectors [6, 21]. However, these embedding-based models fail to predict links in inductive setting, neither can they discover any rules that explain the prediction.
+
+# 5.2 Graph Neural Networks
+
+Existing GNNs generally follow the idea of neural message passing [10] that consists of two procedures: propagation and aggregation. Under this framework, several GNNs are proposed that take inspiration from convolutional neural networks [8, 11, 15, 25], recurrent neural networks [17], and recursive neural networks [1]. However, these methods use node-based message passing, while we propose passing messages based on edges in this work.
+
+There are two GNN models conceptually connected to our idea of identifying relative position of nodes in a graph. DEGNN [16] captures the distance between the node set whose representation is to be learned and each node in the graph, which is used as extra node attributes or as controllers of message aggregation in GNNs. SEAL [38] labels nodes with their distance to two nodes  $a$  and  $b$  when predicting link existence between  $(a, b)$ . In contrast, we use relational paths to indicate the relative position of two nodes.
+
+Researchers also tried to apply GNNs to knowledge graphs. For example, Schlichtkrull et al. [20] use GNNs to model the entities and relations in KGs, however, they are limited in that they did not consider the relational paths and cannot predict in inductive settings. Wang et al. [30, 32] use GNNs to learn entity embeddings in KGs, but their purpose is to use the learned embeddings to enhance the performance of recommender systems rather than KG completion.
+
+# 6 CONCLUSION AND FUTURE WORK
+
+We propose PATHCon for KG completion. PATHCon considers two types of subgraph structure in KGs, i.e., contextual relations of the head/tail entity and relational paths between head and tail entity. We show that both relational context and relational paths are critical to relation prediction, and they can be combined further to achieve
+
+<table><tr><td></td><td>Predicted relation</td><td>Important relational context</td><td>Important relational paths</td></tr><tr><td>FB15K-237</td><td>award winner
+film written by
+education campus of</td><td>award honored for, award nominee
+film release region
+education major field of study</td><td>(award nominated for), (award winner, award category)
+(film edited by), (film crewmember)
+(education institution in)</td></tr><tr><td>DDB14</td><td>may cause
+is associated with
+may be allelic with</td><td>may cause, belongs to the drug family of
+is associated with, is a risk factor for
+may be allelic with, belong(s) to the category of</td><td>(is a risk factor for), (see also, may cause)
+(is associated with, is associated with)
+(may cause, may cause), (may be allelic with, may be allelic with)</td></tr></table>
+
+Table 5: Examples of important context/paths identified by PATHCon on FB15K-237 and DDB14.
+
+state-of-the-art performance. Moreover, PATHCon is also shown to be inductive, storage-efficient, and explainable.
+
+We point out four directions for future work. First, as we discussed in Remark 2, it is worth studying the empirical performance of PATHCON on node-feature-aware KGs. Second, as we discussed in Section 4.3, designing a model that can better take advantage of pre-trained word embeddings is a promising direction; Third, it is worth investigating why RNN does not perform well, and whether we can model relational paths better; Last, it is interesting to study if the context representation and path representation can be assembled in a more principled way.
+
+Acknowledgements. This research has been supported in part by DARPA, ARO, NSF, NIH, Stanford Data Science Initiative, Wu Tsai Neurosciences Institute, Chan Zuckerberg Biohub, Amazon, JPMorgan Chase, Docomo, Hitachi, Intel, JD.com, KDDI, NVIDIA, Dell, Toshiba, Visa, and UnitedHealth Group.
+
+# REFERENCES
+
+[1] Monica Bianchini, Marco Gori, and Franco Scarselli. 2001. Processing directed acyclic graphs with recursive neural networks. IEEE Transactions on Neural Networks 12, 6 (2001), 1464-1470.  
+[2] Kurt Bollacker, Colin Evans, Praveen Paritosh, Tim Sturge, and Jamie Taylor. 2008. Freebase: a collaboratively created graph database for structuring human knowledge. In SIGMOD. 1247-1250.  
+[3] Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko. 2013. Translating embeddings for modeling multi-relational data. In NeurIPS. 2787-2795.  
+[4] Antoine Bordes, Jason Weston, Ronan Collobert, and Yoshua Bengio. 2011. Learning structured embeddings of knowledge bases. In AAAI. 301-306.  
+[5] Andrew Carlson, Justin Betteridge, Bryan Kisiel, Burr Settles, Estevam R Hruschka, and Tom M Mitchell. 2010. Toward an architecture for never-ending language learning. In AAAI. 1306-1313.  
+[6] Tim Dettmers, Pasquale Minervini, Pontus Stenetorp, and Sebastian Riedel. 2018. Convolutional 2d knowledge graph embeddings. In AAAI. 1811-1818.  
+[7] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2018. Bert: pre-training of deep bidirectional transformers for language understanding. arXiv preprint (2018).  
+[8] David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alan Aspuru-Guzik, and Ryan P Adams. 2015. Convolutional networks on graphs for learning molecular fingerprints. In NeurIPS. 2224-2232.  
+[9] Luis Galárraga, Christina Teflioudi, Katja Hose, and Fabian M Suchanek. 2015. Fast rule mining in ontological knowledge bases with amie+. The VLDB Journal 24, 6 (2015), 707-730.  
+[10] Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. 2017. Neural message passing for quantum chemistry. In ICML. 1263-1272.  
+[11] Will Hamilton, Zhitao Ying, and Jure Leskovec. 2017. Inductive representation learning on large graphs. In NeurIPS. 1024-1034.  
+[12] Vinh Thinh Ho, Daria Stepanova, Mohamed H Gad-Elrab, Evgeny Kharlamov, and Gerhard Weikum. 2018. Rule learning from knowledge graphs guided by embedding models. In International Semantic Web Conference. Springer, 72–90.  
+[13] Seyed Mehran Kazemi and David Poole. 2018. Simple embedding for link prediction in knowledge graphs. In NeurIPS. 4284-4295.  
+[14] Diederik P Kingma and Jimmy Ba. 2015. Adam: a method for stochastic optimization. In ICLR.  
+[15] Thomas N Kipf and Max Welling. 2017. Semi-supervised classification with graph convolutional networks. In ICLR.  
+[16] Pan Li, Yanbang Wang, Hongwei Wang, and Jure Leskovec. 2020. Distance Encoding: Design Provably More Powerful Neural Networks for Graph Representation
+
+Learning. In NeurIPS.  
+[17] Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. 2016. Gated graph sequence neural networks. In ICLR.  
+[18] George A Miller. 1995. Wordnet: a lexical database for English. Commun. ACM 38, 11 (1995), 39-41.  
+[19] Ali Sadeghian, Mohammadreza Armandpour, Patrick Ding, and Daisy Zhe Wang 2019. Drum: end-to-end differentiable rule mining on knowledge graphs. In NeurIPS, 15321-15331.  
+[20] Michael Schlichtkrull, Thomas N Kipf, Peter Bloem, Rianne Van Den Berg, Ivan Titov, and Max Welling. 2018. Modeling relational data with graph convolutional networks. In European Semantic Web Conference. Springer, 593-607.  
+[21] Richard Socher, Danqi Chen, Christopher D Manning, and Andrew Ng. 2013. Reasoning with neural tensor networks for knowledge base completion. In NeurIPS 926-934.  
+[22] Zhiqing Sun, Zhi-Hong Deng, Jian-Yun Nie, and Jian Tang. 2019. Rotate: knowledge graph embedding by relational rotation in complex space. In ICLR.  
+[23] Kristina Toutanova and Danqi Chen. 2015. Observed versus latent features for knowledge base and text inference. In Workshop on Continuous Vector Space Models and their Compositionality. 57-66.  
+[24] Théo Trouillon, Johannes Welbl, Sebastian Riedel, Éric Gaussier, and Guillaume Bouchard. 2016. Complex embeddings for simple link prediction. In ICML.  
+[25] Hongwei Wang and Jure Leskovec. 2020. Unifying graph convolutional neural networks and label propagation. arXiv preprint (2020).  
+[26] Hongwei Wang, Fuzheng Zhang, Min Hou, Xing Xie, Minyi Guo, and Qi Liu. 2018. Shine: Signed heterogeneous information network embedding for sentiment link prediction. In WSDM, 592-600.  
+[27] Hongwei Wang, Fuzheng Zhang, Jialin Wang, Miao Zhao, Wenjie Li, Xing Xie, and Minyi Guo. 2018. Ripplenet: Propagating user preferences on the knowledge graph for recommender systems. In CIKM. 417-426.  
+[28] Hongwei Wang, Fuzheng Zhang, Jialin Wang, Miao Zhao, Wenjie Li, Xing Xie and Minyi Guo. 2019. Exploring high-order user preference on the knowledge graph for recommender systems. ACM Transactions on Information Systems 37, 3 (2019), 1-26.  
+[29] Hongwei Wang, Fuzheng Zhang, Xing Xie, and Minyi Guo. 2018. DKN: Deep knowledge-aware network for news recommendation. In WWW. 1835-1844.  
+[30] Hongwei Wang, Fuzheng Zhang, Mengdi Zhang, Jure Leskovec, Miao Zhao, Wenjie Li, and Zhongyuan Wang. 2019. Knowledge-aware graph neural networks with label smoothness regularization for recommender systems. In KDD. 968-977.  
+[31] Hongwei Wang, Fuzheng Zhang, Miao Zhao, Wenjie Li, Xing Xie, and Minyi Guo. 2019. Multi-task feature learning for knowledge graph enhanced recommendation. In WWW. 2000-2010.  
+[32] Hongwei Wang, Miao Zhao, Xing Xie, Wenjie Li, and Minyi Guo. 2019. Knowledge graph convolutional networks for recommender systems. In WWW.  
+[33] Wenhan Xiong, Thien Hoang, and William Yang Wang. 2017. Deeppath: a reinforcement learning method for knowledge graph reasoning. In EMNLP. 564-573.  
+[34] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. 2019. How powerful are graph neural networks?. In ICLR.  
+[35] Bishan Yang, Wen-tau Yih, Xiaodong He, Jianfeng Gao, and Li Deng. 2015. Embedding entities and relations for learning and inference in knowledge bases. In ICLR.  
+[36] Fan Yang, Zhilin Yang, and William W Cohen. 2017. Differentiable learning of logical rules for knowledge base reasoning. In NeurIPS. 2319-2328.  
+[37] Jonathan S Yedidia, William T Freeman, and Yair Weiss. 2003. Understanding belief propagation and its generalizations. Exploring artificial intelligence in the new millennium 8 (2003), 236-239.  
+[38] Muhan Zhang and Yixin Chen. 2018. Link prediction based on graph neural networks. In NeurIPS. 5165-5175.  
+[39] Shuai Zhang, Yi Tay, Lina Yao, and Qi Liu. 2019. Quaternion knowledge graph embeddings. In NeurIPS. 2731-2741.  
+[40] Wen Zhang, Bibek Paudel, Liang Wang, Jiaoyan Chen, Hai Zhu, Wei Zhang, Abraham Bernstein, and Huajun Chen. 2019. Iteratively learning embeddings and rules for knowledge graph reasoning. In WWW. 2366-2377.
+
+# APPENDIX
+
+# A Proof of Theorem 1
+
+Proof. In each iteration of node-based message passing:
+
+The aggregation (Eq. (3)) is performed for  $N$  times, and each aggregation takes  $\mathbb{E}[d] = \frac{2M}{N}$  elements as input in expectation, where  $\mathbb{E}[d]$  is the expected node degree. Therefore, the expected cost of aggregation in each iteration is  $N\cdot \mathbb{E}[d] = 2M$ ;
+
+The update (Eq. (4)) is performed for  $N$  times, and each update takes 2 elements as input. Therefore, the cost of update in each iteration is  $2N$ .
+
+In conclusion, the expected cost of node-based message passing in each iteration is  $2M + 2N$ .
+
+# B Proof of Theorem 2
+
+For relational message passing, it actually passes messages on the line graph of the original graph. The line graph of a given graph  $\mathcal{G}$ , denoted by  $L(\mathcal{G})$ , is a graph such that each node of  $L(\mathcal{G})$  represents an edge of  $\mathcal{G}$ , and two nodes of  $L(\mathcal{G})$  are adjacent if and only if their corresponding edges share a common endpoint in  $\mathcal{G}$ . We show by the following lemma that the line graph is much larger and denser than the original graph:
+
+LEMMA 1. The number of nodes in line graph  $L(\mathcal{G})$  is  $M$ , and the expected node degree of  $L(\mathcal{G})$  is
+
+$$
+\mathbb {E} _ {L (\mathcal {G})} [ d ] = \frac {N \cdot \operatorname {V a r} _ {\mathcal {G}} [ d ]}{M} + \frac {4 M}{N} - 2, \tag {22}
+$$
+
+where  $\operatorname{Var}_{\mathcal{G}}[d]$  is the variance of node degrees in  $\mathcal{G}$ .
+
+Proof. It is clear that the number of nodes in line graph  $L(\mathcal{G})$  is  $M$  because each node in  $L(\mathcal{G})$  corresponds to an edge in  $\mathcal{G}$ . We now prove that the expected node degree of  $L(\mathcal{G})$  is  $\mathbb{E}_{L(\mathcal{G})}[d] = \frac{N \cdot \mathrm{Var}_{\mathcal{G}}[d]}{M} + \frac{4M}{N} - 2$ .
+
+Let's first count the number of edges in  $L(\mathcal{G})$ . According to the definition of line graph, each edge in  $L(\mathcal{G})$  corresponds to an unordered pair of edges in  $\mathcal{G}$  connecting to a same node; On the other hand, each unordered pair of edges in  $\mathcal{G}$  that connect to a same node also determines an edge in  $L(\mathcal{G})$ . Therefore, the number of edges in  $L(\mathcal{G})$  equals the number of all unordered pairs of edges connecting to a same node:
+
+$$
+\# e d g e s i n L (\mathcal {G}) = \sum_ {i} {\binom {d _ {i}} {2}} = \sum_ {i} {\frac {d _ {i} (d _ {i} - 1)}{2}} = \frac {1}{2} \sum_ {i} d _ {i} ^ {2} - M,
+$$
+
+where  $d_{i}$  is the degree of node  $v_{i}$  in  $\mathcal{G}$  and  $M = 2\sum_{i}d_{i}$  is the number of edges. Then the expected node degree of  $L(\mathcal{G})$  is
+
+$$
+\begin{array}{l} \mathbb {E} _ {L (\mathcal {G})} [ d ] = 2 \cdot \frac {\# e d g e s i n L (\mathcal {G})}{\# n o d e s i n L (\mathcal {G})} = \frac {\sum_ {i} d _ {i} ^ {2} - 2 M}{M} \\ = \frac {N \cdot \mathbb {E} _ {\mathcal {G}} [ d ^ {2} ]}{M} - 2 = \frac {N \left(\operatorname {V a r} _ {\mathcal {G}} [ d ] + \mathbb {E} _ {\mathcal {G}} ^ {2} [ d ]\right)}{M} - 2 \\ = \frac {N \cdot \operatorname {V a r} _ {\mathcal {G}} [ d ] + N \left(\frac {2 M}{N}\right) ^ {2}}{M} - 2 \\ = \frac {N \cdot \operatorname {V a r} _ {\mathcal {G}} [ d ]}{M} + \frac {4 M}{N} - 2. \\ \end{array}
+$$
+
+□
+
+From Lemma 1 it is clear to see that  $\mathbb{E}_{L(\mathcal{G})}[d]$  is at least twice of  $\mathbb{E}_{\mathcal{G}}[d] = \frac{2M}{N}$ , i.e. the expected node degree of the original graph  $\mathcal{G}$ , since  $\mathrm{Var}_{\mathcal{G}}[d] \geq 0$  ( $-2$  is omitted). Unfortunately, in real-world graphs (including KGs), node degrees vary significantly, and they typically follow the power law distribution whose variance is extremely large due to the long tail (this is empirically justified in Table 2, as we can see that  $\mathrm{Var}_{\mathcal{G}}[d]$  is quite large for all KGs). This means that  $\mathbb{E}_{L(\mathcal{G})}[d] \gg \mathbb{E}_{\mathcal{G}}[d]$  in practice. On the other hand, the number of nodes in  $L(\mathcal{G})$  (which is  $M$ ) is also far larger than the number of nodes in  $\mathcal{G}$  (which is  $N$ ). Therefore,  $L(\mathcal{G})$  is generally much larger and denser than its original graph  $\mathcal{G}$ . Based on Lemma 1, Theorem 2 is proven as follows:
+
+Proof. In each iteration of relational message passing:
+
+The aggregation (Eq. (5)) is performed for  $M$  times, and each aggregation takes  $\mathbb{E}_{L(\mathcal{G})}[d] = \frac{N\cdot\mathrm{Var}_{\mathcal{G}}[d]}{M} +\frac{4M}{N} -2$  elements as input in expectation. So the expected cost of aggregation in each iteration is  $M\cdot \mathbb{E}_{L(\mathcal{G})}[d] = N\cdot \mathrm{Var}_{\mathcal{G}}[d] + \frac{4M^2}{N} -2M;$
+
+The update ((Eq. (6))) is performed for  $M$  times, and each update takes 2 elements as input. Therefore, the cost of update in each iteration is  $2M$ .
+
+In conclusion, the expected cost of relational message passing in each iteration is  $N \cdot \operatorname{Var}_{\mathcal{G}}[d] + \frac{4M^2}{N}$ .
+
+# C Proof of Theorem 3
+
+Proof. In each iteration of alternate relational message passing:
+
+The edge-to-node aggregation operation (Eq. (7)) is performed for  $N$  times, and each aggregation takes  $\mathbb{E}[d] = \frac{2M}{N}$  elements as input in expectation. Therefore, the expected cost of edge-to-node aggregation in each iteration is  $N\cdot \mathbb{E}[d] = 2M$ ;
+
+The node-to-edge aggregation (Eq. (8)) is performed for  $M$  times, and each aggregation takes 2 elements as input. So the cost of node-to-edge aggregation in each iteration is  $2M$ ;
+
+The update (Eq. (9)) is performed for  $M$  times, and each update takes 2 elements as input. Therefore, the cost of update in each iteration is  $2M$ .
+
+In conclusion, the expected cost of alternate relational message passing in each iteration is  $6M$ .
+
+# D Implementation Details
+
+Baselines. The implementation code of TransE, DistMult, ComplEx, and RotatE comes from https://github.com/DeepGraphLearning/KnowledgeGraphEmbedding; the implementation code of SimpleE is at https://github.com/baharefatemi/SimpleE; the implementation code of QuatE is at https://github.com/cheungdaven/QuatE, and we use  $\mathrm{QuatE}^2$  (QuatE without type constraints) here; the implementation code of DRUM is at https://github.com/alisadeghian/DRUM. For fair comparison, the embedding dimension for all the baselines are set to 400. We train each baseline for 1,000 epochs, and report the test result when the result on validation set is optimal.
+
+Our method. Our proposed method is implemented in TensorFlow and trained on single GPU. We use Adam [14] as the optimizer with learning rate of 0.005. L2 regularization is used to prevent overfitting and the weight of L2 loss term is  $10^{-7}$ . Batch size is 128, the number of epochs is 20, and the dimension of all hidden
+
+![](images/7c01505da3ae3dbfdc55fc20a3f3bc9daac8d66d2a9cce871e5f40c6e2ffb51e.jpg)  
+Figure 8: The learned correlation between all relational paths with length  $\leq 2$  and the predicted relations on DDB14.
+
+<table><tr><td></td><td>FB15K</td><td>FB15K-237</td><td>WN18</td><td>WN18RR</td><td>NELL995</td><td>DDB14</td></tr><tr><td>#context hops</td><td>2</td><td>2</td><td>3</td><td>3</td><td>2</td><td>3</td></tr><tr><td>Max. path len.</td><td>2</td><td>3</td><td>3</td><td>4</td><td>3</td><td>4</td></tr></table>
+
+states is 64. Initial relation features are set as their identities, while BOW/BERT features are studied in Section 4.3. The above settings are determined by optimizing the classification accuracy on the validation set of WN18RR, and kept unchanged for all datasets.
+
+During experiments we find that performance of different number of context hops and the maximum path length largely depends on datasets, so these hyper-parameters are tuned separately for each dataset. We present their default settings in Table 6, and search spaces of hyper-parameters as follows:
+
+- Dimension of hidden states:  $\{8, 16, 32, 64\}$ ;  
+- Weight of L2 loss term:  $\{10^{-8}, 10^{-7}, 10^{-6}, 10^{-5}\}$ ;  
+- Learning rate:  $\{0.001, 0.005, 0.01, 0.05, 0.1\}$ ;  
+- The number of context hops:  $\{1,2,3,4\}$ ;  
+Maximum path length:  $\{1,2,3,4\}$
+
+Each experiment of PATHCON is repeated for three times. We report average performance and standard deviation as the results.
+
+# E More Results of Explainability on DDB14
+
+After training on DDB14, we print out the transformation matrix of the context aggregator and the path aggregator in PATHCON, and the results are shown as heat maps in Figures 9 and 8, respectively. The degree of darkness of an entry in Figure 9 (Figure 8) denotes the strength of correlation between the existence of a contextual relation (a relational path) and a predicted relation. Relation IDs as well as their meanings are listed as follows for readers' reference:
+
+Table 6: Dataset-specific hyper-parameter settings: the number of context hops and the maximum path length.  
+
+<table><tr><td>0: belong(s) to the category of</td><td>7: interacts with</td></tr><tr><td>1: is a category subset of</td><td>8: belongs to the drug family of</td></tr><tr><td>2: may cause</td><td>9: belongs to drug super-family</td></tr><tr><td>3: is a subtype of</td><td>10: is a vector for</td></tr><tr><td>4: is a risk factor for</td><td>11: may be allelic with</td></tr><tr><td>5: is associated with</td><td>12: see also</td></tr><tr><td>6: may contraindicate</td><td>13: is an ingredient of</td></tr></table>
+
+Figure 9 shows that most of large values are distributed along the diagonal. This is in accordance with our intuition, for example, if we want to predict the relation for pair  $(h, ?, t)$  and we observe
+
+![](images/7602294cde9cc1541555ccf724080d85e4dda9d808c9161824fbd19b007a6224.jpg)  
+Figure 9: The learned correlation between the contextual relations of head/tail and the predicted relations on DDB14.
+
+that  $h$  appears in another triplet ( $h$ , is a risk factor for,  $t'$ ), then we know that the type of  $h$  is risk factor and it is likely to be a risk factor of other entities in the KG. Therefore, “?” are more likely to be “is a risk factor for” than “belongs to the drug family of” since  $h$  is not a drug. In addition, we also find some large values that are not in the diagonal, e.g., (belongs to the drug family of, belongs to the drug super-family) and (may contraindicate, interacts with).
+
+We also have some interesting findings from Figure 8. First, we find that many rules from Figure 8 is with the form:
+
+$$
+(a, \text {s e e} \quad \text {a l s o}, b) \wedge (b, \mathsf {R}, c) \Rightarrow (a, \mathsf {R}, c),
+$$
+
+where  $\mathsf{R}$  is a relation type in the KG. These rules are indeed meaningful because (a, see also, b) means  $a$  and  $b$  are equivalent thus can interchange with each other.
+
+We also find PATHCon learns rules that show the relation type is transitive, for example:
+
+$(a,$  is associated with,  $b)\wedge (b,$  is associated with,  $c$ $\Rightarrow (a,$  is associated with,  $c)$
+
+$(a,$  may be allelic with,  $b)\wedge (b,$  may be allelic with,  $c)$ $\Rightarrow (a,$  may be allelic with,  $c)$
+
+Other interesting rules learned by PATHCon include:
+
+$(a,\mathrm{belong}(s)$  to the category of,  $b)\Rightarrow (a$  is a subtype of,  $b)$
+
+(a, is a risk factor for,  $b) \Rightarrow (a, \text{may cause}, b)$ ;
+
+$(a,\text{may cause},c)\wedge (b,\text{may cause},c)\Rightarrow (a,\text{may be allelic with},b);$
+
+$(a, \text{is a risk factor for}, c) \wedge (b, \text{is a risk factor for}, c) \Rightarrow (a, \text{may be allelic with}, b)$ .

2002.06xxx/2002.06757/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:26fb61345057cdc0b240a9a45b14c6380951eda5ab625280ad90eab9f6a3f9dd
+size 688078

2002.06xxx/2002.06789/742d8561-0e5e-4192-b15b-21fc92c86ee6_content_list.json

@@ -0,0 +1,1714 @@
+[
+    {
+        "type": "text",
+        "text": "CAT: Customized Adversarial Training for Improved Robustness",
+        "text_level": 1,
+        "bbox": [
+            156,
+            109,
+            815,
+            132
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Minhao Cheng<sup>1</sup> Qi Lei<sup>2</sup> Pin-Yu Chen<sup>3</sup> Inderjit Dhillon<sup>2</sup> Cho-Jui Hsieh<sup>1</sup>",
+        "bbox": [
+            215,
+            176,
+            751,
+            193
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract",
+        "text_level": 1,
+        "bbox": [
+            241,
+            220,
+            318,
+            234
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training has become one of the most effective methods for improving robustness of neural networks. However, it often suffers from poor generalization on both clean and perturbed data. In this paper, we propose a new algorithm, named Customized Adversarial Training (CAT), which adaptively customizes the perturbation level and the corresponding label for each training sample in adversarial training. We show that the proposed algorithm achieves better clean and robust accuracy than previous adversarial training methods through extensive experiments.",
+        "bbox": [
+            117,
+            243,
+            442,
+            422
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. Introduction",
+        "text_level": 1,
+        "bbox": [
+            86,
+            452,
+            217,
+            468
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks (DNNs) have proved their effectiveness on a variety of domains and tasks. However, it has been found that DNNs are highly vulnerable to adversarial examples (Szegedy et al., 2014). To enhance the robustness of DNNs against adversarial examples, adversarial training (Goodfellow et al., 2015; Madry et al., 2018) has become one of the most effective and widely used methods. Given a pre-defined perturbation tolerance, denoted as  $\\epsilon$ , adversarial training aims to minimize the robust loss, defined as the worst-case loss within  $\\epsilon$ -ball around each example, leading to a min-max optimization problem. (Madry et al., 2018) show that applying a multi-step projected gradient descent (PGD) attack to approximately solve the inner maximization leads to a robust model, and several recent research has proposed various ways to improve adversarial training (Zhang et al., 2019b; Wang, 2019; Wang et al., 2019; Balaji et al., 2019; Ding et al., 2018).",
+        "bbox": [
+            84,
+            479,
+            475,
+            734
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, the standard adversarial training methods still have a hypothetical and possibly problematic assumption: the perturbation tolerance  $\\epsilon$  is a large and fixed constant throughout the training process, which ignores the fact that every data point may have different intrinsic robustness.",
+        "bbox": [
+            84,
+            742,
+            475,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, some examples are naturally closer to the decision boundary, and enforcing large margin on those examples will force the classifier to give up on those examples, leading to a distorted decision surface. This intuition may explain the known issue of the undesirable robustness-accuracy tradeoff in adversarial robustness (Su et al., 2018; Tsipras et al., 2019). Furthermore, with a different perturbation tolerance, it is questionable whether we should still force the model to learn to fit the one-hot label as in the original adversarial training formulation. In the extreme case, if an example is perturbed to the decision boundary, a good classifier yielding the binary class prediction probabilities should output  $[0.5, 0.5]$  instead of  $[1, 0]$ . This point becomes crucial when each example is associated with a different level of perturbation. Although some recent papers have started to address the uniform  $\\epsilon$  issue by treating correctly and incorrectly classified examples differently (Ding et al., 2018) or assigning non-uniform perturbation level (Balaji et al., 2019), none of them have tried to incorporate the customized training labels in this process.",
+        "bbox": [
+            495,
+            220,
+            887,
+            523
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Motivated by these ideas, we propose a novel Customized Adversarial Training (CAT) framework that can substantially improve the performance of adversarial training. Throughout the adversarial training process, our algorithm dynamically finds a non-uniform and effective perturbation level and the corresponding customized target label for each example. This leads to better generalization performance and furthermore, with a careful design on adaptive  $\\epsilon$  tuning, our algorithm has only negligible computational overhead and runs as fast as the original adversarial training algorithm. Furthermore, we theoretically explain why the proposed method could lead to improved generalization performance.",
+        "bbox": [
+            495,
+            530,
+            888,
+            712
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our method significantly outperforms existing adversarial training methods on the standard CIFAR-10 defense task. With Wide-ResNet structure on CIFAR-10, under  $8/255\\ell_{\\infty}$  perturbation, our method achieves  $73\\%$  robust accuracy under PGD attack and  $71\\%$  robust accuracy under Carlini and Wagner (C&W) attack (Carlini & Wagner, 2017), while the current best model only achieves  $58.6\\%$  under PGD attack and  $56.8\\%$  under C&W attack. Furthermore, our method only degrades the clean accuracy from  $95.93\\%$  (standard test accuracy) to  $93.48\\%$ , while other adversarial training methods have clean accuracy below  $91.34\\%$ .",
+        "bbox": [
+            495,
+            719,
+            887,
+            885
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "aside_text",
+        "text": "arXiv:2002.06789v1 [cs.LG] 17 Feb 2020",
+        "bbox": [
+            22,
+            263,
+            57,
+            708
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_footnote",
+        "text": "$^{1}$ Department of Computer Science, University of California, Los Angeles, USA  $^{2}$ Department of Computer Science, University of Texas, Austin, USA  $^{3}$ IBM research AI, Yorktown Heights, USA. Correspondence to: Minhao Cheng <mhcheng@ucla.edu>.",
+        "bbox": [
+            84,
+            828,
+            475,
+            881
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2. Related Work",
+        "text_level": 1,
+        "bbox": [
+            84,
+            83,
+            227,
+            98
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial attack. Finding adversarial examples, also known as adversarial attacks, can be formulated as an optimization problem — the goal is to find the perturbation  $\\delta$  to maximize the (robust) loss, while constraining  $\\delta$  to have small norm (e.g.,  $\\ell_p$  norm). Therefore gradient-based algorithms have been widely used, such as fast gradient sign method (FGSM) (Goodfellow et al., 2015), C&W attack (Carlini & Wagner, 2017) and PGD attack (Madry et al., 2018). In addition to white-box attacks, it has been also found that adversarial attacks can be generated also in the soft-label black box setting (Chen et al., 2017; Ilyas et al., 2018) and hard-label black box setting (Brendel et al., 2017; Cheng et al., 2018; 2020), and with similar quality to white-box attacks. Moreover, physical attacks have been proposed to generate adversarial examples in the real world (Eykholt et al., 2018). Therefore, with the existence of these powerful adversarial attacks, how to enhance the robustness of neural network models has become an important issue in many real world applications.",
+        "bbox": [
+            84,
+            109,
+            475,
+            396
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training. To enhance the adversarial robustness of a neural network model, a natural idea is to iteratively generate adversarial examples, add them back to the training data, and retrain the model. For example, Goodfellow et al. (2015) use adversarial examples generated by FGSM to augment the data, and Kurakin et al. (2017) propose to use a multiple-step FGSM to further improve the performance. Madry et al. (2018) show that adversarial training can be formulated as a min-max optimization problem, and propose to use PGD attack (similar to multi-step FGSM) to find adversarial examples for each batch. The resulting method achieves notable successes and can survive even under strong attacks (Athalye et al., 2018). After that, many defense algorithms are based on a similar min-max framework. Zhang et al. (2019b) propose TRADES, a theoretically-driven upper bound minimization algorithm to achieve the top-1 rank in NeurIPS 2018 defense competition. Recently, Ding et al. (2018) notice the importance of misclassified examples and treat correctly classified and misclassified examples differently. Wang (2020) use label prediction probability as a smooth way to combine correctly and misclassified samples. Other than just adding adversarial examples into the training process, Wang (2019) find that it is also effective to find the \"adversarial label\" along with the \"adversarial perturbation\". The convergence of adversarial training has also been studied (Gao et al., 2019; Wang et al., 2019). Recently, to reduce the computational overhead brought by adversarial training, several works have been proposed (Shafahi et al., 2019; Zhang et al., 2019a; Wong et al., 2020). It is widely recognized that the current defensive models are still not ideal and have considerable room for improvement. Moreover, to make robust models",
+        "bbox": [
+            84,
+            422,
+            477,
+            906
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "useful in practice, it is crucial that both clean and robust error need to be further enhanced.",
+        "bbox": [
+            496,
+            84,
+            885,
+            113
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Other adversarial defenses In addition to adversarial training based methods, a wide range of defense methods have been proposed such as Gaussian data augmentation (Zantedeschi et al., 2017), randomized smoothing (Liu et al., 2018; Cohen et al., 2019), Mixup (Zhang et al., 2018) and its variants (Thulasidasan et al., 2019; Verma et al., 2018), and Label smoothing (Shafahi et al., 2018; Goibert & Dohmatob, 2019). Shafahi et al. (2018) find that it could achieve similar robust accuracy with adversarial training when combining Gaussian data augmentation and label-smoothing.",
+        "bbox": [
+            495,
+            143,
+            887,
+            297
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "However, some of the aforementioned methods have been shown to cause obfuscated gradients instead of enhanced robustness (Athalye et al., 2018), while adversarial training based methods are still shown to be robust under different kinds of adversarial attacks.",
+        "bbox": [
+            495,
+            303,
+            885,
+            378
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3. Proposed Method",
+        "text_level": 1,
+        "bbox": [
+            496,
+            398,
+            671,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1. Preliminaries",
+        "text_level": 1,
+        "bbox": [
+            496,
+            424,
+            625,
+            439
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training can be formulated as a min-max optimization problem. For a  $K$ -class classification problem, let  $\\mathcal{D} = \\{(\\pmb{x}_i,y_i)\\}_{i = 1,\\dots ,n}$  denote the set of training samples in the dataset with  $\\pmb {x}_i\\in \\mathbb{R}^d$ $y_{i}\\in \\{1,\\ldots ,K\\} = :[K]$ . Let  $f_{\\theta}(\\pmb {x}):\\mathbb{R}^{d}\\to [K]$  denote a classification model parameterized by  $\\theta$ . We denote by  $h_\\theta (\\pmb {x}):\\mathbb{R}^d\\rightarrow [0,1]^K$  as the prediction output for each class, i.e.,  $f_{\\theta}(\\pmb {x}) = \\mathrm{argmax}_i[h_\\theta (\\pmb {x})]_i$ . We use standard  $O(\\cdot)$  notation to hide universal constant factor, and  $a\\lesssim b$  to indicate  $a = O(b)$ .",
+        "bbox": [
+            495,
+            448,
+            888,
+            585
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training can be formulated as:",
+        "bbox": [
+            496,
+            592,
+            777,
+            607
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\min  _ {\\theta} \\frac {1}{n} \\sum_ {i = 1} ^ {n} \\max  _ {\\boldsymbol {x} _ {i} ^ {\\prime} \\in \\mathcal {B} (\\boldsymbol {x} _ {i}, \\epsilon)} \\ell \\left(f _ {\\theta} \\left(\\boldsymbol {x} _ {i} ^ {\\prime}\\right), y _ {i}\\right), \\tag {1}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            575,
+            631,
+            885,
+            671
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where  $\\mathcal{B}(\\pmb{x}_i, \\epsilon)$  denotes the  $\\ell_p$ -norm ball centered at  $\\pmb{x}_i$  with radius  $\\epsilon$ . The inner maximization problem aims to find an adversarial version of a given data point  $\\pmb{x}_i$  that achieves a high loss. In general one can define  $\\mathcal{B}(\\pmb{x}_i, \\epsilon)$  based on the threat model, but the  $\\ell_{\\infty}$  ball is the most popular choice adopted by recent works (Madry et al., 2018; Zhang et al., 2019b; Wang, 2019; Ding et al., 2018; Wang, 2020), which will also be used in this paper. For a deep neural network model, the inner maximization does not have a closed form solution, so adversarial training methods typically use a gradient-based iterative solver to approximately solve the inner problem. The most commonly used choice is the multi-step PGD (Madry et al., 2018) and C&W attack (Carlini & Wagner, 2017).",
+        "bbox": [
+            495,
+            694,
+            888,
+            905
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "header",
+        "text": "CAT: Customized Adversarial Training for Improved Robustness",
+        "bbox": [
+            279,
+            56,
+            692,
+            70
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/2cd82c6c381d3c6f90da287502a833cb4c96d5c6194adcc46a2e07e1bbfb85f3.jpg",
+        "image_caption": [
+            "(a) Standard training"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            98,
+            95,
+            285,
+            238
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/f8aec5384bd9578539c3c4480f5726e7e985f0d7fee16a562a753639ada78da6.jpg",
+        "image_caption": [
+            "(b) Adv-train with  $\\epsilon = 1$"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            300,
+            95,
+            486,
+            237
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/21e7760168b3a7b88302180bb40a6c5e5c61b8cf83e84ea55fefb0b38e8f7638.jpg",
+        "image_caption": [
+            "(c) Adv-train with  $\\epsilon = 4$",
+            "Figure 1. Different training methods on a linearly separable binary classification dataset with 1.75 margin for both classes. Adversarial training with small  $\\epsilon$  works fine, but for a large  $\\epsilon$  beyond the true margin, adversarial training would ruin the classifier's classification performance, while our proposed adaptive customized adversarial training method still keeps a good generalization performance."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            501,
+            95,
+            687,
+            237
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/0951df86790934bc6aae77d8f84521e3e83bdda00a616ad07625ab514c1fd11b.jpg",
+        "image_caption": [
+            "(d) CAT (ours) with  $\\epsilon_{max} = 4$"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            702,
+            95,
+            888,
+            237
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2. Motivation",
+        "text_level": 1,
+        "bbox": [
+            84,
+            333,
+            194,
+            345
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, if adversarial training can always find a model with close-to-zero robust error, one should always use a large  $\\epsilon$  for training because it will automatically imply robustness to any smaller  $\\epsilon$ . Unfortunately, in practice a uniformly large  $\\epsilon$  is often harmful. In the following we empirically explain this problem and use it to motivate our proposed algorithm.",
+        "bbox": [
+            84,
+            356,
+            475,
+            462
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use a simple linear classification case to demonstrate why a uniformly large  $\\epsilon$  is harmful. In Figure 1a, we generate a synthetic linearly separable dataset with the margin set to be 1.75 for both classes, and the correct linear boundary can be easily obtained by standard training. In Figure 1b, we run adversarial training with  $\\epsilon = 1$ , and since this  $\\epsilon$  is smaller than the margin, the algorithm can still obtain near-optimal results. However, when we use a large  $\\epsilon = 4$  for adversarial training in Figure 1c, the resulting decision boundary becomes significantly worse. It is because adversarial training cannot correctly fit all the samples with a margin up to 4, so it will sacrifice some data samples, leading to distorted and undesirable decision boundary. This motivates the following two problems:",
+        "bbox": [
+            84,
+            469,
+            475,
+            680
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- We shouldn't set the same large  $\\epsilon$  uniformly for all samples. Some samples are intrinsically closer to the decision boundary and they should use a smaller  $\\epsilon$ . Without doing this, adversarial training will give up on those samples, which leads to worse training and generalization error (see more discussions in Section 3.5 on the generalization bounds).",
+            "- The adversarial training loss is trying to force the prediction to match the one-hot label (e.g., [1, 0] in the binary classification case) even after large perturbations. However, if a sample is perturbed, the prediction shouldn't remain one-hot. For instance, if a sample is perturbed to the decision boundary, the prediction of a perfect model should be  $[0.5, 0.5]$  instead of  $[1, 0]$ ."
+        ],
+        "bbox": [
+            101,
+            688,
+            473,
+            901
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This also makes adversarial training fail to recover a good decision hyperplane.",
+        "bbox": [
+            527,
+            333,
+            885,
+            363
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, we observe that even if adversarial training can obtain close-to-zero training error with large  $\\epsilon$  (e.g., (Gao et al., 2019) proves that this will happen for overparameterized network with large-enough margin), a uniformly large  $\\epsilon$  will lead to larger generalization gap. This could be partially explained by the theoretical results provided by (Yin et al., 2018), which shows that the adversarial Rademacher complexity has a lower bound with an explicit dependence on the perturbation tolerance. The empirical results in Table 1 also illustrate this problem. When conducting adversarial training with  $\\epsilon = 0.3$  on CIFAR10 VGG-16, we found that the model achieves close-to-zero robust training error on all  $\\epsilon \\leq 0.3$ , but it suffers larger generalization gap compared to training with smaller  $\\epsilon$ . This also demonstrates that a uniformly large  $\\epsilon$  is harmful even when it achieves perfect training error.",
+        "bbox": [
+            496,
+            369,
+            887,
+            612
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/9c700014c447688f6e9d209c98b5dd5588c3bc910dee2a227a75aa85196e3b15.jpg",
+        "table_caption": [
+            "Table 1. The influence of different fixed  $\\epsilon$  values used in adversarial training on the robust accuracy with  $\\epsilon = {0.01}$  ."
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Testing ε</td><td rowspan=\"2\">Error Type</td><td colspan=\"3\">Training ε</td></tr><tr><td>0.01</td><td>0.02</td><td>0.03</td></tr><tr><td rowspan=\"2\">0.01</td><td>Train</td><td>99.96%</td><td>99.99%</td><td>99.16%</td></tr><tr><td>Test</td><td>69.79%</td><td>69.06%</td><td>66.04%</td></tr></table>",
+        "bbox": [
+            500,
+            669,
+            883,
+            733
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "CAT (Customized Adversarial Training) We propose the Customized Adversarial Training (CAT) framework that improves adversarial training by addressing the above-mentioned problems. First, our algorithm has an auto-tuning  $\\epsilon$  method to customize the  $\\epsilon$  used for each training example. Second, instead of forcing the model to fit the original label, we customize the target label for each example based on its own  $\\epsilon$ . In the following we will describe these two components in more detail.",
+        "bbox": [
+            495,
+            768,
+            885,
+            905
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "header",
+        "text": "CAT: Customized Adversarial Training for Improved Robustness",
+        "bbox": [
+            279,
+            56,
+            692,
+            70
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3. Auto-tuning  $\\epsilon$  for adversarial training",
+        "text_level": 1,
+        "bbox": [
+            84,
+            85,
+            382,
+            99
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The first component of our algorithm is an auto-tuning  $\\epsilon$  tuning method which adaptively assigns a suitable  $\\epsilon$  for each sample during the adversarial training procedure. Let  $\\epsilon_{i}$  be the perturbation level assigned to example  $i$ . Based on the intuition mentioned in Section 3.2, we do not want to further increase  $\\epsilon$  if we find the classifier does not have capacity to robustly classify the example, which means we should set",
+        "bbox": [
+            84,
+            108,
+            473,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\epsilon_ {i} = \\underset {\\epsilon} {\\operatorname {a r g m i n}} \\left\\{\\max  _ {\\boldsymbol {x} _ {i} ^ {\\prime} \\in \\mathcal {B} \\left(\\boldsymbol {x} _ {i}, \\epsilon\\right)} f _ {\\theta} \\left(\\boldsymbol {x} _ {i} ^ {\\prime}\\right) \\neq y _ {i} \\right\\} \\tag {2}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            153,
+            223,
+            473,
+            248
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and the adversarial training objective becomes",
+        "bbox": [
+            84,
+            257,
+            392,
+            272
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\min  _ {\\theta} \\frac {1}{n} \\sum_ {i = 1} ^ {n} \\max  _ {\\boldsymbol {x} _ {i} ^ {\\prime} \\in \\mathcal {B} \\left(\\boldsymbol {x} _ {i}, \\epsilon_ {i}\\right)} \\ell \\left(f _ {\\theta} \\left(\\boldsymbol {x} _ {i} ^ {\\prime}\\right), y _ {i}\\right). \\tag {3}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            158,
+            282,
+            473,
+            321
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that  $\\epsilon_{i}$  in (2) depends on  $\\theta$  while  $\\theta$  in (3) also depends on  $\\epsilon_{i}$ . We thus propose to conduct alternative updates — conducting one SGD update on  $\\theta$ , and then update the  $\\epsilon_{i}$  in the current batch. However, finding  $\\epsilon_{i}$  exactly requires brute-force search for every possible value, which adds significant computational overhead to adversarial training. Therefore, we only conduct a simplified update rule on  $\\epsilon_{i}$  as follows. Starting from an initial perturbation level of zero, at each iteration we conduct adversarial attack (e.g., PGD attack) with perturbation tolerance  $\\epsilon_{i} + \\eta$  where  $\\eta$  is a constant. If the attack is successful, then we keep the current  $\\epsilon_{i}$ , while if the attack is unsuccessful, which means an attacker still cannot find an adversarial example that satisfies  $\\max_{\\boldsymbol{x}_i' \\in \\mathcal{B}(\\boldsymbol{x}_i, \\epsilon_i + \\eta)} f_\\theta(\\boldsymbol{x}_i') \\neq y_i$ , then we increase  $\\epsilon_{i} = \\epsilon_{i} + \\eta$ . The attack results will also be used to update the model parameter  $\\theta$ , so this adaptive scheme does not require any additional cost. In practice, we also have an upper bound on the final perturbation to make sure each individual  $\\epsilon_{i}$  will not be too large.",
+        "bbox": [
+            84,
+            329,
+            475,
+            617
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4. Adaptive label uncertainty for adversarial training",
+        "text_level": 1,
+        "bbox": [
+            84,
+            633,
+            472,
+            648
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As mentioned in Section 3.2, the standard adversarial training loss is trying to enforce a sample being classified as the original one-hot label after  $\\epsilon$  perturbation. However, this may not be ideal. In the extreme case, if a sample is perturbed to the decision boundary, the prediction must be far away from one-hot. This problem is more severe when using non-uniform  $\\epsilon_{i}$ , since each different  $\\epsilon_{i}$  will introduce a different bias to the loss, and that may be one of the reasons that purely adaptive  $\\epsilon$ -scheduling does not work well (see our ablation study in Section 4.4 and also the results reported in (Balaji et al., 2019)).",
+        "bbox": [
+            84,
+            656,
+            475,
+            823
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the following, we propose an adaptive label smoothing approach to reflect different perturbation tolerance on each example. Szegedy et al. (2016) introduced label smoothing that converts one-hot label vectors into one-warm vectors representing low-confidence classification, in order to",
+        "bbox": [
+            84,
+            829,
+            475,
+            905
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "prevent the model from making over-confident predictions. Specifically, with a one-hot encoded label  $y$ , the smoothed version is",
+        "bbox": [
+            496,
+            84,
+            885,
+            128
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\tilde {y} = (1 - \\alpha) y + \\alpha u\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            622,
+            130,
+            759,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where  $\\alpha \\in [0,1]$  is the hyperparameter to control the smoothing level. In the adaptive setting, we set  $\\alpha = c*\\epsilon_{i}$  so that a larger perturbation tolerance would receive a higher label uncertainty and  $c$  is a hyperparameter. A common choice of  $u$  is the uniform distribution  $u = \\frac{1}{K}$ . To further prevent over-fitting and improve the generalization, we use  $u = \\operatorname{Dirichlet}(\\mathbf{1})$  where  $\\operatorname{Dirichlet}(\\cdot)$  refers to the Dirichlet distribution and  $\\mathbf{1} \\in \\mathbb{R}^{K}$  is an all one vector. With different perturbation tolerance, the adaptive version of label smoothing is",
+        "bbox": [
+            496,
+            151,
+            885,
+            303
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\tilde {y} _ {i} = \\left(1 - c \\epsilon_ {i}\\right) y _ {i} + c \\epsilon_ {i} \\text {D i r i c h l e t} (\\mathbf {1}). \\tag {4}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            571,
+            314,
+            885,
+            330
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The final objective function: Combining the two aforementioned two main techniques, our Customized Adversarial Training (CAT) method attempts to minimize the following objective:",
+        "bbox": [
+            496,
+            348,
+            887,
+            407
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\min  _ {\\theta} \\frac {1}{n} \\sum_ {i = 1} ^ {n} \\max  _ {\\boldsymbol {x} _ {i} ^ {\\prime} \\in \\mathcal {B} \\left(\\boldsymbol {x} _ {i}, \\epsilon_ {i}\\right)} \\ell \\left(f _ {\\theta} \\left(\\boldsymbol {x} _ {i} ^ {\\prime}\\right), \\tilde {\\boldsymbol {y}} _ {i}\\right) \\tag {5}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            539,
+            419,
+            883,
+            458
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf{s.t.} \\epsilon_ {i} = \\underset {\\epsilon} {\\operatorname {a r g m i n}} \\left\\{\\max  _ {\\boldsymbol {x} _ {i} ^ {\\prime} \\in \\mathcal {B} (\\boldsymbol {x} _ {i}, \\epsilon)} f _ {\\theta} \\left(\\boldsymbol {x} _ {i} ^ {\\prime}\\right) \\neq y _ {i} \\right\\}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            568,
+            460,
+            841,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where  $\\tilde{y}_i$  is defined in (4). As described in Section 3.3, we approximately minimize this objective with an alternative update scheme, which encounters almost no additional cost compared to the original adversarial training algorithm. The detailed algorithm is shown in Algorithm 1.",
+        "bbox": [
+            496,
+            494,
+            885,
+            571
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Choice of loss function. In general, our framework can be used with any loss function  $\\ell(\\cdot)$ . In the previous works, cross entropy loss is commonly used for  $\\ell$ . However, the model trained by smoothing techniques tends to have better performance against PGD attack than  $\\mathrm{C\\&W_{\\infty}}$  attack (see the VGG experiments in Figure 2. So in addition to testing our algorithm under cross entropy loss, we also propose a mixed loss to enhance the defense performance towards  $\\mathrm{C\\&W_{\\infty}}$  attack. That is,",
+        "bbox": [
+            496,
+            577,
+            885,
+            714
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\operatorname {C E} \\left(x _ {i}, \\tilde {y} _ {i}\\right) + \\max  \\left\\{\\left[ \\max  _ {i \\neq y _ {0}} [ Z (\\boldsymbol {x}) ] _ {i} - [ Z (\\boldsymbol {x}) ] _ {y _ {0}}, - \\kappa \\right\\}, \\right. \\tag {6}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            511,
+            724,
+            883,
+            748
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where  $Z(\\pmb{x}) \\in \\mathbb{R}^{K}$  is the final (logit) layer output, and  $[Z(\\pmb{x})]_i$  is the prediction score for the i-th class and  $y_{0}$  is the original label. The parameter  $\\kappa$  encourages to find an adversary that will not classify as class  $y_{0}$  with high confidence.",
+        "bbox": [
+            496,
+            758,
+            885,
+            834
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.5. Theoretical Analysis",
+        "text_level": 1,
+        "bbox": [
+            496,
+            851,
+            671,
+            866
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To better understand how our scheme improves generalization, we provide some theoretical analysis. Recall we denote",
+        "bbox": [
+            496,
+            875,
+            885,
+            905
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "header",
+        "text": "CAT: Customized Adversarial Training for Improved Robustness",
+        "bbox": [
+            279,
+            56,
+            692,
+            70
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 CAT algorithm",
+        "text_level": 1,
+        "bbox": [
+            86,
+            84,
+            277,
+            99
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "code",
+        "sub_type": "algorithm",
+        "code_caption": [],
+        "code_body": "Input: Training dataset  $(X,Y)$ , cross entropy loss or mix loss  $\\ell$ , scheduling parameter  $\\eta$ , weighting factor  $c$ , perturbation upperbound  $\\epsilon_{max}$   \nInitial every sample's  $\\epsilon_i$  with 0  \nfor epoch=1,...,N do  \n    for i=1,...,B do  \n         $\\tilde{y}_i \\gets (1 - c\\epsilon_i)y_i + (1 - c\\epsilon_i)\\text{Dirichlet}(1)$ $\\epsilon_i \\gets \\epsilon_i + \\eta$ $\\delta_i \\gets 0$   \n    for  $j = 1\\dots m$  do  \n         $\\delta_i \\gets \\delta_i + \\alpha \\cdot sign(\\nabla_\\delta \\ell(f_\\theta(\\boldsymbol{x}_i + \\delta_i),\\tilde{y}_i))$ $\\delta_i \\gets \\max(\\min(\\delta_i,\\epsilon_i),-\\epsilon_i)$   \n    end for  \n    if  $f_\\theta(\\boldsymbol{x}_i + \\delta_i) \\neq y_i$  then  \n         $\\epsilon_i \\gets \\epsilon_i - \\eta$   \n    end if  \n     $\\epsilon_i \\gets \\min(\\epsilon_{max},\\epsilon_i)$ $\\tilde{y}_i \\gets (1 - c\\epsilon_i)y_i + (1 - c\\epsilon_i)\\text{Dirichlet}(1)$ $\\theta \\gets \\theta - \\gamma_\\theta\\nabla_\\theta\\ell(f_\\theta(\\boldsymbol{x}_i + \\delta_i),\\tilde{y}_i)$   \nend for  \nend for  \nreturn  $\\theta$",
+        "bbox": [
+            99,
+            104,
+            475,
+            436
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "by  $h_{\\theta}(\\pmb{x}) : \\mathbb{R}^d \\to [0,1]^K$  as the prediction probability for the  $K$  classes. We define the bilateral margin that our paper is essentially maximizing over as follows.",
+        "bbox": [
+            84,
+            462,
+            473,
+            508
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.1 (Bilateral margin) We define the bilateral perturbed network output by  $H_{\\theta}(\\boldsymbol{x}, \\boldsymbol{\\delta}^i, \\boldsymbol{\\delta}^o)$ :",
+        "bbox": [
+            84,
+            518,
+            473,
+            550
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nH _ {\\theta} (\\boldsymbol {x}, \\boldsymbol {\\delta} ^ {i}, \\boldsymbol {\\delta} ^ {o}) := h _ {\\theta} \\left(\\boldsymbol {x} + \\boldsymbol {\\delta} ^ {i} \\| \\boldsymbol {x} \\|\\right) + \\boldsymbol {\\delta} ^ {o} \\left\\| \\boldsymbol {x} + \\boldsymbol {\\delta} ^ {i} \\| \\boldsymbol {x} \\| \\right\\|.\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            98,
+            558,
+            460,
+            578
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The bilateral margin is now defined as the minimum norm of  $(\\delta^i,\\delta^o)$  required to cause the classifier to make false predictions:",
+        "bbox": [
+            84,
+            585,
+            473,
+            630
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "code",
+        "sub_type": "algorithm",
+        "code_caption": [],
+        "code_body": "$m_{F}(\\pmb {x},y)\\coloneqq \\min_{\\pmb{\\delta}^{i},\\pmb{\\delta}^{o}}\\sqrt{\\|\\pmb{\\delta}^{i}\\|^{2} + \\|\\pmb{\\delta}^{o}\\|^{2}}$  subject to  $\\max_{y^{\\prime}}H_{\\theta}(\\pmb {x},\\pmb{\\delta}^{i},\\pmb{\\delta}^{o})_{y^{\\prime}}\\neq y.$  (7)",
+        "bbox": [
+            102,
+            638,
+            473,
+            691
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This margin captures both the relative perturbation on the input layer  $\\delta^i$  and on the soft-max output  $\\delta^o$ .",
+        "bbox": [
+            84,
+            707,
+            473,
+            737
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.2 Suppose the parameter space  $\\Theta$  we optimize over has covering number that scales as  $\\log \\mathcal{N}_{\\| \\cdot \\|_{op}}(\\eta ,\\Theta)\\leq \\lfloor \\mathcal{C}^2 /\\eta^2\\rfloor$  for some complexity  $\\mathcal{C}$ . Then with probability  $1 - \\delta$  over the draw of the training data, any classifier  $f_{\\theta},\\theta \\in \\Theta$  which achieves training error O satisfies:",
+        "bbox": [
+            84,
+            750,
+            473,
+            824
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbb {E} [ f _ {\\theta} (\\boldsymbol {x}) = y ] \\lesssim \\frac {\\mathcal {C} \\log^ {2} n}{\\sqrt {n}} \\sqrt {\\frac {1}{n} \\sum_ {i = 1} ^ {n} \\frac {1}{m _ {F} (\\boldsymbol {x} _ {i} , y _ {i})}} + \\zeta ,\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            106,
+            833,
+            450,
+            880
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where  $\\zeta$  is of small order  $O\\left(\\frac{1}{n}\\log (1 / \\delta)\\right)$",
+        "bbox": [
+            84,
+            888,
+            362,
+            907
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We defer the proof to the Appendix, which is adapted from Theorem 2.1 of (Wei & Ma, 2019). We observe the population risk is bounded by two key factors, the average of  $\\frac{1}{m_F(\\boldsymbol{x}_i,y_i)}$  and  $\\mathcal{C}$ , the covering number of the parameter space. On one side, the average of  $\\frac{1}{m_F(\\boldsymbol{x}_i,y_i)}$  is dominated by the samples with the smallest margin. Therefore when we do adversarial training, it is important that we not only achieve higher overall accuracy, but also make sure the samples closer to the decision boundary have large enough margin. This can not be achieved by simply using constant and large  $\\epsilon$  that will maintain a large margin for most samples but sacrifice the accuracy of a small portion of data. On the other hand, the covering number of the network's parameter space can be roughly captured by a bound of product of all layers' weight norms. We hypothesize that with more flexibility in choosing  $\\epsilon$ , our algorithm will converge faster than using larger constant  $\\epsilon$  and will have more implicit regularization effect. To testify this hypothesis, we roughly measure the model complexity  $\\mathcal{C}$  by the product of the weight norms of different models. In comparison to our model, when training with constant  $\\epsilon = 0.01$ , 0.02 and 0.03, it respectively yields  $\\mathcal{C}$  as large as 2.54, 3.53 and 1.39 times of that of our model, which means our model indeed has more implicit regularization effect among others.",
+        "bbox": [
+            496,
+            84,
+            887,
+            452
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.6. Connections with other training methods",
+        "text_level": 1,
+        "bbox": [
+            496,
+            468,
+            816,
+            484
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Many recent papers attempt to improve adversarial training. Although they all follow the similar min-max framework, each of them uses slightly different loss functions. We summarize the loss functions used by recent adversarial training methods in Table 2.",
+        "bbox": [
+            496,
+            492,
+            885,
+            566
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We see that except for natural training which directly minimizes the cross entropy loss (denoted as CE), all training techniques involve the use of the min-max framework. TRADES and MMA use the unperturbed data's cross entropy loss as an additional regularization term to achieve a better trade-off between clean and robust error.",
+        "bbox": [
+            495,
+            574,
+            887,
+            665
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Similar to our method, both MMA and IAAT have samplewise adaptive  $\\epsilon$  during training. They also utilize the adaptive  $\\epsilon$  to find the largest possible  $\\epsilon_{i}$  for every sample  $x_{i}$ . However, they do not consider the adaptive label technique mentioned in Section 3.4. As a result, they can only achieve better clean accuracy while the improvements in robust accuracy is limited. Our CAT-CE algorithm (CAT with CE loss) is more general than IAAT and MMA. CAT-CE reduce to IAAT when we set  $c = 0$  in adaptive label smoothing. Moreover, MMA could be treated as a special case of CAT-CE when we use a line search scheme to find the  $\\epsilon_{i}$  and  $c = 0$ . Also, in Section 4.4, we will show the importance of the adaptive label uncertainty step in CAT.",
+        "bbox": [
+            495,
+            672,
+            888,
+            869
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "header",
+        "text": "CAT: Customized Adversarial Training for Improved Robustness",
+        "bbox": [
+            279,
+            56,
+            692,
+            70
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/715842dc50a413e42aa2847cd052e27e8e783fc05702185f3370687bacab0c73.jpg",
+        "table_caption": [
+            "Table 2. Summary of several robust training methods and their corresponding loss function. Dirichlet(b) indicates the Dirichlet distribution parameterized by b."
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>Loss Function</td></tr><tr><td>Natural</td><td>CE(fθ(x),y)</td></tr><tr><td>Adversarial training (Madry et al., 2018)</td><td>maxx&#x27;∈B(x,ε) CE(fθ(x&#x27;),y)</td></tr><tr><td>TRADES (Zhang et al., 2019b)</td><td>CE(fθ(x),y) + maxx&#x27;∈B(x,ε) KL(fθ(x&#x27;),fθ(x))</td></tr><tr><td>Bilateral Adv Training (Wang, 2019)</td><td>maxx&#x27;∈B(x,ε),y&#x27;∈Δ CE(fθ(x&#x27;),y&#x27;)</td></tr><tr><td>MMA (Ding et al., 2018)</td><td>CE(fθ(x))1(fθ(x)≠y) + (maxx&#x27;∈B(x,ε) CE(fθ(x&#x27;),y))1(fθ(x)=y)</td></tr><tr><td>MART (Wang, 2020)</td><td>maxx&#x27;∈B(x,ε) BCE(fθ(x&#x27;),y) + KL(fθ(x&#x27;),fθ(x))·(1-fθ(x))</td></tr><tr><td>IAAT (Balaji et al., 2019)</td><td>maxx&#x27;∈B(xi,εi) CE(fθ(x&#x27;),yi)</td></tr><tr><td>CAT-CE (ours)</td><td>maxx&#x27;∈B(xi,εi) CE(fθ(x&#x27;),(1-cεi)y_i+ cεiDirichlet(1))</td></tr><tr><td>CAT-MIX (ours)</td><td>maxx&#x27;∈B(xi,εi) CE(x&#x27;, (1-cεi)y_i+ cεiDirichlet(1)) + maxj≠y_0[Z(x&#x27;)j-[Z(x&#x27;)j]y_0</td></tr></table>",
+        "bbox": [
+            98,
+            126,
+            875,
+            277
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4. Performance Evaluation",
+        "text_level": 1,
+        "bbox": [
+            84,
+            306,
+            313,
+            321
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct extensive experiments to show that CAT achieves a strong result on both clean and robust accuracy. We include the following methods into our comparison:",
+        "bbox": [
+            84,
+            332,
+            475,
+            391
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- Customized Adversarial Training (CAT-CE): Our proposed method with the cross entropy loss.",
+            "- Customized Adversarial Training (CAT-MIX): Our proposed method with the mixed cross entropy loss (6).",
+            "- Adversarial training: The adversarial training method proposed in (Madry et al., 2018) where they use a K-step PGD attack as adversary.",
+            "- TRADES: TRADES (Zhang et al., 2019b) improves adversarial training by an additional loss on the clean examples and achieves the state-of-art performance on robust accuracy.",
+            "- Natural: the natural training which only minimizes the cross entropy loss."
+        ],
+        "bbox": [
+            101,
+            400,
+            475,
+            595
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, since many recently proposed adversarial training methods have considered CIFAR-10 with Wide-ResNet structure as the standard setting and report their numbers, we also compare our performance with 7 previous methods on this specific setting.",
+        "bbox": [
+            84,
+            604,
+            475,
+            679
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1. Experimental Setup",
+        "text_level": 1,
+        "bbox": [
+            84,
+            696,
+            259,
+            710
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dataset and model structure. We use two popular dataset CIFAR-10 (Krizhevsky et al.) and Restricted-ImageNet (Deng et al., 2009) for performance evaluation. For CIFAR-10, we use both standard VGG-16 (Simonyan & Zisserman, 2015) and Wide ResNet that is used in both vanilla adversarial training (Madry et al., 2018) and TRADES (Zhang et al., 2019b). For VGG-16, we implement adversarial training with the standard hyperparameters and train TRADES with the official implementation. For Wide ResNet, since the model has become standard for testing adversarial training methods, we use exactly the same model structure provided by (Madry et al., 2018;",
+        "bbox": [
+            84,
+            720,
+            478,
+            901
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Zhang et al., 2019b). And use the models' checkpoint released by adversarial training and TRADES official repository and implement the Madry's adversarial training using the standard hyper-parameters. For Restricted-ImageNet, we use ResNet-50. All our experiments were implemented in Pytorch-1.4 and conducted using dual Intel E5-2640 v4 CPUs (2.40GHz) with 512 GB memory with a GTX 2080 TI GPU.",
+        "bbox": [
+            495,
+            306,
+            887,
+            428
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation details. We set the number of iterations in adversarial attack to be 10 for all methods. Adversarial training and TRADES are trained on PGD attacks setting  $\\epsilon = 8 / 255$  with cross entropy loss (CE). We implement our CAT method both on cross entropy (CE) (Madry et al., 2018) and C&W loss (Carlini & Wagner, 2017), and set  $\\epsilon_{\\mathrm{max}} = 8 / 255$ . All the models are trained using SGD with momentum 0.9, weight decay  $5 \\times 10^{-4}$ . For VGG-16/Wide ResNet models, we use the initial learning rate of 0.01/0.1, and we decay the learning rate by  $90\\%$  at the 80th, 140th, and 180th epoch. For CAT, we set epsilon scheduling parameter  $\\eta = 0.005$ ,  $\\epsilon_{\\mathrm{max}} = 8 / 255$  and weighting parameter  $c = 10$ . For CAT-MIX, we set  $\\kappa = 10$ .",
+        "bbox": [
+            495,
+            436,
+            888,
+            632
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2. Robustness Evaluation and Analysis",
+        "text_level": 1,
+        "bbox": [
+            496,
+            648,
+            782,
+            664
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "White-box attacks. For CIFAR10, we evaluate all the models under different tolerance of white-box  $\\ell_{\\infty}$ -norm bounded non-targeted PGD and C&W attack. Specifically, we use both  $\\mathrm{PGD}^{20}$  (20-step PGD with step size  $\\epsilon / 5$ ) and C&W $_{\\infty}$ . All attacks are equipped with random-start. To be noted, when  $\\epsilon = 0$ , the robust accuracy is reduced to test accuracy of unperturbed (natural) test samples, i.e clean accuracy.",
+        "bbox": [
+            495,
+            672,
+            887,
+            777
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The experimental results are shown in Figure 2, where we can easily see that both CAT-CE and CAT-MIX clearly outperform other methods among  $\\epsilon$  from 0 to 0.07. So our methods can achieve better robust error at the standard  $8/255$  perturbation threshold considered in the literature, and also has better clean accuracy ( $\\epsilon = 0$ ). The accuracy curve becomes quite flat when  $\\epsilon$  is increased.",
+        "bbox": [
+            495,
+            785,
+            888,
+            891
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "header",
+        "text": "CAT: Customized Adversarial Training for Improved Robustness",
+        "bbox": [
+            279,
+            56,
+            692,
+            70
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/1c4d2f01ce585720b152e55130eeabcbc941f6aabcacf5684b30a4e5cc60a209.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            478,
+            256
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/120ac1d509e02b194040be43bb815d8499e10e1f15dd7c6319e424d8a18391d0.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            99,
+            799,
+            256
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0567bfc3c8e95caf1d3a1262baca3f87fd7603a507539ce381c4bef9b80d4bc0.jpg",
+        "image_caption": [
+            "Figure 2. Robust accuracy under different levels of attacks on CIFAR-10 dataset with VGG and Wide-ResNet architectures. CAT-CE and CAT-MIX clearly outperform TREADS and adversarial training."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            273,
+            478,
+            429
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/77c9729b839c41a556dcada1563ceccfcad0531a85f6867763c6fd7d06fcb403.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            273,
+            799,
+            429
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/d96b8eca2c54b4f217ef28d5d53d386dc4d2f5811cf235c8ec06b0e01f36a5ec.jpg",
+        "table_caption": [
+            "Table 3. The clean and robust accuracy of Wide Resnet models trained by various defense methods. All robust accuracy results use  $\\epsilon = 8 / 255\\ell_{\\infty}$  ball. We reported the best performance listed in the papers. (*) denotes random_restart is applied in the testing attack. (X) denotes it use a  $X$  step PGD attack"
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>Clean accuracy</td><td>PGD accuracy</td><td>C&amp;W accuracy</td></tr><tr><td>Natural training</td><td>95.93%</td><td>0%</td><td>0%</td></tr><tr><td>Adversarial training (Madry et al., 2018)</td><td>87.30%</td><td>52.68%</td><td>50.73%</td></tr><tr><td>Dynamic adversarial training (Wang et al., 2019)</td><td>84.51%</td><td>55.03%</td><td>51.98%</td></tr><tr><td>TRADES (Zhang et al., 2019b)</td><td>84.22%</td><td>56.40%(20)</td><td>51.98%</td></tr><tr><td>Bilateral Adv Training (Wang, 2019)</td><td>91.00%</td><td>57.5%(*20)</td><td>56.2%(*20)</td></tr><tr><td>MMA (Ding et al., 2018)</td><td>84.36%</td><td>47.18%</td><td>X</td></tr><tr><td>MART (Wang, 2020)</td><td>84.17%</td><td>58.56%(20)</td><td>54.58%</td></tr><tr><td>IAAT (Balaji et al., 2019)</td><td>91.34%</td><td>48.53%(*10)</td><td>56.80%</td></tr><tr><td>CAT-CE (ours)</td><td>93.48%</td><td>73.38%(*20)</td><td>61.88%(*20)</td></tr><tr><td>CAT-MIX (ours)</td><td>89.61%</td><td>73.16%(*20)</td><td>71.67%(*20)</td></tr></table>",
+        "bbox": [
+            138,
+            547,
+            836,
+            728
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/6dae5cd29db186cd3944814f86963461be571633d9cc85f825e956a47c71e198.jpg",
+        "image_caption": [
+            "(a) Natural"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            114,
+            763,
+            277,
+            857
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c09f87b4d89824a189272feac6e1dbcce79924ea99d8d83fa785df63931331c.jpg",
+        "image_caption": [
+            "(b) Adv train"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            312,
+            762,
+            475,
+            857
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b770add6287008acd7914be8488c8cb56bef839320b9bcae3ff4f8ee73118a1f.jpg",
+        "image_caption": [
+            "(c) TRADES",
+            "Figure 3. Loss landscape comparison of different adversarial training methods"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            511,
+            768,
+            674,
+            858
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c6f737ba5e111ea2851a2bd6f412075e71461d589e770d1db0ce00ff152b79ce.jpg",
+        "image_caption": [
+            "(d) CAT"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            702,
+            768,
+            874,
+            858
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "header",
+        "text": "CAT: Customized Adversarial Training for Improved Robustness",
+        "bbox": [
+            279,
+            56,
+            692,
+            70
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Wide ResNet has become a standard structure for comparing adversarial training methods, and it's standard to train and evaluate with  $8/255\\ell_{\\infty}$  norm perturbation. For this setting, we collect the reported accuracy from 7 other adversarial training methods, with several of them published very recently, to have a detailed full comparison. As shown in Table 3, our method achieves state-of-art robust accuracy while maintaining a high clean accuracy. Due to the page limit, we put the Restricted ImageNet result in the appendix.",
+        "bbox": [
+            84,
+            84,
+            475,
+            220
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Black-box transfer attacks. We follow the criterion of evaluating transfer attacks as suggested by Athalye et al. (2018) to inspect whether the models trained by CAT will cause the issue of obfuscated gradients and give a false sense of model robustness. We generate 10,000 adversarial examples of CIFAR-10 from natural models with  $\\epsilon = 0.03$  and evaluate their attack performance on the target model. Table 4 shows that CAT achieves the best accuracy compared with adversarial training and TRADES, suggesting the effectiveness of CAT in defending both white-box and transfer attacks.",
+        "bbox": [
+            84,
+            227,
+            477,
+            393
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/fb0aef8abb42fcc87878c2bf189afe27a0715ed5dcea35436c9bca55826bd86a.jpg",
+        "table_caption": [
+            "Table 4. Robust accuracy under transfer attack on CIFAR-10"
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>VGG 16</td><td>Wide ResNet</td></tr><tr><td>Adv train</td><td>79.13%</td><td>85.84%</td></tr><tr><td>TRADES</td><td>83.53%</td><td>83.90%</td></tr><tr><td>CAT</td><td>86.58%</td><td>88.66 %</td></tr></table>",
+        "bbox": [
+            143,
+            433,
+            413,
+            502
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3. Loss Landscape Exploration",
+        "text_level": 1,
+        "bbox": [
+            84,
+            532,
+            318,
+            547
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To further verify the superior robustness using CAT, we visualize the loss landscape of different training methods in Figure 3. Following the implementation in (Engstrom et al., 2018), we divide the data input along a linear space grid defined by the sign of the input gradient and a random Rademacher vector, where the x- and y- axes represent the magnitude of the perturbation added in each direction and the z-axis represents the loss.",
+        "bbox": [
+            84,
+            555,
+            473,
+            676
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 3, CAT generates a model with a lower and smoother loss landscape. Also, it could be taken as another strong evidence that we have found a robust model through CAT training.",
+        "bbox": [
+            84,
+            684,
+            473,
+            744
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4. Ablation study",
+        "text_level": 1,
+        "bbox": [
+            84,
+            761,
+            222,
+            776
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The importance of adaptive label uncertainty. Here we discuss and perform an ablation study using VGG-16 and CIFAR-10 on the importance of adaptive label uncertainty and adaptive instance-wise  $\\epsilon$ . In Figure 4b, Adp train denotes the original adversarial training, Adv+LS denotes adversarial training with label smoothing (setting  $y$  by Eq (4)), Adp-Adv denotes adversarial training with adaptive instance-wise  $\\epsilon$ , and CAT-CE is the proposed method",
+        "bbox": [
+            84,
+            784,
+            475,
+            905
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/75721312574a0fc7f380d4ee4d9bd1e0d7995038c8bacf9e5af8eaaf08946d14.jpg",
+        "image_caption": [
+            "(a)"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            535,
+            97,
+            848,
+            258
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/3dc2fb39cd86a67bd3f87e5047a9d95fb5d912effe65d37a7b1ee0a9f1f1d354.jpg",
+        "image_caption": [
+            "(b)",
+            "Figure 4. Analysis of CAT. In (a) we test CAT under different steps of PGD attack, and in (b) we conduct an ablation study on CAT by changing the loss function and removing Label Adaption (LA)."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            534,
+            292,
+            848,
+            452
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "which is a combination of these two tricks. We found that only applying adaptive instance-wise  $\\epsilon$  or label smoothing cannot significantly boost the robust accuracy over standard adversarial training, but the proposed method, by nicely combining these two ideas, can significantly improve the performance. This explains why CAT significantly outperforms some instance adaptive  $\\epsilon$  methods like IAAT and MMA.",
+        "bbox": [
+            495,
+            565,
+            885,
+            685
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "More iterations of PGD attack. As suggested in Athalye et al. (2018), to verify that the performance gain is not brought by insufficient iterations in PGD attack, in Figure 4a, we show the robust accuracy with the number of iteration varying from 10 to 500 on CIFAR10 VGG16. The results show that although increasing the number of iterations would decrease the performance by around  $2\\%$ , CAT always outperforms other methods significantly.",
+        "bbox": [
+            495,
+            694,
+            888,
+            815
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5. Conclusions",
+        "text_level": 1,
+        "bbox": [
+            496,
+            834,
+            624,
+            849
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose CAT, a customized adversarial training method that is designed to have better generalization for both clean and robust performance. We also provide",
+        "bbox": [
+            495,
+            859,
+            887,
+            905
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "header",
+        "text": "CAT: Customized Adversarial Training for Improved Robustness",
+        "bbox": [
+            279,
+            56,
+            692,
+            70
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "a theoretical analysis to motivate our algorithm. Experimental results show that CAT has achieved state-of-art robust accuracy and a high clean accuracy while keeping similar running time as standard adversarial training. The success of CAT indicates that it is crucial to customize the perturbation level on both data sample side and its label in adversarial training.",
+        "bbox": [
+            84,
+            84,
+            478,
+            191
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References",
+        "text_level": 1,
+        "bbox": [
+            86,
+            210,
+            181,
+            224
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Athalye, A., Carlini, N., and Wagner, D. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. International Coherence on International Conference on Machine Learning, 2018.",
+            "Balaji, Y., Goldstein, T., and Hoffman, J. Instance adaptive adversarial training: Improved accuracy tradeoffs in neural nets. arXiv preprint arXiv:1910.08051, 2019.",
+            "Brendel, W., Rauber, J., and Bethge, M. Decision-based adversarial attacks: Reliable attacks against black-box machine learning models. arXiv preprint arXiv:1712.04248, 2017.",
+            "Carlini, N. and Wagner, D. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy, pp. 39-57, 2017.",
+            "Chen, P.-Y., Zhang, H., Sharma, Y., Yi, J., and Hsieh, C.-J. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 15-26, 2017.",
+            "Cheng, M., Le, T., Chen, P.-Y., Yi, J., Zhang, H., and Hsieh, C.-J. Query-efficient hard-label black-box attack: An optimization-based approach. arXiv preprint arXiv:1807.04457, 2018.",
+            "Cheng, M., Singh, S., Chen, P., Chen, P.-Y., Liu, S., and Hsieh, C.-J. Sign-opt: A query-efficient hard-label adversarial attack. In ICLR, 2020.",
+            "Cohen, J. M., Rosenfeld, E., and Kolter, J. Z. Certified adversarial robustness via randomized smoothing. International Conference on Machine Learning, 2019.",
+            "Deng, J., Dong, W., Socher, R., Li, L.-J., Li, K., and Fei-Fei, L. Imagenet: A large-scale hierarchical image database. In IEEE Conference on Computer Vision and Pattern Recognition, pp. 248-255, 2009.",
+            "Ding, G. W., Sharma, Y., Lui, K. Y. C., and Huang, R. Max-margin adversarial (mma) training: Direct input space margin maximization through adversarial training. arXiv preprint arXiv:1812.02637, 2018."
+        ],
+        "bbox": [
+            86,
+            233,
+            475,
+            905
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Engstrom, L., Ilyas, A., and Athalye, A. Evaluating and understanding the robustness of adversarial logit pairing. arXiv preprint arXiv:1807.10272, 2018.",
+            "Eykholt, K., Evtimov, I., Fernandes, E., Li, B., Rahmati, A., Xiao, C., Prakash, A., Kohno, T., and Song, D. Robust physical-world attacks on deep learning visual classification. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1625-1634, 2018.",
+            "Gao, R., Cai, T., Li, H., Hsieh, C.-J., Wang, L., and Lee, J. D. Convergence of adversarial training in overparametrized neural networks. In Advances in Neural Information Processing Systems, pp. 13009-13020, 2019.",
+            "Goibert, M. and Dohmatob, E. Adversarial robustness via adversarial label-smoothing. arXiv preprint arXiv:1906.11567, 2019.",
+            "Goodfellow, I. J., Shlens, J., and Szegedy, C. Explaining and harnessing adversarial examples. International Conference on Learning Representations, 2015.",
+            "Ilyas, A., Engstrom, L., Athalye, A., and Lin, J. Black-box adversarial attacks with limited queries and information. arXiv preprint arXiv:1804.08598, 2018.",
+            "Krizhevsky, A., Nair, V., and Hinton, G. Cifar-10 (canadian institute for advanced research). URL http://www.cs.toronto.edu/~kriz/cifar.html.",
+            "Kurakin, A., Goodfellow, I., and Bengio, S. Adversarial machine learning at scale. International Conference on Learning Representations, 2017.",
+            "Liu, X., Cheng, M., Zhang, H., and Hsieh, C.-J. Towards robust neural networks via random self-ensemble. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 369-385, 2018.",
+            "Madry, A., Makelov, A., Schmidt, L., Tsipras, D., and Vladu, A. Towards deep learning models resistant to adversarial attacks. International Conference on Learning Representations, 2018.",
+            "Shafahi, A., Ghiasi, A., Huang, F., and Goldstein, T. Label smoothing and logit squeezing: A replacement for adversarial training? 2018.",
+            "Shafahi, A., Najibi, M., Ghiasi, A., Xu, Z., Dickerson, J., Studer, C., Davis, L. S., Taylor, G., and Goldstein, T. Adversarial training for free! Neural Information Processing Systems, 2019.",
+            "Simonyan, K. and Zisserman, A. Very deep convolutional networks for large-scale image recognition. International Conference on Learning Representations, 2015."
+        ],
+        "bbox": [
+            500,
+            84,
+            885,
+            905
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "header",
+        "text": "CAT: Customized Adversarial Training for Improved Robustness",
+        "bbox": [
+            279,
+            56,
+            692,
+            71
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Su, D., Zhang, H., Chen, H., Yi, J., Chen, P.-Y., and Gao, Y. Is robustness the cost of accuracy? a comprehensive study on the robustness of 18 deep image classification models. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 631-648, 2018.",
+            "Szegedy, C., Zaremba, W., Sutskever, I., Bruna, J., Erhan, D., Goodfellow, I., and Fergus, R. Intriguing properties of neural networks. International Conference on Learning Representations, 2014.",
+            "Szegedy, C., Vanhoucke, V., Ioffe, S., Shlens, J., and Wojna, Z. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818-2826, 2016.",
+            "Thulasidasan, S., Chennupati, G., Bilmes, J., Bhattacharya, T., and Michalak, S. On mixup training: Improved calibration and predictive uncertainty for deep neural networks. Neural Information Processing Systems, 2019.",
+            "Tsipras, D., Santurkar, S., Engstrom, L., Turner, A., and Madry, A. Robustness may be at odds with accuracy. In International Conference on Learning Representations, 2019.",
+            "Verma, V., Lamb, A., Beckham, C., Najafi, A., Mitliagkas, I., Courville, A., Lopez-Paz, D., and Bengio, Y. Manifold mixup: Better representations by interpolating hidden states. International Conference on Machine Learning, 2018.",
+            "Wang, J. Bilateral adversarial training: Towards fast training of more robust models against adversarial attacks. International Conference on Computer Vision, 2019.",
+            "Wang, Y., Ma, X., Bailey, J., Yi, J., Zhou, B., and Gu, Q. On the convergence and robustness of adversarial training. In International Conference on Machine Learning, pp. 6586-6595, 2019.",
+            "Wang, Zou, Y. B. M. G. Improving adversarial robustness requires revisiting misclassified examples. International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id=rk10g6EFwS.",
+            "Wei, C. and Ma, T. Improved sample complexities for deep networks and robust classification via an all-layer margin. arXiv preprint arXiv:1910.04284, 2019.",
+            "Wong, E., Rice, L., and Kolter, J. Z. Fast is better than free: Revisiting adversarial training. arXiv preprint arXiv:2001.03994, 2020.",
+            "Yin, D., Ramchandran, K., and Bartlett, P. Rademacher complexity for adversarially robust generalization. arXiv preprint arXiv:1810.11914, 2018."
+        ],
+        "bbox": [
+            86,
+            84,
+            475,
+            905
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Zantedeschi, V., Nicolae, M.-I., and Rawat, A. Efficient defenses against adversarial attacks. In ACM Workshop on Artificial Intelligence and Security, pp. 39-49, 2017.",
+            "Zhang, D., Zhang, T., Lu, Y., Zhu, Z., and Dong, B. You only propagate once: Accelerating adversarial training via maximal principle. In Advances in Neural Information Processing Systems, pp. 227-238, 2019a.",
+            "Zhang, H., Cisse, M., Dauphin, Y. N., and Lopez-Paz, D. mixup: Beyond empirical risk minimization. International Conference on Learning Representations, 2018.",
+            "Zhang, H., Yu, Y., Jiao, J., Xing, E. P., Ghaoui, L. E., and Jordan, M. I. Theoretically principled trade-off between robustness and accuracy. International Conference on Machine Learning, 2019b."
+        ],
+        "bbox": [
+            498,
+            84,
+            887,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "header",
+        "text": "CAT: Customized Adversarial Training for Improved Robustness",
+        "bbox": [
+            279,
+            56,
+            692,
+            71
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A. Omitted Proofs",
+        "text_level": 1,
+        "bbox": [
+            84,
+            83,
+            243,
+            99
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this section we provide the omitted proof for Theorem 3.2, which is adapted from Theorem 2.1 from (Wei & Ma, 2019). They defined the all layer margin for a  $k$ -layer network  $h_\\theta(\\boldsymbol{x}) = f_k \\circ f_{k-1} \\circ \\dots \\circ f_1(\\boldsymbol{x})$  and perturbation  $\\delta = (\\delta_1, \\delta_2, \\dots, \\delta_k)$  as follows:",
+        "bbox": [
+            84,
+            109,
+            888,
+            154
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nh _ {1} (\\boldsymbol {x}, \\delta) = f _ {1} (\\boldsymbol {x}) + \\delta_ {1} \\| \\boldsymbol {x} \\| _ {2}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            165,
+            522,
+            183
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nh _ {i} (\\boldsymbol {x}, \\delta) = f _ {i} \\left(h _ {i - 1} (\\boldsymbol {x}, \\delta)\\right) + \\delta_ {i} \\| h _ {i - 1} (\\boldsymbol {x}, \\delta) \\| _ {2}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            185,
+            638,
+            202
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nH _ {\\theta} (\\boldsymbol {x}, \\delta) = h _ {k} (\\boldsymbol {x}, \\delta).\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            204,
+            475,
+            220
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "They define the all-layer margin as the minimum norm of  $\\delta = (\\delta_{i})_{i=1}^{k}$  required that causes the classifier to make a false prediction.",
+        "bbox": [
+            84,
+            233,
+            885,
+            263
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nm _ {F} (\\boldsymbol {x}, y) := \\min  _ {\\boldsymbol {\\delta} ^ {i}, \\boldsymbol {\\delta} ^ {o}} \\sqrt {\\| \\boldsymbol {\\delta} ^ {i} \\| ^ {2} + \\| \\boldsymbol {\\delta} ^ {o} \\| ^ {2}} \\tag {8}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            263,
+            883,
+            296
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {s u b j e c t} \\max  _ {y ^ {\\prime}} H _ {\\theta} (\\boldsymbol {x}, \\boldsymbol {\\delta} ^ {i}, \\boldsymbol {\\delta} ^ {o}) _ {y ^ {\\prime}} \\neq y.\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            292,
+            653,
+            316
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "They consider the function class  $\\mathcal{F} = \\{f_k\\circ f_{k - 1}\\dots \\circ f_1:f_i\\in \\mathcal{F}_i\\}$  be the class of compositions of functions from function classes  $\\mathcal{F}_1,\\dots \\mathcal{F}_k$  . They achieve the generalization bound as follows:",
+        "bbox": [
+            84,
+            321,
+            885,
+            354
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Theorem A.1 (Theorem 2.1 from (Wei & Ma, 2019)) In the above setting, with probability  $1 - \\delta$  over the draw of the data, all classifiers  $F \\in \\mathcal{F}$  which achieve training error 0 satisfy",
+        "bbox": [
+            84,
+            364,
+            885,
+            397
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbb {E} [ f _ {\\theta} (\\pmb {x}) = y ] \\lesssim \\frac {\\sum_ {i} \\mathcal {C} _ {i} \\log^ {2} n}{\\sqrt {n}} \\sqrt {\\frac {1}{n} \\sum_ {i = 1} ^ {n} \\frac {1}{m _ {F} (\\pmb {x} _ {i} , y _ {i})}} + \\zeta ,\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            407,
+            674,
+            455
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where  $\\zeta$  is of small order  $O\\left(\\frac{1}{n}\\log (1 / \\delta)\\right)$ .",
+        "bbox": [
+            84,
+            465,
+            364,
+            484
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For our problem, we define  $h_\\theta(\\pmb{x}) \\coloneqq f_2 \\circ f_1(\\pmb{x})$ , where  $f_1$  is identity mapping, and  $f_2$  is the original function  $h_\\theta$ . Therefore the all layer margin is reduced to our bilateral margin:",
+        "bbox": [
+            84,
+            494,
+            888,
+            526
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\begin{array}{l} h _ {1} (\\boldsymbol {x}, \\boldsymbol {\\delta} ^ {i}) = f _ {1} (\\boldsymbol {x}) + \\boldsymbol {\\delta} ^ {i} \\| \\boldsymbol {x} \\| _ {2} = \\boldsymbol {x} + \\boldsymbol {\\delta} ^ {i} \\| \\boldsymbol {x} \\| \\\\ H _ {\\theta} (\\boldsymbol {x}, \\boldsymbol {\\delta}) = h _ {2} (\\boldsymbol {x}, \\boldsymbol {\\delta} ^ {i}, \\boldsymbol {\\delta} ^ {o}) = f _ {2} \\left(h _ {1} (\\boldsymbol {x}, \\boldsymbol {\\delta} ^ {i})\\right) + \\boldsymbol {\\delta} ^ {o} \\| h _ {1} (\\boldsymbol {x}, \\boldsymbol {\\delta} ^ {i}) \\| \\\\ = h _ {\\theta} \\left(\\boldsymbol {x} + \\delta^ {i} \\| \\boldsymbol {x} \\|\\right) + \\delta^ {o} \\| \\boldsymbol {x} + \\delta^ {i} \\| \\boldsymbol {x} \\| \\|. \\\\ \\end{array}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            535,
+            694,
+            595
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Next, notice since  $f_{1}$  is identity mapping, and composition with  $h_{\\theta}$  doesn't affect the overall complexity. We apply Theorem A.1 and get our result.",
+        "bbox": [
+            84,
+            606,
+            885,
+            638
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "header",
+        "text": "CAT: Customized Adversarial Training for Improved Robustness",
+        "bbox": [
+            279,
+            56,
+            692,
+            70
+        ],
+        "page_idx": 10
+    }
+]

2002.06xxx/2002.06789/742d8561-0e5e-4192-b15b-21fc92c86ee6_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b233d326a542a55db48fbf7499d938a1347b1983ee42a80eda4bb724ffb7cf7
+size 1778014

2002.06xxx/2002.06789/full.md

@@ -0,0 +1,365 @@
+# CAT: Customized Adversarial Training for Improved Robustness
+
+Minhao Cheng<sup>1</sup> Qi Lei<sup>2</sup> Pin-Yu Chen<sup>3</sup> Inderjit Dhillon<sup>2</sup> Cho-Jui Hsieh<sup>1</sup>
+
+# Abstract
+
+Adversarial training has become one of the most effective methods for improving robustness of neural networks. However, it often suffers from poor generalization on both clean and perturbed data. In this paper, we propose a new algorithm, named Customized Adversarial Training (CAT), which adaptively customizes the perturbation level and the corresponding label for each training sample in adversarial training. We show that the proposed algorithm achieves better clean and robust accuracy than previous adversarial training methods through extensive experiments.
+
+# 1. Introduction
+
+Deep neural networks (DNNs) have proved their effectiveness on a variety of domains and tasks. However, it has been found that DNNs are highly vulnerable to adversarial examples (Szegedy et al., 2014). To enhance the robustness of DNNs against adversarial examples, adversarial training (Goodfellow et al., 2015; Madry et al., 2018) has become one of the most effective and widely used methods. Given a pre-defined perturbation tolerance, denoted as  $\epsilon$ , adversarial training aims to minimize the robust loss, defined as the worst-case loss within  $\epsilon$ -ball around each example, leading to a min-max optimization problem. (Madry et al., 2018) show that applying a multi-step projected gradient descent (PGD) attack to approximately solve the inner maximization leads to a robust model, and several recent research has proposed various ways to improve adversarial training (Zhang et al., 2019b; Wang, 2019; Wang et al., 2019; Balaji et al., 2019; Ding et al., 2018).
+
+However, the standard adversarial training methods still have a hypothetical and possibly problematic assumption: the perturbation tolerance  $\epsilon$  is a large and fixed constant throughout the training process, which ignores the fact that every data point may have different intrinsic robustness.
+
+Intuitively, some examples are naturally closer to the decision boundary, and enforcing large margin on those examples will force the classifier to give up on those examples, leading to a distorted decision surface. This intuition may explain the known issue of the undesirable robustness-accuracy tradeoff in adversarial robustness (Su et al., 2018; Tsipras et al., 2019). Furthermore, with a different perturbation tolerance, it is questionable whether we should still force the model to learn to fit the one-hot label as in the original adversarial training formulation. In the extreme case, if an example is perturbed to the decision boundary, a good classifier yielding the binary class prediction probabilities should output  $[0.5, 0.5]$  instead of  $[1, 0]$ . This point becomes crucial when each example is associated with a different level of perturbation. Although some recent papers have started to address the uniform  $\epsilon$  issue by treating correctly and incorrectly classified examples differently (Ding et al., 2018) or assigning non-uniform perturbation level (Balaji et al., 2019), none of them have tried to incorporate the customized training labels in this process.
+
+Motivated by these ideas, we propose a novel Customized Adversarial Training (CAT) framework that can substantially improve the performance of adversarial training. Throughout the adversarial training process, our algorithm dynamically finds a non-uniform and effective perturbation level and the corresponding customized target label for each example. This leads to better generalization performance and furthermore, with a careful design on adaptive  $\epsilon$  tuning, our algorithm has only negligible computational overhead and runs as fast as the original adversarial training algorithm. Furthermore, we theoretically explain why the proposed method could lead to improved generalization performance.
+
+Our method significantly outperforms existing adversarial training methods on the standard CIFAR-10 defense task. With Wide-ResNet structure on CIFAR-10, under  $8/255\ell_{\infty}$  perturbation, our method achieves  $73\%$  robust accuracy under PGD attack and  $71\%$  robust accuracy under Carlini and Wagner (C&W) attack (Carlini & Wagner, 2017), while the current best model only achieves  $58.6\%$  under PGD attack and  $56.8\%$  under C&W attack. Furthermore, our method only degrades the clean accuracy from  $95.93\%$  (standard test accuracy) to  $93.48\%$ , while other adversarial training methods have clean accuracy below  $91.34\%$ .
+
+# 2. Related Work
+
+Adversarial attack. Finding adversarial examples, also known as adversarial attacks, can be formulated as an optimization problem — the goal is to find the perturbation  $\delta$  to maximize the (robust) loss, while constraining  $\delta$  to have small norm (e.g.,  $\ell_p$  norm). Therefore gradient-based algorithms have been widely used, such as fast gradient sign method (FGSM) (Goodfellow et al., 2015), C&W attack (Carlini & Wagner, 2017) and PGD attack (Madry et al., 2018). In addition to white-box attacks, it has been also found that adversarial attacks can be generated also in the soft-label black box setting (Chen et al., 2017; Ilyas et al., 2018) and hard-label black box setting (Brendel et al., 2017; Cheng et al., 2018; 2020), and with similar quality to white-box attacks. Moreover, physical attacks have been proposed to generate adversarial examples in the real world (Eykholt et al., 2018). Therefore, with the existence of these powerful adversarial attacks, how to enhance the robustness of neural network models has become an important issue in many real world applications.
+
+Adversarial training. To enhance the adversarial robustness of a neural network model, a natural idea is to iteratively generate adversarial examples, add them back to the training data, and retrain the model. For example, Goodfellow et al. (2015) use adversarial examples generated by FGSM to augment the data, and Kurakin et al. (2017) propose to use a multiple-step FGSM to further improve the performance. Madry et al. (2018) show that adversarial training can be formulated as a min-max optimization problem, and propose to use PGD attack (similar to multi-step FGSM) to find adversarial examples for each batch. The resulting method achieves notable successes and can survive even under strong attacks (Athalye et al., 2018). After that, many defense algorithms are based on a similar min-max framework. Zhang et al. (2019b) propose TRADES, a theoretically-driven upper bound minimization algorithm to achieve the top-1 rank in NeurIPS 2018 defense competition. Recently, Ding et al. (2018) notice the importance of misclassified examples and treat correctly classified and misclassified examples differently. Wang (2020) use label prediction probability as a smooth way to combine correctly and misclassified samples. Other than just adding adversarial examples into the training process, Wang (2019) find that it is also effective to find the "adversarial label" along with the "adversarial perturbation". The convergence of adversarial training has also been studied (Gao et al., 2019; Wang et al., 2019). Recently, to reduce the computational overhead brought by adversarial training, several works have been proposed (Shafahi et al., 2019; Zhang et al., 2019a; Wong et al., 2020). It is widely recognized that the current defensive models are still not ideal and have considerable room for improvement. Moreover, to make robust models
+
+useful in practice, it is crucial that both clean and robust error need to be further enhanced.
+
+Other adversarial defenses In addition to adversarial training based methods, a wide range of defense methods have been proposed such as Gaussian data augmentation (Zantedeschi et al., 2017), randomized smoothing (Liu et al., 2018; Cohen et al., 2019), Mixup (Zhang et al., 2018) and its variants (Thulasidasan et al., 2019; Verma et al., 2018), and Label smoothing (Shafahi et al., 2018; Goibert & Dohmatob, 2019). Shafahi et al. (2018) find that it could achieve similar robust accuracy with adversarial training when combining Gaussian data augmentation and label-smoothing.
+
+However, some of the aforementioned methods have been shown to cause obfuscated gradients instead of enhanced robustness (Athalye et al., 2018), while adversarial training based methods are still shown to be robust under different kinds of adversarial attacks.
+
+# 3. Proposed Method
+
+# 3.1. Preliminaries
+
+Adversarial training can be formulated as a min-max optimization problem. For a  $K$ -class classification problem, let  $\mathcal{D} = \{(\pmb{x}_i,y_i)\}_{i = 1,\dots ,n}$  denote the set of training samples in the dataset with  $\pmb {x}_i\in \mathbb{R}^d$ $y_{i}\in \{1,\ldots ,K\} = :[K]$ . Let  $f_{\theta}(\pmb {x}):\mathbb{R}^{d}\to [K]$  denote a classification model parameterized by  $\theta$ . We denote by  $h_\theta (\pmb {x}):\mathbb{R}^d\rightarrow [0,1]^K$  as the prediction output for each class, i.e.,  $f_{\theta}(\pmb {x}) = \mathrm{argmax}_i[h_\theta (\pmb {x})]_i$ . We use standard  $O(\cdot)$  notation to hide universal constant factor, and  $a\lesssim b$  to indicate  $a = O(b)$ .
+
+Adversarial training can be formulated as:
+
+$$
+\min  _ {\theta} \frac {1}{n} \sum_ {i = 1} ^ {n} \max  _ {\boldsymbol {x} _ {i} ^ {\prime} \in \mathcal {B} (\boldsymbol {x} _ {i}, \epsilon)} \ell \left(f _ {\theta} \left(\boldsymbol {x} _ {i} ^ {\prime}\right), y _ {i}\right), \tag {1}
+$$
+
+where  $\mathcal{B}(\pmb{x}_i, \epsilon)$  denotes the  $\ell_p$ -norm ball centered at  $\pmb{x}_i$  with radius  $\epsilon$ . The inner maximization problem aims to find an adversarial version of a given data point  $\pmb{x}_i$  that achieves a high loss. In general one can define  $\mathcal{B}(\pmb{x}_i, \epsilon)$  based on the threat model, but the  $\ell_{\infty}$  ball is the most popular choice adopted by recent works (Madry et al., 2018; Zhang et al., 2019b; Wang, 2019; Ding et al., 2018; Wang, 2020), which will also be used in this paper. For a deep neural network model, the inner maximization does not have a closed form solution, so adversarial training methods typically use a gradient-based iterative solver to approximately solve the inner problem. The most commonly used choice is the multi-step PGD (Madry et al., 2018) and C&W attack (Carlini & Wagner, 2017).
+
+![](images/2cd82c6c381d3c6f90da287502a833cb4c96d5c6194adcc46a2e07e1bbfb85f3.jpg)  
+(a) Standard training
+
+![](images/f8aec5384bd9578539c3c4480f5726e7e985f0d7fee16a562a753639ada78da6.jpg)  
+(b) Adv-train with  $\epsilon = 1$
+
+![](images/21e7760168b3a7b88302180bb40a6c5e5c61b8cf83e84ea55fefb0b38e8f7638.jpg)  
+(c) Adv-train with  $\epsilon = 4$  
+Figure 1. Different training methods on a linearly separable binary classification dataset with 1.75 margin for both classes. Adversarial training with small  $\epsilon$  works fine, but for a large  $\epsilon$  beyond the true margin, adversarial training would ruin the classifier's classification performance, while our proposed adaptive customized adversarial training method still keeps a good generalization performance.
+
+![](images/0951df86790934bc6aae77d8f84521e3e83bdda00a616ad07625ab514c1fd11b.jpg)  
+(d) CAT (ours) with  $\epsilon_{max} = 4$
+
+# 3.2. Motivation
+
+Intuitively, if adversarial training can always find a model with close-to-zero robust error, one should always use a large  $\epsilon$  for training because it will automatically imply robustness to any smaller  $\epsilon$ . Unfortunately, in practice a uniformly large  $\epsilon$  is often harmful. In the following we empirically explain this problem and use it to motivate our proposed algorithm.
+
+We use a simple linear classification case to demonstrate why a uniformly large  $\epsilon$  is harmful. In Figure 1a, we generate a synthetic linearly separable dataset with the margin set to be 1.75 for both classes, and the correct linear boundary can be easily obtained by standard training. In Figure 1b, we run adversarial training with  $\epsilon = 1$ , and since this  $\epsilon$  is smaller than the margin, the algorithm can still obtain near-optimal results. However, when we use a large  $\epsilon = 4$  for adversarial training in Figure 1c, the resulting decision boundary becomes significantly worse. It is because adversarial training cannot correctly fit all the samples with a margin up to 4, so it will sacrifice some data samples, leading to distorted and undesirable decision boundary. This motivates the following two problems:
+
+- We shouldn't set the same large  $\epsilon$  uniformly for all samples. Some samples are intrinsically closer to the decision boundary and they should use a smaller  $\epsilon$ . Without doing this, adversarial training will give up on those samples, which leads to worse training and generalization error (see more discussions in Section 3.5 on the generalization bounds).  
+- The adversarial training loss is trying to force the prediction to match the one-hot label (e.g., [1, 0] in the binary classification case) even after large perturbations. However, if a sample is perturbed, the prediction shouldn't remain one-hot. For instance, if a sample is perturbed to the decision boundary, the prediction of a perfect model should be  $[0.5, 0.5]$  instead of  $[1, 0]$ .
+
+This also makes adversarial training fail to recover a good decision hyperplane.
+
+Furthermore, we observe that even if adversarial training can obtain close-to-zero training error with large  $\epsilon$  (e.g., (Gao et al., 2019) proves that this will happen for overparameterized network with large-enough margin), a uniformly large  $\epsilon$  will lead to larger generalization gap. This could be partially explained by the theoretical results provided by (Yin et al., 2018), which shows that the adversarial Rademacher complexity has a lower bound with an explicit dependence on the perturbation tolerance. The empirical results in Table 1 also illustrate this problem. When conducting adversarial training with  $\epsilon = 0.3$  on CIFAR10 VGG-16, we found that the model achieves close-to-zero robust training error on all  $\epsilon \leq 0.3$ , but it suffers larger generalization gap compared to training with smaller  $\epsilon$ . This also demonstrates that a uniformly large  $\epsilon$  is harmful even when it achieves perfect training error.
+
+Table 1. The influence of different fixed  $\epsilon$  values used in adversarial training on the robust accuracy with  $\epsilon = {0.01}$  .  
+
+<table><tr><td rowspan="2">Testing ε</td><td rowspan="2">Error Type</td><td colspan="3">Training ε</td></tr><tr><td>0.01</td><td>0.02</td><td>0.03</td></tr><tr><td rowspan="2">0.01</td><td>Train</td><td>99.96%</td><td>99.99%</td><td>99.16%</td></tr><tr><td>Test</td><td>69.79%</td><td>69.06%</td><td>66.04%</td></tr></table>
+
+CAT (Customized Adversarial Training) We propose the Customized Adversarial Training (CAT) framework that improves adversarial training by addressing the above-mentioned problems. First, our algorithm has an auto-tuning  $\epsilon$  method to customize the  $\epsilon$  used for each training example. Second, instead of forcing the model to fit the original label, we customize the target label for each example based on its own  $\epsilon$ . In the following we will describe these two components in more detail.
+
+# 3.3. Auto-tuning  $\epsilon$  for adversarial training
+
+The first component of our algorithm is an auto-tuning  $\epsilon$  tuning method which adaptively assigns a suitable  $\epsilon$  for each sample during the adversarial training procedure. Let  $\epsilon_{i}$  be the perturbation level assigned to example  $i$ . Based on the intuition mentioned in Section 3.2, we do not want to further increase  $\epsilon$  if we find the classifier does not have capacity to robustly classify the example, which means we should set
+
+$$
+\epsilon_ {i} = \underset {\epsilon} {\operatorname {a r g m i n}} \left\{\max  _ {\boldsymbol {x} _ {i} ^ {\prime} \in \mathcal {B} \left(\boldsymbol {x} _ {i}, \epsilon\right)} f _ {\theta} \left(\boldsymbol {x} _ {i} ^ {\prime}\right) \neq y _ {i} \right\} \tag {2}
+$$
+
+and the adversarial training objective becomes
+
+$$
+\min  _ {\theta} \frac {1}{n} \sum_ {i = 1} ^ {n} \max  _ {\boldsymbol {x} _ {i} ^ {\prime} \in \mathcal {B} \left(\boldsymbol {x} _ {i}, \epsilon_ {i}\right)} \ell \left(f _ {\theta} \left(\boldsymbol {x} _ {i} ^ {\prime}\right), y _ {i}\right). \tag {3}
+$$
+
+Note that  $\epsilon_{i}$  in (2) depends on  $\theta$  while  $\theta$  in (3) also depends on  $\epsilon_{i}$ . We thus propose to conduct alternative updates — conducting one SGD update on  $\theta$ , and then update the  $\epsilon_{i}$  in the current batch. However, finding  $\epsilon_{i}$  exactly requires brute-force search for every possible value, which adds significant computational overhead to adversarial training. Therefore, we only conduct a simplified update rule on  $\epsilon_{i}$  as follows. Starting from an initial perturbation level of zero, at each iteration we conduct adversarial attack (e.g., PGD attack) with perturbation tolerance  $\epsilon_{i} + \eta$  where  $\eta$  is a constant. If the attack is successful, then we keep the current  $\epsilon_{i}$ , while if the attack is unsuccessful, which means an attacker still cannot find an adversarial example that satisfies  $\max_{\boldsymbol{x}_i' \in \mathcal{B}(\boldsymbol{x}_i, \epsilon_i + \eta)} f_\theta(\boldsymbol{x}_i') \neq y_i$ , then we increase  $\epsilon_{i} = \epsilon_{i} + \eta$ . The attack results will also be used to update the model parameter  $\theta$ , so this adaptive scheme does not require any additional cost. In practice, we also have an upper bound on the final perturbation to make sure each individual  $\epsilon_{i}$  will not be too large.
+
+# 3.4. Adaptive label uncertainty for adversarial training
+
+As mentioned in Section 3.2, the standard adversarial training loss is trying to enforce a sample being classified as the original one-hot label after  $\epsilon$  perturbation. However, this may not be ideal. In the extreme case, if a sample is perturbed to the decision boundary, the prediction must be far away from one-hot. This problem is more severe when using non-uniform  $\epsilon_{i}$ , since each different  $\epsilon_{i}$  will introduce a different bias to the loss, and that may be one of the reasons that purely adaptive  $\epsilon$ -scheduling does not work well (see our ablation study in Section 4.4 and also the results reported in (Balaji et al., 2019)).
+
+In the following, we propose an adaptive label smoothing approach to reflect different perturbation tolerance on each example. Szegedy et al. (2016) introduced label smoothing that converts one-hot label vectors into one-warm vectors representing low-confidence classification, in order to
+
+prevent the model from making over-confident predictions. Specifically, with a one-hot encoded label  $y$ , the smoothed version is
+
+$$
+\tilde {y} = (1 - \alpha) y + \alpha u
+$$
+
+where  $\alpha \in [0,1]$  is the hyperparameter to control the smoothing level. In the adaptive setting, we set  $\alpha = c*\epsilon_{i}$  so that a larger perturbation tolerance would receive a higher label uncertainty and  $c$  is a hyperparameter. A common choice of  $u$  is the uniform distribution  $u = \frac{1}{K}$ . To further prevent over-fitting and improve the generalization, we use  $u = \operatorname{Dirichlet}(\mathbf{1})$  where  $\operatorname{Dirichlet}(\cdot)$  refers to the Dirichlet distribution and  $\mathbf{1} \in \mathbb{R}^{K}$  is an all one vector. With different perturbation tolerance, the adaptive version of label smoothing is
+
+$$
+\tilde {y} _ {i} = \left(1 - c \epsilon_ {i}\right) y _ {i} + c \epsilon_ {i} \text {D i r i c h l e t} (\mathbf {1}). \tag {4}
+$$
+
+The final objective function: Combining the two aforementioned two main techniques, our Customized Adversarial Training (CAT) method attempts to minimize the following objective:
+
+$$
+\min  _ {\theta} \frac {1}{n} \sum_ {i = 1} ^ {n} \max  _ {\boldsymbol {x} _ {i} ^ {\prime} \in \mathcal {B} \left(\boldsymbol {x} _ {i}, \epsilon_ {i}\right)} \ell \left(f _ {\theta} \left(\boldsymbol {x} _ {i} ^ {\prime}\right), \tilde {\boldsymbol {y}} _ {i}\right) \tag {5}
+$$
+
+$$
+\mathbf{s.t.} \epsilon_ {i} = \underset {\epsilon} {\operatorname {a r g m i n}} \left\{\max  _ {\boldsymbol {x} _ {i} ^ {\prime} \in \mathcal {B} (\boldsymbol {x} _ {i}, \epsilon)} f _ {\theta} \left(\boldsymbol {x} _ {i} ^ {\prime}\right) \neq y _ {i} \right\}
+$$
+
+where  $\tilde{y}_i$  is defined in (4). As described in Section 3.3, we approximately minimize this objective with an alternative update scheme, which encounters almost no additional cost compared to the original adversarial training algorithm. The detailed algorithm is shown in Algorithm 1.
+
+Choice of loss function. In general, our framework can be used with any loss function  $\ell(\cdot)$ . In the previous works, cross entropy loss is commonly used for  $\ell$ . However, the model trained by smoothing techniques tends to have better performance against PGD attack than  $\mathrm{C\&W_{\infty}}$  attack (see the VGG experiments in Figure 2. So in addition to testing our algorithm under cross entropy loss, we also propose a mixed loss to enhance the defense performance towards  $\mathrm{C\&W_{\infty}}$  attack. That is,
+
+$$
+\operatorname {C E} \left(x _ {i}, \tilde {y} _ {i}\right) + \max  \left\{\left[ \max  _ {i \neq y _ {0}} [ Z (\boldsymbol {x}) ] _ {i} - [ Z (\boldsymbol {x}) ] _ {y _ {0}}, - \kappa \right\}, \right. \tag {6}
+$$
+
+where  $Z(\pmb{x}) \in \mathbb{R}^{K}$  is the final (logit) layer output, and  $[Z(\pmb{x})]_i$  is the prediction score for the i-th class and  $y_{0}$  is the original label. The parameter  $\kappa$  encourages to find an adversary that will not classify as class  $y_{0}$  with high confidence.
+
+# 3.5. Theoretical Analysis
+
+To better understand how our scheme improves generalization, we provide some theoretical analysis. Recall we denote
+
+# Algorithm 1 CAT algorithm
+
+Input: Training dataset  $(X,Y)$ , cross entropy loss or mix loss  $\ell$ , scheduling parameter  $\eta$ , weighting factor  $c$ , perturbation upperbound  $\epsilon_{max}$   
+Initial every sample's  $\epsilon_i$  with 0  
+for epoch=1,...,N do  
+    for i=1,...,B do  
+         $\tilde{y}_i \gets (1 - c\epsilon_i)y_i + (1 - c\epsilon_i)\text{Dirichlet}(1)$ $\epsilon_i \gets \epsilon_i + \eta$ $\delta_i \gets 0$   
+    for  $j = 1\dots m$  do  
+         $\delta_i \gets \delta_i + \alpha \cdot sign(\nabla_\delta \ell(f_\theta(\boldsymbol{x}_i + \delta_i),\tilde{y}_i))$ $\delta_i \gets \max(\min(\delta_i,\epsilon_i),-\epsilon_i)$   
+    end for  
+    if  $f_\theta(\boldsymbol{x}_i + \delta_i) \neq y_i$  then  
+         $\epsilon_i \gets \epsilon_i - \eta$   
+    end if  
+     $\epsilon_i \gets \min(\epsilon_{max},\epsilon_i)$ $\tilde{y}_i \gets (1 - c\epsilon_i)y_i + (1 - c\epsilon_i)\text{Dirichlet}(1)$ $\theta \gets \theta - \gamma_\theta\nabla_\theta\ell(f_\theta(\boldsymbol{x}_i + \delta_i),\tilde{y}_i)$   
+end for  
+end for  
+return  $\theta$
+
+by  $h_{\theta}(\pmb{x}) : \mathbb{R}^d \to [0,1]^K$  as the prediction probability for the  $K$  classes. We define the bilateral margin that our paper is essentially maximizing over as follows.
+
+Definition 3.1 (Bilateral margin) We define the bilateral perturbed network output by  $H_{\theta}(\boldsymbol{x}, \boldsymbol{\delta}^i, \boldsymbol{\delta}^o)$ :
+
+$$
+H _ {\theta} (\boldsymbol {x}, \boldsymbol {\delta} ^ {i}, \boldsymbol {\delta} ^ {o}) := h _ {\theta} \left(\boldsymbol {x} + \boldsymbol {\delta} ^ {i} \| \boldsymbol {x} \|\right) + \boldsymbol {\delta} ^ {o} \left\| \boldsymbol {x} + \boldsymbol {\delta} ^ {i} \| \boldsymbol {x} \| \right\|.
+$$
+
+The bilateral margin is now defined as the minimum norm of  $(\delta^i,\delta^o)$  required to cause the classifier to make false predictions:
+
+$m_{F}(\pmb {x},y)\coloneqq \min_{\pmb{\delta}^{i},\pmb{\delta}^{o}}\sqrt{\|\pmb{\delta}^{i}\|^{2} + \|\pmb{\delta}^{o}\|^{2}}$  subject to  $\max_{y^{\prime}}H_{\theta}(\pmb {x},\pmb{\delta}^{i},\pmb{\delta}^{o})_{y^{\prime}}\neq y.$  (7)
+
+This margin captures both the relative perturbation on the input layer  $\delta^i$  and on the soft-max output  $\delta^o$ .
+
+Theorem 3.2 Suppose the parameter space  $\Theta$  we optimize over has covering number that scales as  $\log \mathcal{N}_{\| \cdot \|_{op}}(\eta ,\Theta)\leq \lfloor \mathcal{C}^2 /\eta^2\rfloor$  for some complexity  $\mathcal{C}$ . Then with probability  $1 - \delta$  over the draw of the training data, any classifier  $f_{\theta},\theta \in \Theta$  which achieves training error O satisfies:
+
+$$
+\mathbb {E} [ f _ {\theta} (\boldsymbol {x}) = y ] \lesssim \frac {\mathcal {C} \log^ {2} n}{\sqrt {n}} \sqrt {\frac {1}{n} \sum_ {i = 1} ^ {n} \frac {1}{m _ {F} (\boldsymbol {x} _ {i} , y _ {i})}} + \zeta ,
+$$
+
+where  $\zeta$  is of small order  $O\left(\frac{1}{n}\log (1 / \delta)\right)$
+
+We defer the proof to the Appendix, which is adapted from Theorem 2.1 of (Wei & Ma, 2019). We observe the population risk is bounded by two key factors, the average of  $\frac{1}{m_F(\boldsymbol{x}_i,y_i)}$  and  $\mathcal{C}$ , the covering number of the parameter space. On one side, the average of  $\frac{1}{m_F(\boldsymbol{x}_i,y_i)}$  is dominated by the samples with the smallest margin. Therefore when we do adversarial training, it is important that we not only achieve higher overall accuracy, but also make sure the samples closer to the decision boundary have large enough margin. This can not be achieved by simply using constant and large  $\epsilon$  that will maintain a large margin for most samples but sacrifice the accuracy of a small portion of data. On the other hand, the covering number of the network's parameter space can be roughly captured by a bound of product of all layers' weight norms. We hypothesize that with more flexibility in choosing  $\epsilon$ , our algorithm will converge faster than using larger constant  $\epsilon$  and will have more implicit regularization effect. To testify this hypothesis, we roughly measure the model complexity  $\mathcal{C}$  by the product of the weight norms of different models. In comparison to our model, when training with constant  $\epsilon = 0.01$ , 0.02 and 0.03, it respectively yields  $\mathcal{C}$  as large as 2.54, 3.53 and 1.39 times of that of our model, which means our model indeed has more implicit regularization effect among others.
+
+# 3.6. Connections with other training methods
+
+Many recent papers attempt to improve adversarial training. Although they all follow the similar min-max framework, each of them uses slightly different loss functions. We summarize the loss functions used by recent adversarial training methods in Table 2.
+
+We see that except for natural training which directly minimizes the cross entropy loss (denoted as CE), all training techniques involve the use of the min-max framework. TRADES and MMA use the unperturbed data's cross entropy loss as an additional regularization term to achieve a better trade-off between clean and robust error.
+
+Similar to our method, both MMA and IAAT have samplewise adaptive  $\epsilon$  during training. They also utilize the adaptive  $\epsilon$  to find the largest possible  $\epsilon_{i}$  for every sample  $x_{i}$ . However, they do not consider the adaptive label technique mentioned in Section 3.4. As a result, they can only achieve better clean accuracy while the improvements in robust accuracy is limited. Our CAT-CE algorithm (CAT with CE loss) is more general than IAAT and MMA. CAT-CE reduce to IAAT when we set  $c = 0$  in adaptive label smoothing. Moreover, MMA could be treated as a special case of CAT-CE when we use a line search scheme to find the  $\epsilon_{i}$  and  $c = 0$ . Also, in Section 4.4, we will show the importance of the adaptive label uncertainty step in CAT.
+
+Table 2. Summary of several robust training methods and their corresponding loss function. Dirichlet(b) indicates the Dirichlet distribution parameterized by b.  
+
+<table><tr><td>Methods</td><td>Loss Function</td></tr><tr><td>Natural</td><td>CE(fθ(x),y)</td></tr><tr><td>Adversarial training (Madry et al., 2018)</td><td>maxx&#x27;∈B(x,ε) CE(fθ(x&#x27;),y)</td></tr><tr><td>TRADES (Zhang et al., 2019b)</td><td>CE(fθ(x),y) + maxx&#x27;∈B(x,ε) KL(fθ(x&#x27;),fθ(x))</td></tr><tr><td>Bilateral Adv Training (Wang, 2019)</td><td>maxx&#x27;∈B(x,ε),y&#x27;∈Δ CE(fθ(x&#x27;),y&#x27;)</td></tr><tr><td>MMA (Ding et al., 2018)</td><td>CE(fθ(x))1(fθ(x)≠y) + (maxx&#x27;∈B(x,ε) CE(fθ(x&#x27;),y))1(fθ(x)=y)</td></tr><tr><td>MART (Wang, 2020)</td><td>maxx&#x27;∈B(x,ε) BCE(fθ(x&#x27;),y) + KL(fθ(x&#x27;),fθ(x))·(1-fθ(x))</td></tr><tr><td>IAAT (Balaji et al., 2019)</td><td>maxx&#x27;∈B(xi,εi) CE(fθ(x&#x27;),yi)</td></tr><tr><td>CAT-CE (ours)</td><td>maxx&#x27;∈B(xi,εi) CE(fθ(x&#x27;),(1-cεi)y_i+ cεiDirichlet(1))</td></tr><tr><td>CAT-MIX (ours)</td><td>maxx&#x27;∈B(xi,εi) CE(x&#x27;, (1-cεi)y_i+ cεiDirichlet(1)) + maxj≠y_0[Z(x&#x27;)j-[Z(x&#x27;)j]y_0</td></tr></table>
+
+# 4. Performance Evaluation
+
+In this section, we conduct extensive experiments to show that CAT achieves a strong result on both clean and robust accuracy. We include the following methods into our comparison:
+
+- Customized Adversarial Training (CAT-CE): Our proposed method with the cross entropy loss.  
+- Customized Adversarial Training (CAT-MIX): Our proposed method with the mixed cross entropy loss (6).  
+- Adversarial training: The adversarial training method proposed in (Madry et al., 2018) where they use a K-step PGD attack as adversary.  
+- TRADES: TRADES (Zhang et al., 2019b) improves adversarial training by an additional loss on the clean examples and achieves the state-of-art performance on robust accuracy.  
+- Natural: the natural training which only minimizes the cross entropy loss.
+
+Furthermore, since many recently proposed adversarial training methods have considered CIFAR-10 with Wide-ResNet structure as the standard setting and report their numbers, we also compare our performance with 7 previous methods on this specific setting.
+
+# 4.1. Experimental Setup
+
+Dataset and model structure. We use two popular dataset CIFAR-10 (Krizhevsky et al.) and Restricted-ImageNet (Deng et al., 2009) for performance evaluation. For CIFAR-10, we use both standard VGG-16 (Simonyan & Zisserman, 2015) and Wide ResNet that is used in both vanilla adversarial training (Madry et al., 2018) and TRADES (Zhang et al., 2019b). For VGG-16, we implement adversarial training with the standard hyperparameters and train TRADES with the official implementation. For Wide ResNet, since the model has become standard for testing adversarial training methods, we use exactly the same model structure provided by (Madry et al., 2018;
+
+Zhang et al., 2019b). And use the models' checkpoint released by adversarial training and TRADES official repository and implement the Madry's adversarial training using the standard hyper-parameters. For Restricted-ImageNet, we use ResNet-50. All our experiments were implemented in Pytorch-1.4 and conducted using dual Intel E5-2640 v4 CPUs (2.40GHz) with 512 GB memory with a GTX 2080 TI GPU.
+
+Implementation details. We set the number of iterations in adversarial attack to be 10 for all methods. Adversarial training and TRADES are trained on PGD attacks setting  $\epsilon = 8 / 255$  with cross entropy loss (CE). We implement our CAT method both on cross entropy (CE) (Madry et al., 2018) and C&W loss (Carlini & Wagner, 2017), and set  $\epsilon_{\mathrm{max}} = 8 / 255$ . All the models are trained using SGD with momentum 0.9, weight decay  $5 \times 10^{-4}$ . For VGG-16/Wide ResNet models, we use the initial learning rate of 0.01/0.1, and we decay the learning rate by  $90\%$  at the 80th, 140th, and 180th epoch. For CAT, we set epsilon scheduling parameter  $\eta = 0.005$ ,  $\epsilon_{\mathrm{max}} = 8 / 255$  and weighting parameter  $c = 10$ . For CAT-MIX, we set  $\kappa = 10$ .
+
+# 4.2. Robustness Evaluation and Analysis
+
+White-box attacks. For CIFAR10, we evaluate all the models under different tolerance of white-box  $\ell_{\infty}$ -norm bounded non-targeted PGD and C&W attack. Specifically, we use both  $\mathrm{PGD}^{20}$  (20-step PGD with step size  $\epsilon / 5$ ) and C&W $_{\infty}$ . All attacks are equipped with random-start. To be noted, when  $\epsilon = 0$ , the robust accuracy is reduced to test accuracy of unperturbed (natural) test samples, i.e clean accuracy.
+
+The experimental results are shown in Figure 2, where we can easily see that both CAT-CE and CAT-MIX clearly outperform other methods among  $\epsilon$  from 0 to 0.07. So our methods can achieve better robust error at the standard  $8/255$  perturbation threshold considered in the literature, and also has better clean accuracy ( $\epsilon = 0$ ). The accuracy curve becomes quite flat when  $\epsilon$  is increased.
+
+![](images/1c4d2f01ce585720b152e55130eeabcbc941f6aabcacf5684b30a4e5cc60a209.jpg)
+
+![](images/120ac1d509e02b194040be43bb815d8499e10e1f15dd7c6319e424d8a18391d0.jpg)
+
+![](images/0567bfc3c8e95caf1d3a1262baca3f87fd7603a507539ce381c4bef9b80d4bc0.jpg)  
+Figure 2. Robust accuracy under different levels of attacks on CIFAR-10 dataset with VGG and Wide-ResNet architectures. CAT-CE and CAT-MIX clearly outperform TREADS and adversarial training.
+
+![](images/77c9729b839c41a556dcada1563ceccfcad0531a85f6867763c6fd7d06fcb403.jpg)
+
+Table 3. The clean and robust accuracy of Wide Resnet models trained by various defense methods. All robust accuracy results use  $\epsilon = 8 / 255\ell_{\infty}$  ball. We reported the best performance listed in the papers. (*) denotes random_restart is applied in the testing attack. (X) denotes it use a  $X$  step PGD attack  
+
+<table><tr><td>Methods</td><td>Clean accuracy</td><td>PGD accuracy</td><td>C&amp;W accuracy</td></tr><tr><td>Natural training</td><td>95.93%</td><td>0%</td><td>0%</td></tr><tr><td>Adversarial training (Madry et al., 2018)</td><td>87.30%</td><td>52.68%</td><td>50.73%</td></tr><tr><td>Dynamic adversarial training (Wang et al., 2019)</td><td>84.51%</td><td>55.03%</td><td>51.98%</td></tr><tr><td>TRADES (Zhang et al., 2019b)</td><td>84.22%</td><td>56.40%(20)</td><td>51.98%</td></tr><tr><td>Bilateral Adv Training (Wang, 2019)</td><td>91.00%</td><td>57.5%(*20)</td><td>56.2%(*20)</td></tr><tr><td>MMA (Ding et al., 2018)</td><td>84.36%</td><td>47.18%</td><td>X</td></tr><tr><td>MART (Wang, 2020)</td><td>84.17%</td><td>58.56%(20)</td><td>54.58%</td></tr><tr><td>IAAT (Balaji et al., 2019)</td><td>91.34%</td><td>48.53%(*10)</td><td>56.80%</td></tr><tr><td>CAT-CE (ours)</td><td>93.48%</td><td>73.38%(*20)</td><td>61.88%(*20)</td></tr><tr><td>CAT-MIX (ours)</td><td>89.61%</td><td>73.16%(*20)</td><td>71.67%(*20)</td></tr></table>
+
+![](images/6dae5cd29db186cd3944814f86963461be571633d9cc85f825e956a47c71e198.jpg)  
+(a) Natural
+
+![](images/7c09f87b4d89824a189272feac6e1dbcce79924ea99d8d83fa785df63931331c.jpg)  
+(b) Adv train
+
+![](images/b770add6287008acd7914be8488c8cb56bef839320b9bcae3ff4f8ee73118a1f.jpg)  
+(c) TRADES  
+Figure 3. Loss landscape comparison of different adversarial training methods
+
+![](images/c6f737ba5e111ea2851a2bd6f412075e71461d589e770d1db0ce00ff152b79ce.jpg)  
+(d) CAT
+
+Wide ResNet has become a standard structure for comparing adversarial training methods, and it's standard to train and evaluate with  $8/255\ell_{\infty}$  norm perturbation. For this setting, we collect the reported accuracy from 7 other adversarial training methods, with several of them published very recently, to have a detailed full comparison. As shown in Table 3, our method achieves state-of-art robust accuracy while maintaining a high clean accuracy. Due to the page limit, we put the Restricted ImageNet result in the appendix.
+
+Black-box transfer attacks. We follow the criterion of evaluating transfer attacks as suggested by Athalye et al. (2018) to inspect whether the models trained by CAT will cause the issue of obfuscated gradients and give a false sense of model robustness. We generate 10,000 adversarial examples of CIFAR-10 from natural models with  $\epsilon = 0.03$  and evaluate their attack performance on the target model. Table 4 shows that CAT achieves the best accuracy compared with adversarial training and TRADES, suggesting the effectiveness of CAT in defending both white-box and transfer attacks.
+
+Table 4. Robust accuracy under transfer attack on CIFAR-10  
+
+<table><tr><td>Method</td><td>VGG 16</td><td>Wide ResNet</td></tr><tr><td>Adv train</td><td>79.13%</td><td>85.84%</td></tr><tr><td>TRADES</td><td>83.53%</td><td>83.90%</td></tr><tr><td>CAT</td><td>86.58%</td><td>88.66 %</td></tr></table>
+
+# 4.3. Loss Landscape Exploration
+
+To further verify the superior robustness using CAT, we visualize the loss landscape of different training methods in Figure 3. Following the implementation in (Engstrom et al., 2018), we divide the data input along a linear space grid defined by the sign of the input gradient and a random Rademacher vector, where the x- and y- axes represent the magnitude of the perturbation added in each direction and the z-axis represents the loss.
+
+As shown in Figure 3, CAT generates a model with a lower and smoother loss landscape. Also, it could be taken as another strong evidence that we have found a robust model through CAT training.
+
+# 4.4. Ablation study
+
+The importance of adaptive label uncertainty. Here we discuss and perform an ablation study using VGG-16 and CIFAR-10 on the importance of adaptive label uncertainty and adaptive instance-wise  $\epsilon$ . In Figure 4b, Adp train denotes the original adversarial training, Adv+LS denotes adversarial training with label smoothing (setting  $y$  by Eq (4)), Adp-Adv denotes adversarial training with adaptive instance-wise  $\epsilon$ , and CAT-CE is the proposed method
+
+![](images/75721312574a0fc7f380d4ee4d9bd1e0d7995038c8bacf9e5af8eaaf08946d14.jpg)  
+(a)
+
+![](images/3dc2fb39cd86a67bd3f87e5047a9d95fb5d912effe65d37a7b1ee0a9f1f1d354.jpg)  
+(b)  
+Figure 4. Analysis of CAT. In (a) we test CAT under different steps of PGD attack, and in (b) we conduct an ablation study on CAT by changing the loss function and removing Label Adaption (LA).
+
+which is a combination of these two tricks. We found that only applying adaptive instance-wise  $\epsilon$  or label smoothing cannot significantly boost the robust accuracy over standard adversarial training, but the proposed method, by nicely combining these two ideas, can significantly improve the performance. This explains why CAT significantly outperforms some instance adaptive  $\epsilon$  methods like IAAT and MMA.
+
+More iterations of PGD attack. As suggested in Athalye et al. (2018), to verify that the performance gain is not brought by insufficient iterations in PGD attack, in Figure 4a, we show the robust accuracy with the number of iteration varying from 10 to 500 on CIFAR10 VGG16. The results show that although increasing the number of iterations would decrease the performance by around  $2\%$ , CAT always outperforms other methods significantly.
+
+# 5. Conclusions
+
+In this paper, we propose CAT, a customized adversarial training method that is designed to have better generalization for both clean and robust performance. We also provide
+
+a theoretical analysis to motivate our algorithm. Experimental results show that CAT has achieved state-of-art robust accuracy and a high clean accuracy while keeping similar running time as standard adversarial training. The success of CAT indicates that it is crucial to customize the perturbation level on both data sample side and its label in adversarial training.
+
+# References
+
+Athalye, A., Carlini, N., and Wagner, D. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. International Coherence on International Conference on Machine Learning, 2018.  
+Balaji, Y., Goldstein, T., and Hoffman, J. Instance adaptive adversarial training: Improved accuracy tradeoffs in neural nets. arXiv preprint arXiv:1910.08051, 2019.  
+Brendel, W., Rauber, J., and Bethge, M. Decision-based adversarial attacks: Reliable attacks against black-box machine learning models. arXiv preprint arXiv:1712.04248, 2017.  
+Carlini, N. and Wagner, D. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy, pp. 39-57, 2017.  
+Chen, P.-Y., Zhang, H., Sharma, Y., Yi, J., and Hsieh, C.-J. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 15-26, 2017.  
+Cheng, M., Le, T., Chen, P.-Y., Yi, J., Zhang, H., and Hsieh, C.-J. Query-efficient hard-label black-box attack: An optimization-based approach. arXiv preprint arXiv:1807.04457, 2018.  
+Cheng, M., Singh, S., Chen, P., Chen, P.-Y., Liu, S., and Hsieh, C.-J. Sign-opt: A query-efficient hard-label adversarial attack. In ICLR, 2020.  
+Cohen, J. M., Rosenfeld, E., and Kolter, J. Z. Certified adversarial robustness via randomized smoothing. International Conference on Machine Learning, 2019.  
+Deng, J., Dong, W., Socher, R., Li, L.-J., Li, K., and Fei-Fei, L. Imagenet: A large-scale hierarchical image database. In IEEE Conference on Computer Vision and Pattern Recognition, pp. 248-255, 2009.  
+Ding, G. W., Sharma, Y., Lui, K. Y. C., and Huang, R. Max-margin adversarial (mma) training: Direct input space margin maximization through adversarial training. arXiv preprint arXiv:1812.02637, 2018.
+
+Engstrom, L., Ilyas, A., and Athalye, A. Evaluating and understanding the robustness of adversarial logit pairing. arXiv preprint arXiv:1807.10272, 2018.  
+Eykholt, K., Evtimov, I., Fernandes, E., Li, B., Rahmati, A., Xiao, C., Prakash, A., Kohno, T., and Song, D. Robust physical-world attacks on deep learning visual classification. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1625-1634, 2018.  
+Gao, R., Cai, T., Li, H., Hsieh, C.-J., Wang, L., and Lee, J. D. Convergence of adversarial training in overparametrized neural networks. In Advances in Neural Information Processing Systems, pp. 13009-13020, 2019.  
+Goibert, M. and Dohmatob, E. Adversarial robustness via adversarial label-smoothing. arXiv preprint arXiv:1906.11567, 2019.  
+Goodfellow, I. J., Shlens, J., and Szegedy, C. Explaining and harnessing adversarial examples. International Conference on Learning Representations, 2015.  
+Ilyas, A., Engstrom, L., Athalye, A., and Lin, J. Black-box adversarial attacks with limited queries and information. arXiv preprint arXiv:1804.08598, 2018.  
+Krizhevsky, A., Nair, V., and Hinton, G. Cifar-10 (canadian institute for advanced research). URL http://www.cs.toronto.edu/~kriz/cifar.html.  
+Kurakin, A., Goodfellow, I., and Bengio, S. Adversarial machine learning at scale. International Conference on Learning Representations, 2017.  
+Liu, X., Cheng, M., Zhang, H., and Hsieh, C.-J. Towards robust neural networks via random self-ensemble. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 369-385, 2018.  
+Madry, A., Makelov, A., Schmidt, L., Tsipras, D., and Vladu, A. Towards deep learning models resistant to adversarial attacks. International Conference on Learning Representations, 2018.  
+Shafahi, A., Ghiasi, A., Huang, F., and Goldstein, T. Label smoothing and logit squeezing: A replacement for adversarial training? 2018.  
+Shafahi, A., Najibi, M., Ghiasi, A., Xu, Z., Dickerson, J., Studer, C., Davis, L. S., Taylor, G., and Goldstein, T. Adversarial training for free! Neural Information Processing Systems, 2019.  
+Simonyan, K. and Zisserman, A. Very deep convolutional networks for large-scale image recognition. International Conference on Learning Representations, 2015.
+
+Su, D., Zhang, H., Chen, H., Yi, J., Chen, P.-Y., and Gao, Y. Is robustness the cost of accuracy? a comprehensive study on the robustness of 18 deep image classification models. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 631-648, 2018.  
+Szegedy, C., Zaremba, W., Sutskever, I., Bruna, J., Erhan, D., Goodfellow, I., and Fergus, R. Intriguing properties of neural networks. International Conference on Learning Representations, 2014.  
+Szegedy, C., Vanhoucke, V., Ioffe, S., Shlens, J., and Wojna, Z. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818-2826, 2016.  
+Thulasidasan, S., Chennupati, G., Bilmes, J., Bhattacharya, T., and Michalak, S. On mixup training: Improved calibration and predictive uncertainty for deep neural networks. Neural Information Processing Systems, 2019.  
+Tsipras, D., Santurkar, S., Engstrom, L., Turner, A., and Madry, A. Robustness may be at odds with accuracy. In International Conference on Learning Representations, 2019.  
+Verma, V., Lamb, A., Beckham, C., Najafi, A., Mitliagkas, I., Courville, A., Lopez-Paz, D., and Bengio, Y. Manifold mixup: Better representations by interpolating hidden states. International Conference on Machine Learning, 2018.  
+Wang, J. Bilateral adversarial training: Towards fast training of more robust models against adversarial attacks. International Conference on Computer Vision, 2019.  
+Wang, Y., Ma, X., Bailey, J., Yi, J., Zhou, B., and Gu, Q. On the convergence and robustness of adversarial training. In International Conference on Machine Learning, pp. 6586-6595, 2019.  
+Wang, Zou, Y. B. M. G. Improving adversarial robustness requires revisiting misclassified examples. International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id=rk10g6EFwS.  
+Wei, C. and Ma, T. Improved sample complexities for deep networks and robust classification via an all-layer margin. arXiv preprint arXiv:1910.04284, 2019.  
+Wong, E., Rice, L., and Kolter, J. Z. Fast is better than free: Revisiting adversarial training. arXiv preprint arXiv:2001.03994, 2020.  
+Yin, D., Ramchandran, K., and Bartlett, P. Rademacher complexity for adversarially robust generalization. arXiv preprint arXiv:1810.11914, 2018.
+
+Zantedeschi, V., Nicolae, M.-I., and Rawat, A. Efficient defenses against adversarial attacks. In ACM Workshop on Artificial Intelligence and Security, pp. 39-49, 2017.  
+Zhang, D., Zhang, T., Lu, Y., Zhu, Z., and Dong, B. You only propagate once: Accelerating adversarial training via maximal principle. In Advances in Neural Information Processing Systems, pp. 227-238, 2019a.  
+Zhang, H., Cisse, M., Dauphin, Y. N., and Lopez-Paz, D. mixup: Beyond empirical risk minimization. International Conference on Learning Representations, 2018.  
+Zhang, H., Yu, Y., Jiao, J., Xing, E. P., Ghaoui, L. E., and Jordan, M. I. Theoretically principled trade-off between robustness and accuracy. International Conference on Machine Learning, 2019b.
+
+# A. Omitted Proofs
+
+In this section we provide the omitted proof for Theorem 3.2, which is adapted from Theorem 2.1 from (Wei & Ma, 2019). They defined the all layer margin for a  $k$ -layer network  $h_\theta(\boldsymbol{x}) = f_k \circ f_{k-1} \circ \dots \circ f_1(\boldsymbol{x})$  and perturbation  $\delta = (\delta_1, \delta_2, \dots, \delta_k)$  as follows:
+
+$$
+h _ {1} (\boldsymbol {x}, \delta) = f _ {1} (\boldsymbol {x}) + \delta_ {1} \| \boldsymbol {x} \| _ {2}
+$$
+
+$$
+h _ {i} (\boldsymbol {x}, \delta) = f _ {i} \left(h _ {i - 1} (\boldsymbol {x}, \delta)\right) + \delta_ {i} \| h _ {i - 1} (\boldsymbol {x}, \delta) \| _ {2}
+$$
+
+$$
+H _ {\theta} (\boldsymbol {x}, \delta) = h _ {k} (\boldsymbol {x}, \delta).
+$$
+
+They define the all-layer margin as the minimum norm of  $\delta = (\delta_{i})_{i=1}^{k}$  required that causes the classifier to make a false prediction.
+
+$$
+m _ {F} (\boldsymbol {x}, y) := \min  _ {\boldsymbol {\delta} ^ {i}, \boldsymbol {\delta} ^ {o}} \sqrt {\| \boldsymbol {\delta} ^ {i} \| ^ {2} + \| \boldsymbol {\delta} ^ {o} \| ^ {2}} \tag {8}
+$$
+
+$$
+\text {s u b j e c t} \max  _ {y ^ {\prime}} H _ {\theta} (\boldsymbol {x}, \boldsymbol {\delta} ^ {i}, \boldsymbol {\delta} ^ {o}) _ {y ^ {\prime}} \neq y.
+$$
+
+They consider the function class  $\mathcal{F} = \{f_k\circ f_{k - 1}\dots \circ f_1:f_i\in \mathcal{F}_i\}$  be the class of compositions of functions from function classes  $\mathcal{F}_1,\dots \mathcal{F}_k$  . They achieve the generalization bound as follows:
+
+Theorem A.1 (Theorem 2.1 from (Wei & Ma, 2019)) In the above setting, with probability  $1 - \delta$  over the draw of the data, all classifiers  $F \in \mathcal{F}$  which achieve training error 0 satisfy
+
+$$
+\mathbb {E} [ f _ {\theta} (\pmb {x}) = y ] \lesssim \frac {\sum_ {i} \mathcal {C} _ {i} \log^ {2} n}{\sqrt {n}} \sqrt {\frac {1}{n} \sum_ {i = 1} ^ {n} \frac {1}{m _ {F} (\pmb {x} _ {i} , y _ {i})}} + \zeta ,
+$$
+
+where  $\zeta$  is of small order  $O\left(\frac{1}{n}\log (1 / \delta)\right)$ .
+
+For our problem, we define  $h_\theta(\pmb{x}) \coloneqq f_2 \circ f_1(\pmb{x})$ , where  $f_1$  is identity mapping, and  $f_2$  is the original function  $h_\theta$ . Therefore the all layer margin is reduced to our bilateral margin:
+
+$$
+\begin{array}{l} h _ {1} (\boldsymbol {x}, \boldsymbol {\delta} ^ {i}) = f _ {1} (\boldsymbol {x}) + \boldsymbol {\delta} ^ {i} \| \boldsymbol {x} \| _ {2} = \boldsymbol {x} + \boldsymbol {\delta} ^ {i} \| \boldsymbol {x} \| \\ H _ {\theta} (\boldsymbol {x}, \boldsymbol {\delta}) = h _ {2} (\boldsymbol {x}, \boldsymbol {\delta} ^ {i}, \boldsymbol {\delta} ^ {o}) = f _ {2} \left(h _ {1} (\boldsymbol {x}, \boldsymbol {\delta} ^ {i})\right) + \boldsymbol {\delta} ^ {o} \| h _ {1} (\boldsymbol {x}, \boldsymbol {\delta} ^ {i}) \| \\ = h _ {\theta} \left(\boldsymbol {x} + \delta^ {i} \| \boldsymbol {x} \|\right) + \delta^ {o} \| \boldsymbol {x} + \delta^ {i} \| \boldsymbol {x} \| \|. \\ \end{array}
+$$
+
+Next, notice since  $f_{1}$  is identity mapping, and composition with  $h_{\theta}$  doesn't affect the overall complexity. We apply Theorem A.1 and get our result.

2002.06xxx/2002.06789/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d39324c22e68cc39958dbd0ba93121fd11f0b1712c6cd3e4052b651e824324c
+size 523440

2002.06xxx/2002.06805/79bedf52-9295-4f4a-afaa-d678c0f969e8_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39731cc2b58a5ea1d94586762fc0d95a20aae686360c59d3508a84484be78848
+size 503922

2002.06xxx/2002.06805/full.md

@@ -0,0 +1,678 @@
+# Polarization-adjusted Convolutional (PAC) Codes: Sequential Decoding vs List Decoding
+
+Mohammad Rowshan, Student Member, IEEE, Andreas Burg, Member, IEEE, Emanuele Viterbo, Fellow, IEEE
+
+In the Shannon lecture at the 2019 International Symposium on Information Theory (ISIT), Arikan proposed to employ a one-to-one convolutional transform as a pre-coding step before the polar transform. The resulting codes of this concatenation are called polarization-adjusted convolutional (PAC) codes. In this scheme, a pair of polar mapper and demapper as pre- and post-processing devices are deployed around a memoryless channel, which provides polarized information to an outer decoder leading to improved error correction performance of the outer code. In this paper, the list decoding and sequential decoding (including Fano decoding and stack decoding) are first adapted for use to decode PAC codes. Then, to reduce the complexity of sequential decoding of PAC/polar codes, we propose (i) an adaptive heuristic metric, (ii) tree search constraints for backtracking to avoid exploration of unlikely sub-paths, and (iii) tree search strategies consistent with the pattern of error occurrence in polar codes. These contribute to the reduction of the average decoding time complexity from  $50\%$  to  $80\%$ , trading with 0.05 to  $0.3\mathrm{dB}$  degradation in error correction performance within  $\mathrm{FER} = 10^{-3}$  range, respectively, relative to not applying the corresponding search strategies. Additionally, as an important ingredient in Fano decoding of PAC/polar codes, an efficient computation method for the intermediate LLRs and partial sums is provided. This method is effective in backtracking and avoids storing the intermediate information or restarting the decoding process. Eventually, all three decoding algorithms are compared in terms of performance, complexity, and resource requirements.
+
+Index Terms-Polarization-adjusted convolutional codes, polar codes, convolutional codes, list decoding, sequential decoding, Fano algorithm, tree search, path metric.
+
+# I. INTRODUCTION
+
+Polar codes proposed by Arikan in [1] are the first class of channel codes with an explicit construction that was proven to achieve the symmetric (Shannon) capacity of a binary-input discrete memoryless channel (BI-DMC) using a low-complexity successive cancellation (SC) decoder (SCD).
+
+Polar codes are founded on the polarization effect resulting from channel synthesizing in a particular fashion. The idea of building synthetic channels originated from the concatenated schemes [2] employed in the sequential decoding of convolutional codes by Massey [3] and Pinsker [4] in order to boost the cutoff rate. The cutoff rate is said to be "boosted" when the
+
+M. Rowshan and E. Viterbo are with the Department of Electrical and Computer Systems Engineering (ECSE), Monash University, Melbourne, VIC3800, Australia. E-mail: mrowshan@connect.ust.hk, emanuele.viterbo@monash.edu. These authors' work was supported by the Australian Research Council under Discovery Project ARC DP160100528. Andreas Burg is with the Telecommunications Circuits Laboratory (TCL), Swiss Federal Institute of Technology (EPFL), Lausanne 1015, Switzerland E-mail: andreas.burg@epfl.ch.
+
+![](images/a78ff2620711321e00284501cdbe24112eaa5538fc617ab5c6b6a9bf38af83c4.jpg)  
+Figure 1: Code Concatenation
+
+sum of the cutoff rates of the synthesized channels is greater than the sum of the cutoff rates of the raw channels. The key idea in boosting the cutoff rate is to build a vector channel where the independent copies of raw channels are transformed into multiple correlated channels. In Pinsker's scheme, the inner block code (with length  $N$ ) is suggested to be chosen at random. This requires maximum likelihood (ML) decoding with prohibitive complexity. Polar codes allow using a more practical decoder with the complexity of  $O(N \log N)$ . Unlike Pinsker's scheme, where the outer convolutional transforms are identical, in multi-level coding and multi-stage decoding (MLC/MSD), originally proposed in [5] as an efficient coded-modulation technique,  $N$  convolutional codes at different rates  $\{R_i\}$  are used which consequently require a chain of  $N$  outer convolutional decoders.
+
+On the other hand, polar coding was originally designed as a low-complexity recursive channel combining and splitting operation, where the polarization effect constrains the rates  $R_{i}$  to either 0 or 1. They turned out to be so effective that no outer code was employed to achieve the original aim of boosting the cutoff rate to channel capacity.
+
+Nevertheless, the error correction performance of finite-length polar codes under successive cancellation (SC) decoding is not competitive, due to the existence of partially polarized channels. To address this issue, the SC list (SCL) decoding (SCLD) was proposed in [6]. This yields an error correction performance comparable to maximum-likelihood (ML) decoding. Also, it was observed that further improvement could be obtained by concatenating cyclic redundancy check (CRC) bits to polar codes.
+
+Recently in [7], ARIAN proposed a concatenation of a convolutional transform with the polarization transform [1], inspired by the aforementioned schemes in which the message is first encoded using a convolutional transform and then transmitted over polarized synthetic channels as shown in Fig. 1. These codes are called "polarization-adjusted convolutional
+
+(PAC) codes". The results show that the block error rate performance of this scheme can reach the finite-length capacity bound [8] a.k.a. dispersion bound.
+
+Fano decoding is an efficient algorithm in terms of required hardware resources such as memory and computation resources, and it has shown a promising error correction performance. Nevertheless, Fano decoding has a high average time complexity. The motivation of this work is to reduce the time and computational complexity at the cost of a small degradation in the practical range of frame error rate (FER), i.e.  $10^{-2}$  to  $10^{-4}$ . Hence, this paper is concerned with the efficient implementation of Fano decoder as well as stack and list decoders for PAC codes, and compares the numerical results with classical polar codes in terms of error correction performance and complexity. The contributions of this work are given below.
+
+- The Fano decoding algorithm requires backtracking during the binary tree search. Hence, intermediate log-likelihood ratios (LLRs) and partial sums need to be updated. This update should be performed without restarting the decoding operation or storing more than  $2N - 1$  intermediate LLRs and partial sums as in conventional SC decoding [18]. In this work, partial rewinding of the SC algorithm is proposed as an efficient approach to compute the intermediate LLRs and partial sums.  
+- The Fano metric is modified in order to improve the comparability of (unexplored) paths with different lengths with the current path. Furthermore, to reduce the number of visited nodes, an adaptive bias is proposed to adjust the bias-term in the metric relative to the impact of the channel noise on the metric.  
+- A tree search strategy is proposed in which the number of diverging paths from the current best path is limited. This is equivalent to constraining the search to the paths in which there are a limited number of flipped bits. Further, this strategy is applied only to the set of bit indices called critical set where over  $99\%$  of the errors occur. This set can reduce the time complexity by visiting fewer nodes at the cost of negligible error-rate degradation.  
+- A combination of top-down search and bottom-up search strategies for the tree search are proposed to adapt the Fano algorithm to the pattern of error occurrence in polar codes, resulting in the faster finding of the correct path.  
+- Performance and complexity comparisons of Fano decoding with stack decoding and list decoding for polar codes and PAC codes, with and without CRC concatenation, for different block-lengths and rate-profiles, are provided by means of simulation.
+
+Paper Outline: Section II introduces the notations for polar codes and convolutional codes and describes their decoding algorithms. Section III illustrates polarization-adjusted convolutional transform, and describes the decoding algorithms. In Section IV, first, an efficient method for calculating the intermediate LLRs and partial sums required through backtracking in Fano decoding is proposed. Then, a heuristic path metric for Fano decoding is introduced. In Section V, strategies are described to improve Fano decoding including adaptive
+
+![](images/356eabb4025b6e2b46e2eece5cc3c2677559afd6ff0b967c0f036abb3cdb107f.jpg)  
+Figure 2: Successive cancellation factor graph for  $N = 4$  path metric, tree search strategies and search constraints. In Section VI, the distance properties of PAC codes and polar codes are compared and the implementation results are shown. Finally Section VII provides some concluding remarks.
+
+# II. PRELIMINARIES
+
+Polarization-adjusted convolutional codes are convolutional pre-transformed polar codes. The pre-transformation (a.k.a pre-coding) is performed by a rate-1 convolutional encoding as shown in Fig. 1. Hence, in the following sections, we first review polar codes and convolutional codes as standalone codes, then we focus on PAC codes.
+
+# A. Polar Codes and List Decoding
+
+A polar code of length  $N = 2^n$  with  $K$  information bits is denoted by  $P(N, K, \mathcal{A})$ , where  $\mathcal{A}$  is the data index set. The information bits  $d$  of length  $K$  is embedded in the vector  $u$  such that  $u_{\mathcal{A}} = d$ , and  $u_{\mathcal{A}^c} = 0$  which are called frozen bits. The set  $\mathcal{A}$  constitutes of indices of reliable sub-channels of the polarized vector channel.
+
+A polar code is encoded as  $\mathbf{x} = \mathbf{u}\mathbf{P}_n$ , where  $\mathbf{P}_n = \mathbf{P}^{\otimes n}$  is the polar transform defined as the  $n$ -th Kronecker power of  $\mathbf{P} \triangleq \begin{bmatrix} 1 & 0 \\ 1 & 1 \end{bmatrix}$ . Let  $\mathbf{y} = (y_0, y_1, \dots, y_{N-1})$  denote the output vector of a noisy channel.
+
+The standard decoding method for polar codes is successive cancellation (SC) decoding in which the non-frozen bits are estimated successively based on their evolved log-likelihood ratio (LLR), denoted by  $\lambda_s^i$ , where  $s$  is the stage of the factor graph in Fig. 2. However, successive hard decisions make the SC solution sub-optimal. When decoding the  $i$ -th bit, if  $i \notin \mathcal{A}$ ,  $\hat{u}_i = 0$ , as  $u_i$  is a frozen bit. Otherwise, the bit  $u_i$  is decided by a local maximum likelihood (ML) rule  $h(\lambda_0^i)$  in (1), which depends on the estimation of previous bits, i.e.,  $\hat{u}_{0,i-1} = \hat{u}_0, \dots, \hat{u}_{i-1}$
+
+$$
+\hat {u} _ {i} = h \left(\lambda_ {0} ^ {i}\right) = \left\{ \begin{array}{l l} 0 & \lambda_ {0} ^ {i} = \ln \frac {P \left(Y , \hat {u} _ {0 , i - 1} \mid \hat {u} _ {i} = 0\right)}{P \left(Y , \hat {u} _ {0 , i - 1} \mid \hat {u} _ {i} = 1\right)} > 0 \\ 1 & \text {o t h e r w i s e} \end{array} \right. \tag {1}
+$$
+
+To resolve the problem of potentially erroneous decisions in the SC decoding, we can introduce the notion of a binary decision tree. In this tree, each branch on level  $i$  corresponds to a decision for  $u_{i} = 1$  or  $u_{i} = 0$  and a path from the root to a leaf corresponds to a decoded codeword. SC decoding explores
+
+only a single path of this tree. Let us denote the  $SC$  path as the path in the tree obtained by following the branches with the larger likelihood (these branches are called good branches and the alternative ones are called bad branches throughout this paper) in each decoding step. A decoding step is defined as the process required to decode a bit. By exploring multiple or even all paths, erroneous preliminary decisions can be corrected to potentially reach ML performance.
+
+Since exhaustive exploration of the tree is prohibitively complex, SC list (SCL) decoding [6] performs a constrained breadth-first search (proceeding from the root to the leaves) which tracks only up to  $L$  parallel paths, that are deemed to be the most reliable ones based on the local decisions.
+
+Let  $\hat{u}_i[l]$  denote the estimate of  $u_{i}$  in the  $l$ -th path, where  $l\in \{1,2,\dots ,L\}$ . In [9], unlike [6], a path metric  $(PM)$  based on LLRs magnitudes is used to measure the reliability of each path to make local decisions about which path to keep and which one to drop. The  $PM$  at  $\hat{u}_i[l]$  is approximated by
+
+$$
+P M _ {l} ^ {(i)} = \left\{ \begin{array}{l l} P M _ {l} ^ {(i - 1)} + \left| \lambda_ {0} ^ {i} [ l ] \right| & \text {i f} \hat {u} _ {i} [ l ] \neq h \left(\lambda_ {0} ^ {i} [ l ]\right) \\ P M _ {l} ^ {(i - 1)} & \text {o t h e r w i s e} \end{array} \right. \tag {2}
+$$
+
+where  $PM_{l}^{(-1)} = 0$
+
+As (2) shows, the path corresponding to the less likely bit value is penalized by  $|\lambda_0^i|$  of that bit. The  $L$  paths with the smallest path metrics are chosen from  $2L$  paths at each step (level of the tree) and are stored in ascending order from  $PM_{1}^{(i)}$  to  $PM_{L}^{(i)}$ . At  $N$ -th step, the path with the smallest path metric  $PM_{1}^{(N)}$  is selected as the estimated codeword.
+
+Additionally, to compensate for the known poor distance properties of polar codes, an  $r$ -bit CRC is often appended to the message as an outer code to assist the decoder in error detection and finding the correct path among the  $L$  paths in the list. However, this concatenation increases the polar code rate to  $(K + r) / N$  causing a small performance degradation in the low SNR regime.
+
+# B. Convolutional Codes and Fano Decoding
+
+Convolutional codes (CCs) are a class of linear codes described by a tuple  $(n_0, k, m)$ , where  $k$  is the number of information bits shifted into the encoder at each time slot (usually  $k = 1$ ),  $n_0$  is the number of corresponding outputted coded bits, and  $m$  is the number of previous input bits stored in a shift-register (a.k.a. memory size) [20]. Unlike the 1-to-1 convolutional transform in PAC codes where  $n_0 = k = 1$  as illustrated in Section III-A, the code rate of convolutional codes is given by  $k / n_0$ . The value  $m + 1$ , named constraint length, determines the number of previous input bits plus the current bit that influence each coded bit. A larger constraint length generally provides greater resilience to bit errors.
+
+The relation between the input bits  $d_{i - m,i}$  and one of the  $n_0$  output bits  $x_{i}$ , at time-step  $i$ , is obtained as a binary convolution  $x_{i} = \sum_{j = 0}^{m}g_{j}d_{i - j}$ , where  $g_{i}\in \{0,1\}$ . By representing bit sequences as polynomials in the delay variable  $D$  representing a time-step in the encoder, an output sequence  $x(D)$  is obtained as  $g(D)d(D)$ , where  $g(D) = \sum_{j = 0}^{m}g_{j}D^{j}$  is the generator polynomial. Different generator polynomials
+
+are used for  $n_0$  outputs, only one polynomial is employed in the pre-transformation of PAC codes.
+
+Convolutional codes are decoded using the trellis-based Viterbi algorithm and the tree search sequential decoding algorithms. The Viterbi algorithm is a maximum likelihood decoding method that examines the entire state space of the encoder at each step. We have studied Viterbi decoding of PAC codes in [32].
+
+On the other hand, the complexity of the sequential decoding is essentially independent of the memory of the encoder, since only one encoder state is examined at each step. The fundamental idea behind sequential decoding is to explore only the most promising path(s). If a path to a node looks "bad" we can discard all the paths through this node without a significant loss in the error correction performance compared to that of a maximum likelihood decoder [20].
+
+In this work, we focus on Fano decoding which is a memory-efficient type of Sequential decoding algorithm. The Fano algorithm is a depth-first tree search, in which the decoder moves from a node either back to its parent node or to one of its children. The Fano decoder can visit a node only if its Fano path metric  $\mu_F$  is larger than or equal to a certain value called threshold  $T$ . Threshold takes only discrete values  $0, \pm \Delta, \pm 2\Delta, \ldots$ .
+
+Comparing the above described Fano decoding to the SC and SC list decoding described in Section II-A, it is instructive to note two important differences: The SC decoding makes decisions to choose the node to visit at each step based on the branch metric. Thus, only one path is explored and the rest are discarded. However, SC list decoding explores multiple paths, but in contrast to Fano decoding, all of them have the same length. Thus, no backtracking is performed neither in SC nor in SC list decoding. Hence, only the path metric used to measure the likelihood of the paths in the sequential decoding must consider the difference in the lengths of partial paths by adding a bias, while in the SC and SC list decoding, the bias term is not required. A simpler sequential decoding algorithm is the stack decoding [20] where the algorithm keeps a stack of size/depth  $D$  of partial paths sorted with respect to the path metric. The algorithm extends the path with the best metric at the top of the stack. The stack decoding is a memory intensive algorithm with a variable time complexity that instead of backtracking as in the Fano decoding, it selects to extend the best partial path in the stack at each time step.
+
+The metric used in the sequential decoding of convolutional codes is a probabilistic path metric. We consider the set  $\mathcal{X} = \{\mathbf{a}^{(1)},\mathbf{a}^{(2)},\dots,\mathbf{a}^{(M)}\}$  of  $M$  partial sequences, representing partially explored paths with different lengths, to be compared. Let  $n_{max} = \max \{n_1,n_2,\dots,n_M\}$  denote the length of the longest sequence, and  $\tilde{\mathbf{r}}$  the partial received sequence of length  $n_{max}$  symbols where each encoded symbol takes  $n$  bits corresponding to  $k$  information/uncoded bits,  $R = k / n$ . Hence, the sequences  $\tilde{\mathbf{r}}$  and  $\mathbf{a}^{(\ell)}$  are
+
+$$
+\tilde {\mathbf {r}} = \left(\mathbf {r} _ {0} \mathbf {r} _ {1} \dots \mathbf {r} _ {n _ {m a x} - 1}\right) = \left(r _ {0} \dots r _ {n - 1} \dots r _ {n n _ {m a x} - 1}\right)
+$$
+
+$$
+\mathbf {a} ^ {(\ell)} = \left(\mathbf {a} _ {0} ^ {(\ell)} \mathbf {a} _ {1} ^ {(\ell)} \dots \mathbf {a} _ {n _ {\ell} - 1} ^ {(\ell)}\right) = \left(a _ {0} ^ {(\ell)} \dots a _ {n - 1} ^ {(\ell)} \dots a _ {n n _ {\ell} - 1} ^ {(\ell)}\right)
+$$
+
+Among the sequences in  $\mathcal{X}$ , we choose the partial sequence  $\mathbf{a}^{(\ell)}$  that maximizes the a-posterior probability  $P(\mathbf{a}^{(\ell)}|\tilde{\mathbf{r}})$ . According to Bayes' rule
+
+$$
+P \left(\mathbf {a} ^ {(\ell)} \mid \tilde {\mathbf {r}}\right) = \frac {P \left(\mathbf {a} ^ {(\ell)}\right) P \left(\tilde {\mathbf {r}} \mid \mathbf {a} ^ {(\ell)}\right)}{P (\tilde {\mathbf {r}})} \tag {3}
+$$
+
+Assuming the channels are memoryless, since the length of the sequence  $\mathbf{a}^{(\ell)}$  is  $n_{\ell} \leq n_{max}$ , and there is no associated symbols in this sequence for  $r_{n_{\ell}}, \ldots, r_{n_{max}-1}$ , then we have
+
+$$
+P \left(\tilde {\mathbf {r}} \mid \mathbf {a} ^ {(\ell)}\right) = \prod_ {j = 0} ^ {n _ {\ell} - 1} P \left(\mathbf {r} _ {j} \mid \mathbf {a} _ {j} ^ {(\ell)}\right) \prod_ {j = n _ {\ell}} ^ {n _ {\max } - 1} P \left(\mathbf {r} _ {j}\right) \tag {4}
+$$
+
+Also, we can rewrite the denominator of (3) as
+
+$$
+P (\tilde {\mathbf {r}}) = \prod_ {j = 0} ^ {n _ {\ell} - 1} P \left(\mathbf {r} _ {j}\right) \prod_ {j = n _ {\ell}} ^ {n _ {\max } - 1} P \left(\mathbf {r} _ {j}\right) \tag {5}
+$$
+
+Now, by substituting (4) and (5) in (3) and cancelling the common term  $\prod_{j=n_\ell}^{n_{\text{max}}-1} P(\mathbf{r}_j)$ , we have
+
+$$
+P \left(\mathbf {a} ^ {\ell} \mid \tilde {\mathbf {r}}\right) = P \left(\mathbf {a} ^ {\ell}\right) \prod_ {i = 0} ^ {n n _ {\ell} - 1} \frac {P \left(r _ {i} \mid a _ {i} ^ {(\ell)}\right)}{P \left(r _ {i}\right)} \tag {6}
+$$
+
+Suppose each encoded bit occurs with equal probability, then each sequence  $\mathbf{a}^{(\ell)}$  occurs with probability  $P(\mathbf{a}^{(\ell)}) = (2^{-k})^{n_{\ell}} = (2^{-nR})^{n_{\ell}} = (2^{-R})^{nn_{\ell}}$ . Thus, by taking the base-2 logarithm of (7), we have
+
+$$
+\log P \left(\mathbf {a} ^ {(\ell)} \mid \tilde {\mathbf {r}}\right) = \sum_ {i = 0} ^ {n n _ {\ell} - 1} \left(\underbrace {\log P \left(r _ {i} \mid a _ {i} ^ {(\ell)}\right)} _ {\text {M L - m e t r i c}} \underbrace {- \log P \left(r _ {i}\right) - R} _ {\text {p a t h - l e n g t h b i a s}}\right). \tag {7}
+$$
+
+In order to adapt (7) for sequential (stack or Fano) decoding of polar/PAC codes, the path metric of list decoding can be used as the ML-metric term. Note that  $n$  in (7) is 1 for PAC codes as the convolutional transform is 1-to-1 resulting in  $R = 1$ . The simplest path-length bias in (7) could be a fixed bias parameter as suggested in [21]. A different bias function based on the cumulative density function (CDF) of the evolving LLRs was proposed in [22]. Further, [23] suggested to replace the path-length bias term with  $\log(1 - p_{e,i})$ , where  $p_{e,i}$  is the error probability of  $i$ -th bit-channel.
+
+Alternatively, in the computer science literature, the path metric of algorithm A, a graph traversal and path search algorithm, is written in the general form of [24]
+
+$$
+f \left(\mathbf {a} ^ {(\ell)}\right) = g \left(\mathbf {a} ^ {(\ell)}\right) + h \left(\mathbf {a} ^ {(\ell)}\right) \tag {8}
+$$
+
+where the first term measures the actual cost of the  $i$ -th partial path as follows,
+
+$$
+g \left(\mathbf {a} ^ {(\ell)}\right) = \sum_ {j = 0} ^ {n _ {\ell} - 1} \log P \left(\mathbf {r} _ {j} \mid \mathbf {a} _ {j} ^ {(\ell)}\right) \tag {9}
+$$
+
+and the second term is a heuristic estimate for the remaining cost of completing the path to its leaf with the best metric by following the corresponding (yet unknown) extension of  $\mathbf{a}^{(\ell)}$ . The choice of the heuristic function  $h(\mathbf{a}^{(\ell)})$ , determines the tradeoff between the complexity and the risk of accidentally abandoning a path that leads to the desired optimal solution.
+
+We propose a heuristic to estimate  $h(\mathbf{a}^{(\ell)})$  for Fano decoding of polar codes and PAC codes in Section IV-B.
+
+![](images/2c79c8bd44607998d9fd003a372ce37a5b0dc66c97376ac35200613eaaeb80ad.jpg)  
+Figure 3: PAC coding scheme
+
+# III. POLARIZATION-ADJUSTED CODES
+
+Polarization-adjusted convolutional codes, denoted by  $PAC(N,K,\mathcal{B},\mathbf{g})$ , are based on the outer convolutional transform and inner polar transform. One may consider PAC coding as a polar coding scheme in which the inputs to the frozen bit-channels are linear combinations of previous bits obtained by convolutional transforms. Thus, given that the previous bits have been estimated correctly, the decoder can still determine the value transmitted by the corresponding "bad channels". In the following Sections, the encoding and decoding of PAC codes are described in detail.
+
+# A. PAC Encoding
+
+The information bits  $\mathbf{d} = (d_0, d_1, \dots, d_{K-1})$  are first mapped to a vector  $\mathbf{v} = (v_0, v_1, \dots, v_{N-1})$  using a rate-profile. The rate-profile (a.k.a. code construction) is formed based on the index set  $\mathcal{B}$  such that  $u_{\mathcal{B}} = d$ , and  $u_{\mathcal{B}^c} = 0$ . Note that the constraint  $v_{\mathcal{B}^c} = 0$  simply leads to an irregular tree code.
+
+After rate-profiling, the vector  $\mathbf{v}$  is transformed using a convolutional generator polynomial  $\mathbf{g} = [g_0,\dots,g_m]$  to  $u_{i} = \sum_{j = 0}^{m}g_{j}v_{i - j}$ , where  $g_{i}\in \{0,1\}$  as discussed in Section II-B (see subroutine convTransform in Algorithm 1). Equivalently, the convolutional transform (CT) can be represented in matrix form where the rows of an upper-triangular generator matrix  $G$  are formed by shifting the vector  $\mathbf{g} = [g_0,\dots g_m]$ . The number of rows equals the block-length. Given the generator matrix  $\mathbf{G}$ , we can encode the message block  $\mathbf{v}$  as  $\mathbf{u} = \mathbf{vG}$ . As a result of this pre-transformation,  $u_{i}$  for  $i\in \mathcal{B}^c$  are no longer fixed or known a priori (as 0's in  $\mathbf{u}$ ) - unlike in conventional. In fact, these formerly frozen bits are acting as parity check (PC) bits [10] or dynamic frozen bits [22].
+
+Then, as Fig. 3 shows, vector  $\mathbf{u}$  is mapped to  $\mathbf{x}$  by employing the conventional polar transform  $\mathbf{P}_n$  defined in Section II-A. Hence, the  $N$ -bit rate-profiled data (or block-length) should be a power of 2, i.e.,  $N = 2^n$ . In summary, the polar transformation is performed by  $\mathbf{x} = \mathbf{u}\mathbf{P}_n$ . Algorithm 1 summarizes the encoding process. In this algorithm, cState and currState represent the current state of the  $m$ -bit memory.
+
+# B. PAC List Decoding
+
+PAC codes as (irregular) tree codes can be decoded using the tree search algorithms discussed in Section II. In this section, we consider the list decoding for PAC codes which trades a fixed time complexity for a large memory requirement
+
+Algorithm 1: PAC Encoding  
+input: profiled information bits v, g  
+output: the codeword x  
+1 u  $\leftarrow$  convTrans(v, g)  
+2 x  $\leftarrow$  polarTrans(u) // Like polar encoder  
+3 return x;  
+4 subroutine convTrans(v, g):  
+5 cState[1,...,|g|-1]  $\leftarrow$  [0,...,0] // currState  
+6 for i  $\leftarrow$  0 to |v|-1 do  
+7 (ui, cState)  $\leftarrow$  conv1bTrans(vi, cState, g)  
+8 return u;  
+9 subroutine conv1bTrans(v, currState, g):  
+10 u  $\leftarrow$  v  $\cdot$  g0  
+11 for j  $\leftarrow$  1 to |g| do  
+12 if  $g_{j} = 1$  then  
+13 |u  $\leftarrow$  u  $\oplus$  currState[j-1]  
+14 nextState  $\leftarrow$  [vi] + currState[1,...,|g|-2]  
+15 return (u, nextState);
+
+(to store a list of paths) and is easier to implement. Then, in the next section and the rest of the paper, we focus on Fano decoding which has a variable time complexity, but is much more memory-efficient. Note that the list decoding in the context of convolutional codes is called  $M$ -algorithm [13]. In the context of PAC codes, some results using list decoding were first presented by Huawei in ITW 2019 [26]. Later, we implemented list decoding for PAC codes in [14] independently of [15].
+
+Algorithm 2 illustrates the list decoding approach. In the beginning, there is a single path in the list. When the index of the current bit is in the set  $\mathcal{B}^c$ , the decoder knows its value, usually  $v_{i} = 0$  and therefore it is encoded into  $u_{i}$  based on the current memory state currState and the generator polynomial g in line 7. Note that the subroutine conv1bTrans is identical with the one in Algorithm 1. Then, using the decision LLR  $\lambda_0^i$  obtained in line 5, the corresponding path metric is calculated using subroutine calcPM. Eventually, the decoded value  $u_{i}$  is fed back into SC process in line 9 to calculate partial sums. On the other hand, if the index of the current bit is in the set  $\mathcal{B}$  (see lines 19-26), there are two options for the value of  $v_{i}$ , 0 and 1, to be considered in line 24. For each option of 0 and 1, the aforementioned process for  $i \in \mathcal{B}^c$  including convolutional encoding, and calculating path metric is performed and then the two encoded values  $u_{i} = 0$  and 1 are fed back into SC process. The subroutines updateLLRs, updatePartialSums, and prunePaths in Algorithm 4 are identical to the ones used in Sc decoding and SCL decoding of polar codes. Note that the vectors  $\lambda$  and  $\beta$  as shown in Fig. 2 are the LLRs and partial sums, respectively.
+
+One can notice that the process of list decoding for PAC codes is similar to that for polar codes except for the additional convolutional re-encoding at each decoding step for which the next memory state is stored for each path. For medium and long block-lengths, we can also append CRC-bits or parity check (PC) bits to the information bits to help in detecting
+
+Algorithm 2: List Decoding of PAC codes  
+input: channel LLRs  $\lambda_{n}^{0,N - 1}$ $\mathcal{B},L,\mathbf{g}$  output: recovered message bits  $\hat{\mathbf{d}}$    
+1  $\mathcal{L}\gets \{1\}$  // a single path in the list   
+2  $[\lambda ,\beta ]\gets [\lambda_n^{0,N - 1} + \{0\} ,\{0\} ]$    
+3 for  $i\gets 0$  to  $N - 1$  do   
+4 if  $i\notin \mathcal{B}$  then for  $l\gets 1$  to  $|\mathcal{L}|$  do  $\begin{array}{r}\lambda_0^i [l]\gets \mathrm{updateLLRs}(l,i,\lambda [l],\beta [l])\\ \hat{v}_i[l]\gets 0\\ [\hat{u}_i[l],\mathrm{cState}[l]]\gets \mathrm{conv1bTrans}(v_i,\mathrm{cState}[l],\mathbf{g})\\ PM_l^{(i)}\gets \mathrm{calcPM}(PM_l^{(i - 1)},\lambda_0^i [l],\hat{u}_i[l])\\ \beta [l]\gets \mathrm{updatePartialSums}(\hat{u}_i[l],\beta [l])\\ \end{array}$    
+5 else for  $l\gets 1$  to  $|\mathcal{L}|$  do L  $\leftarrow$  duplicatePath(L,l,i,g) if  $|\mathcal{L}| > L$  then   
+15 |  $\mathcal{L}\gets$  prunePaths(L) // like SCLD   
+6 d  $\leftarrow$  extractData(v1N[0])   
+7 return d;   
+subroutine duplicatePath (L, l, i, g):   
+9  $\mathcal{L}\gets \mathcal{L}\cup \{l'\} \quad /$  path  $l^{\prime}$  is a copy of path  $l$    
+20  $\lambda_0^i [l]\gets$  updateLLRs(l,i,  $\lambda [l],\beta [l])$    
+21  $(\hat{v}_i[l],\hat{v}_i[l'])\gets (0,1)$    
+22  $[\hat{u}_i[l],\mathrm{cState}[l]]\gets \mathrm{conv1bTrans}(\hat{v}_i[l],\mathrm{cState}[l],\mathbf{g})$    
+23  $[\hat{u}_i[l'],\mathrm{cState}[l'])\gets \mathrm{conv1bTrans}(\hat{v}_i[l'],\mathrm{cState}[l],$  g)   
+24  $PM_l^{(i)}\gets \mathrm{calcPM}(PM_l^{(i - 1)},\lambda_0^i [l],\hat{u}_i[l])$    
+25  $PM_{l'}^{(i)}\gets \mathrm{calcPM}(PM_l^{(i - 1)},\lambda_0^i [l],\hat{u}_i[l'])$    
+26  $\beta [l]\gets$  updatePartialSums(u[i]l],  $\beta [l])$    
+27  $\beta [l']\gets$  updatePartialSums(u[i]l'],  $\beta [l])$    
+28 return L;   
+29 subroutine calcPM(PM,  $\lambda_0,\hat{u})$  ..   
+30 if  $\hat{u} = \frac{1}{2} (1 - \operatorname {sgn}(\lambda_0))$  then   
+31  $PM = PM$    
+32 else   
+33  $\begin{array}{rl}{|PM=PM+|\lambda_0|}&{}\\ {\mathrm{return}PM;}&{}\end{array}$
+
+the correct path. To reduce the computational complexity and performance of list decoding, the methods proposed in the literature such as in [16], [17] can be applied to PAC list decoding as well.
+
+List decoding, with its non-backtracking tree search approach, requires very large list sizes (typically  $L = 256$  or more) to reach the dispersion bound [8], as it will be shown in Section VI. More memory-efficient backtracking search algorithms such as the Fano algorithm can approach the dispersion bound at the cost of a higher average time complexity at low SNR regimes.
+
+# IV. FANO DECODING OF PAC CODES
+
+In this section, we first briefly explain the fundamentals of the Fano algorithm detailed in Algorithm 4 followed by the details of the proposed algorithm for updating the intermediate information required in the SC decoding process in the backtracking (Section IV-A) and our novel path metric (Section IV-B). Then, we present several improvements to the Fano algorithm in order to reduce the time complexity in the following Section V.
+
+In the Fano algorithm, the decoder starts with the origin node  $(i = 0)$  and examines a sequence of adjacent nodes. At any step corresponding to the non-frozen bits in vector  $\mathbf{v}$ , it either moves forward to one of the successor nodes or moves backward to the non-frozen predecessor of the current node. The branch metric  $m_{i}$  is correspondingly added to the current path metric  $\mu_{i-1}$  during forward movement (in lines 9 & 16-17 of Algorithm 4) or restored from memory during the backward movement. The algorithm stops when it reaches a terminal node  $(i = N)$ . The search through the code tree is guided by a threshold  $T$  on the path metric (with initial value of  $T = 0$ ). If the metric becomes less than the threshold as the algorithm follows the current path (line 42 of Algorithm 4), the search is backed up and another path is followed (Algorithm 6 is called in line 58 of Algorithm 4). If no paths can be found with a metric above the threshold, the threshold value is lowered (in line 26 of Algorithm 4) and the process is continued. A node in the tree may be visited more than once in the forward direction but a lower threshold each time. The algorithm eventually reaches a terminal node and stops. For more details on the Fano algorithm, see [20].
+
+Note that (i) the Fano algorithm proposed here stores the path metric of good branch (the one with larger metric) and bad branch (the one with smaller metric) as well as memory states along the current path, (ii) the subroutines updateLLRs and updatePartialSums in Algorithm 4 and the rest of the paper are identical to the ones used in SC decoding of polar codes, (iii) Algorithm 6 is called in line 44 to find a bit index that satisfies the threshold in order to move back, and (iv) toDiverge indicates that the branch with smaller metric should be chosen at information bit  $j$  and this choice is flagged in the  $j$ -element of vector  $\delta$ . The rest of the Algorithm 4 and other algorithms are explained and referred to in the rest of the paper.
+
+# A. Partial Rewind of SC Algorithm
+
+The Fano algorithm performs forward and backward traversals in the decoding tree: while in the forward traversal, the calculation of the required intermediate LLRs and partial sums is straightforward and linear, a more sophisticated approach is required for the backward traversal or partial rewind of SC algorithm. Suppose that we want to move back from the  $i_{\text{curr}}$ -th bit to the  $i_{\text{start}}$ -th bit: First, we need to re-calculate  $\lambda_0^{i_{\text{start}}}$  and a number of intermediate LLRs. Since these LLRs are updated in-place when computing the metrics in natural order, they may no longer be available. As explained in [18], efficient decoders store at most  $N - 1$  intermediate/decision LLRs for decoding bits 0 to  $N - 1$ , of which  $N / 2^{n - s}$  are associated to stage  $s$  ( $0 \leq s \leq n - 1$ ) of the LLR calculation
+
+algorithm. The number of intermediate LLRs to be updated varies between one, when moving from a bit with odd index  $i_{curr}$  to  $i_{curr} - 1$ , and in extreme cases  $N - 1$ , when moving from  $i_{curr} \geq N / 2$  to  $i_{start} < N / 2$ .
+
+In general, up to  $\log_2N$  stages should be activated to calculate the decision LLR at bit  $i_{start}$ ,  $\lambda_0^{i_{start}}$ . The first stage to be activated (from right to left in Fig. 2) is determined by find first set (ffs) operation, here, set means 1, on the binary representation of bit index  $x$ , i.e.,  $\mathrm{bin}(x) = x_{n - 1} \dots x_1 x_0$ . The modified version of ffs [18] is defined below. Note that we assume the decoding is performed in natural order.
+
+$$
+\operatorname {f f s} ^ {*} \left(x _ {n - 1} \dots x _ {1} x _ {0}\right) = \left\{ \begin{array}{l l} \min  (j): x _ {j} = 1 & x > 0, \\ n - 1 & x = 0 \end{array} \right. \tag {10}
+$$
+
+When  $i_{curr}$ , the index of the current bit, is odd,  $\mathrm{ffs}^*(\mathrm{bin}(i_{curr})) = 0$ , and  $i_{start} = i_{curr} - 1$ , we can calculate the decision LLR,  $\lambda_0^{i_{start}}$ , directly according to the  $f$ -node operation without any need to update the intermediate LLRs. As a consequence, when moving back to bit index  $i_{start} < i_{curr} - 1$  we need to consider the  $\mathrm{ffs}^*$  of  $i_{curr} - 1$  and/or  $i_{start} - 1$  if  $i_{curr}$  and  $i_{start}$  both or either one is odd. This is controlled in lines 1-4 of Algorithm 3. Note that the stages to be updated are not necessarily  $s = \mathrm{ffs}^*(\mathrm{bin}(i_{start})), \dots, 1, 0$ , but the deepest stage to be updated,  $s_{max}$ , is
+
+$$
+s _ {\max } = \left\{\max  (s): s = \operatorname {f f s} ^ {*} (\operatorname {b i n} (i _ {m})), i _ {\text {s t a r t}} \leq i _ {m} \leq i _ {\text {c u r r}} \right\} \tag {11}
+$$
+
+The relation (11) finds the deepest stage in the factor graph (from left to right in Fig. 2) at which the LLRs have been updated/overwritten while decoding bit  $i_{start}$  to  $i_{curr}$ . If  $s_{max} \geq \mathrm{ffs}^{*}(\mathrm{bin}(i_{start}))$ , we need to move back further to the bit  $i_{-1}$  at which  $s_{max} = \mathrm{ffs}^{*}(\mathrm{bin}(i_{-1}))$ . The subroutine findsMaxPos in Algorithm 3 performs the operation of finding  $i_{-1}$ .
+
+Example: Suppose the block-length is  $N = 4$  and we are decoding bit  $i_{\text{curr}} = 3$ . The intermediate LLRs vector is  $[\lambda_1^3, \lambda_1^2]$ , excluding the decision LLR,  $\lambda_0^3$  (see Fig. 2). Now, if we need to go one step back to bit  $i_{\text{start}} = 2$ , since  $i_{\text{curr}} = 3$  is odd, we do not need to update the intermediate LLR vector, i.e.,  $\lambda_0^2$  can be directly calculated. However, for moving back to  $i_{\text{start}} = 1$ , since  $i_{\text{start}}$  is odd, we need to find  $s_{\text{max}} = 1$  and calculate  $[\lambda_1^1, \lambda_1^0]$ . Only after this update of the intermediate LLRs it is possible to calculate the decision LLR  $\lambda_0^1$  and rewind the SC algorithm.
+
+Note that the partial sums vector,  $\beta$ , is also updated in lines 12 and 19 during the aforementioned process.
+
+Algorithm 3 shows an efficient approach for updating the intermediate LLRs.
+
+# B. Heuristic Path Metric
+
+The Fano path metric for each examined node plays an important role in the backtracking since it provides an indication for how likely it is that the partial path to the current node is correct. Efficient backtracking relies on this metric to a) select a point to branch off the currently best (possibly erroneous) path to explore promising alternative solutions and to b) abandon unlikely paths based on comparing their path metrics with the threshold  $T$ .
+
+Algorithm 3: updateLLRsPSs: Updating intermediate LLRs & partial sums for partial rewinding  
+input:  $i_{start}$ ,  $i_{curr}$ ,  $\hat{\mathbf{u}}$ ,  $\lambda$ ,  $\beta$   
+output: updated  $\lambda$ , updated  $\beta$   
+1 if  $i_{curr}\%2\neq 0$  then  
+2 |  $i_{curr} \gets i_{curr} - 1$   
+3 if  $i_{start}\%2\neq 0$  then  
+4 |  $i_{start} \gets i_{start} - 1$   
+5  $s_{start} = \mathrm{ffs}^*(i_{start})$  // c.f (10)  
+6  $s_{max} \gets \mathrm{sMax}(i_{start},i_{curr})$  // c.f (11)  
+7 if  $s_{start} \leq s_{max}$  then  
+8 |  $i_{-1} = \mathrm{find\_sMaxPos}(s_{start},s_{max},i_{start})$   
+9 |  $\beta \gets \mathrm{updatePSBack}(i_{-1},s_{max},\hat{\mathbf{u}})$   
+10 for  $i \gets i_{-1}$  to  $i_{start}$  do  
+11 |  $\lambda \gets \mathrm{updateLLRs}(i,\lambda,\beta)$   
+12 |  $\beta \gets \mathrm{updatePartialSums}(i,\hat{\mathbf{u}}_i,\beta)$  // Identical w/ SCD  
+13 else  
+14 |  $\lambda \gets \mathrm{updateLLRs}(i_{start},\lambda,\beta)$   
+15 return  $[\lambda,\beta]$ ;  
+16 subroutine updatePSBack ( $i_{-1}$ ,  $s_{max}$ ,  $\hat{\mathbf{u}}$ ):  
+17 |  $k \gets 2^{s_{max}}$   
+18 | for  $i \gets i_{-1} + 1 - k$  to  $i_{-1}$  do  
+19 |  $\beta \gets \mathrm{updatePartialSums}(i,\hat{\mathbf{u}}_i,\beta)$   
+20 | return  $\beta$ ;  
+21 subroutine find_sMaxPos ( $s_{start}$ ,  $s_{max}$ ,  $i_{-1}$ ):  
+22 |  $s' \gets s_{start}$   
+23 while  $s' < s_{max}$  do  
+24 |  $i_{-1} \gets i_{-1} - 2$   
+25 | if  $i_{-1} > 0$  then  
+26 |  $s' \gets ffs^*(i_{-1})$  // c.f (10)  
+27 else  
+28 |  $s' \gets n$   
+29 | return  $i_{-1}$ ;
+
+To provide such a metric, we follow the generic approach outlined in (6): the first term corresponds to the metric in list decoding while the second term is used to account for the different candidate path lengths in the Fano decoding. For every partial sequence  $a^{(\ell)}$ , we define the following metric:
+
+$$
+\begin{array}{l} \mu_ {\ell} = M \left(a ^ {(\ell)}, \mathbf {y}\right) = \sum_ {\substack {j = 0 \\ N - 1}} ^ {n _ {\ell} - 1} \log P \left(\hat {u} _ {j} ^ {(\ell)} \mid \hat {\mathbf {u}} _ {0, j - 1} ^ {(\ell)}, \mathbf {y}\right) \tag{12} \\ + \sum_ {j = n _ {\ell}} ^ {N - 1} \log E _ {\mathbf {y}} \left[ P \left(u _ {j} \mid \mathbf {u} _ {0, j - 1}, \mathbf {y}\right) \right] \\ \end{array}
+$$
+
+The second term is an expected metric for the continuation of the partial path with length  $N - n_{i}$ . Based on our observation of the actual metric obtained during decoding with or without backtracking, a good estimation of the second term, in case there is no error in the received signals, is  $E_{\mathbf{y}}\left[P(u_{j}|\mathbf{u}_{0,j - 1},\mathbf{y})\right] \approx 1 - p_{e,j}$ , where  $p_{e}$  is the error probability of the bit-channels which can be obtained from the
+
+methods used for the construction/rate-profile of polar codes.
+
+Let us define the expected metric  $B = E_{\mathbf{y}}[\mu_{N - 1}]$  for the full-length path and the expected metric of the remaining partial path as
+
+$$
+B = \sum_ {j = 0} ^ {N - 1} \log \left(1 - p _ {e, j}\right) \tag {13}
+$$
+
+$$
+B _ {i} ^ {c} = \sum_ {j = i + 1} ^ {N - 1} \log \left(1 - p _ {e, j}\right) = B - \sum_ {j = 0} ^ {i} \log \left(1 - p _ {e, j}\right) \tag {14}
+$$
+
+where  $\log (1 - p_{e,j})$  is the estimated branch metric. Now, we can rewrite (12) as a recursion as follows:
+
+$$
+\mu_ {j} = \mu_ {j - 1} + m _ {j} - \log \left(1 - p _ {e, j}\right) \tag {15}
+$$
+
+where  $m_j = \log (P(\hat{u}_j|\hat{\mathbf{u}}_{0,j - 1},\mathbf{y}))$  is the actual branch metric and  $\mu_{-1} = B$ . Note that since the initial metric is  $\mu_{-1} = B$ , at each decoding step, the actual branch metric  $m_j$  is added and instead the estimated metric of the corresponding branch is deducted to maintain the relation in (12). Hence, although (15) looks similar to the metric in [23], the initial value and the foundation of the metric are quite different (in [23],  $\mu_{-1} = 0$ ). Furthermore, one can optimize the FER performance by tuning the bias term,  $\log (1 - p_{e,i})$ . In particular, if the SNR dependent method in [28] is used to obtain  $p_{e,i}$ , one can improve FER performance, by changing the design-SNR.
+
+# V. LOW-COMPLEXITY FANO DECODING
+
+In this section, we introduce an adaptive path metric depending on the noise level and different search strategies to limit the search space.
+
+# A. Adaptive Path Metric
+
+A bit channel  $i$  with low reliability contributes to the metric update depending on the noise level, i.e.,  $\mu_{i}$  can be significantly smaller than  $\mu_{i-1}$  (due to change in the magnitude and/or sign of the decision LLR) in the presence of large channel noise. This impact on the path metric can accumulate over time leading to a significant deviation from the expected metric in (13). Recall that due to channel dependency, a change in the channel LLR of one channel can affect the other low-reliability bit channels as well. Consequently, the metric of most of the examined branches denoted by  $\mu'$  in Fig. 4 are most likely greater than the threshold, i.e.,  $\mu_{i}' > T$  for  $i < i_{curr}$ , where  $i_{curr}$  is defined in Section IV. This causes a large delay due to the exploration of many sub-paths during backtracking. Hence, the metric estimate for the path continuation represented by the second term in (12), is not in a fair way comparable with the actual metric of the current path as discussed in the previous section.
+
+To compensate for such deviation, we suggest adapting the estimate (14) for the continuation of partial paths relative to the impact of the channel noise on the actual metric. This adaptation can be realized by a scaling factor  $\alpha$  for the logarithm of the probability in (14) which in effect adapts the expected probability to the noise level. The effect of this scaling is as follows:
+
+![](images/d302dd2ee514ca55e0f64c8b04c055d0588b39ad907f22d65b134e32bd152342.jpg)  
+Figure 4: Decoding tree:  $\mu_j$ s are the path metrics of the current best path (solid thick line) from the root to a node at level  $j$  and the  $\mu_j^{\prime}$ s are the path metrics of the branches (solid thin line) diverging from the current best path.
+
+$\alpha \log E_{\mathbf{y}}[P(u_j|\mathbf{u}_{0,j - 1},\mathbf{y})] = \log \big(E_{\mathbf{y}}[P(u_j|\mathbf{u}_{0,j - 1},\mathbf{y})]\big)^{\alpha}.$  Since  $\alpha \geq 1$  and  $P(u_{j}|\mathbf{u}_{0,j - 1},\mathbf{y}) < 1,$  then  $(E_{\mathbf{y}}[P(u_j|\mathbf{u}_{0,j - 1},\mathbf{y})])^{\alpha}$  becomes smaller, accounting for a larger noise variance.
+
+The value of  $\alpha$  is determined after visiting the nodes of the current path to some level of decoding tree. This level should cover a sufficient number of low-reliability bit-channels to reflect the noise effect on the metric in a fair way. Until this level/bit index denoted by  $i_{bu}$  in lines 43 and 46 of Algorithm 5, we do not perform backtracking although the metric drops below the threshold,  $T$  (as seen in lines 43-44 where the threshold is updated). Then, the scaling factor is obtained by
+
+$$
+\alpha = \frac {\sum_ {j = 0} ^ {n _ {k}} \log P \left(\hat {u} _ {j} ^ {(\ell)} \mid \hat {\mathbf {u}} _ {0 , j - 1} ^ {(\ell)} , \mathbf {y}\right)}{\sum_ {j = 0} ^ {n _ {k}} \log E _ {\mathbf {y}} \left[ P \left(u _ {j} \mid \mathbf {u} _ {0 , j - 1} , \mathbf {y}\right) \right]} \tag {16}
+$$
+
+This adaptation can be performed when  $\alpha > 1$ , i.e., when the actual metric is larger than the expected metric. In practice, a quantized version of this factor is more convenient to use in fixed-point arithmetic. Hence,  $\alpha_{q} = \lceil \frac{\alpha}{\Delta_{q}} \rceil \Delta_{q}$ , where  $\Delta_{q}$  is an integer. For instance, in decoding  $PAC(128,64)$ , we first follow the current best path to bit  $i_{bu} = 38$ . By taking  $\Delta_{q} = 2$  and the effect of the ceiling operator, an effective value is obtained which further reduces the complexity with almost no degradation in performance. In low and medium code rates, one can choose to calculate  $\alpha$  after the initial sequence of low-reliability bits, where the associated values in vector  $v$  are 0 (equivalent to the frozen bit-channels in polar codes).
+
+After obtaining  $\alpha$ , we need to update not only the metric of the current path, but also the metric of the examined branches,  $\mu_j^\prime$  in Fig. 4, along the current path.
+
+To update the computed metrics we simply add the difference between the updated bias  $\alpha B_{j}^{c}$  and the initial bias  $B_{j}^{c}$  to  $\mu_{j}$  and  $\mu_{j}^{\prime}$ .
+
+$$
+\mu_ {j} ^ {\prime} = \mu_ {j} ^ {\prime} + (\alpha - 1) B _ {j} ^ {c} \tag {17}
+$$
+
+Thus, the metrics are computed by considering  $\alpha$  in the next decoding steps as
+
+$$
+\mu_ {j} = \mu_ {j - 1} + m _ {j} - \alpha \cdot \log \left(1 - p _ {e, j}\right) \tag {18}
+$$
+
+Lines 10 and 16-17 of Algorithm 4 include  $\alpha$  which is initialized at the beginning of the decoding, line  $3(\alpha = 1)$ . The calculation of  $\alpha$  and the metric updating process are shown in Algorithm 5, lines 46-53.
+
+For hardware implementation, we are interested in simple arithmetic operations. Here, we suggest using an LLR-based
+
+![](images/e43d4e8fe37a44a51690ec35fb3fb804f8e8f7a5aa847898bddb7af3901b7bc2.jpg)  
+Figure 5: Bottom-up backtracking
+
+![](images/2c9c983ea47510cd3223779e01c374b55a2ec71444793f7354b5e68d2b391360.jpg)  
+Figure 6: Top-down backtracking
+
+metric instead of the metric based on the probability. To this end, we need to define  $m_j$  based on  $\lambda_0^j$ .
+
+$$
+\begin{array}{l} m _ {j} \left(\lambda_ {0} ^ {j}, \hat {u} _ {j}\right) = \log \left(P \left(\hat {u} _ {j} \mid \hat {\mathbf {u}} _ {0, j - 1}, \mathbf {y}\right)\right) = \log \left(\frac {e ^ {\left(1 - \hat {u} _ {j}\right) \lambda_ {0} ^ {j}}}{e ^ {\lambda_ {0} ^ {j}} + 1}\right) \\ = \log \left(1 + e ^ {- (1 - 2 \hat {u} _ {j}) \lambda_ {0} ^ {j}}\right) ^ {- 1} \tag {19} \\ \end{array}
+$$
+
+where the last equality holds only for  $\hat{u}_j = 0$  and 1. Now, if  $\hat{u} = \frac{1}{2}(1 - \operatorname{sgn}(\lambda_0^j))$ , the term  $e^{-(1 - 2\hat{u})\lambda_0^j} = e^{-|\lambda_0^j|}$  is small and hence  $\log(1 + e^{-|\lambda_0^j|}) \approx 0$ . Otherwise, we can approximate  $\log(1 + e^{|\lambda_0^j|}) \approx |\lambda_0^j|$ . The term  $\log(1 - p_{e,j})$  and  $B = \sum_{j=0}^{N-1} \log(1 - p_{e,j})$  can be pre-computed offline and can be used in the metric computation.
+
+Note that all the terms in (18) are negative and so are the metric values. To save one bit per metric in the storage, we can discard the bit representing the always negative sign from the values. In this case we need to modify the comparisons in the algorithms accordingly.
+
+# B. Constrained Tree Search
+
+The tree search algorithm may explore the paths on the tree that are unlikely to be correct. Unfortunately, the threshold T can only be used to prune a subset of these paths since a too tight threshold would also be likely to prune the correct path. Prior knowledge about error occurrence can be exploited in order to constrain the tree traversal. In the following, we propose several effective constraints resulting in a significant reduction in time complexity at a small performance degradation:
+
+# 1) Constraint on Number of Diversions from Best Path
+
+By using a genie that corrects the error occurrence due to channel noise, we can observe that less than  $1\%$  of the frame errors are due to more than  $b = 5$  bit-errors caused by the channel noise. Fig. 7 shows the relative frequency of error occurrence for different numbers of bit-errors. With this knowledge, we can avoid exploring the paths that diverge from the SC path at more than 5 bit-positions. If we can afford a
+
+Algorithm 4: PAC Fano Decoding  
+input: Channel LLRs  $\lambda_{\mathbf{n}}^{0,\mathbf{N} - 1}$  ,  $N$ $K$ $\mathcal{B}$ $\mathbf{p_e}$  g,  $\Delta$ $i_{bu}$  output: Information bits d   
+1  $\mathcal{CS}\gets$  generateCS(B) // Critical set [17]   
+2 cState[1,...,|g|-1]  $\leftarrow$  {0} // Current state   
+3 currState[0:K-1][1:|g|-1]  $\leftarrow$  {0}   
+4  $[i,j,T,\lambda ,\delta ,\beta ,b_{-1},\alpha_q]\gets [0,0,0,\{0\} ,\{0\} ,\{0\} ,B,1]$    
+5 [onMainPath,isBackTracking,toDiverge,biasUpdated]  $\leftarrow$  [True,False,False,False]
+
+while  $i <   N$  do   
+ $\lambda_0^i\gets$  updateLLRs(i,  $\lambda ,\beta)$  // like SCD   
+if  $i\notin \mathcal{B}$  then   
+ $[\hat{u}_i,\mathrm{cState}]\gets \mathrm{conv1bTrans}(0,\mathrm{cState},\mathrm{g})\quad /\quad \mathrm{Alg.}$  1   
+ $\mu_{i}\leftarrow \mu_{i - 1} + m(\lambda_{0}^{i},\hat{u}_{i}) - \alpha_{q}\cdot \log (1 - p_{e,j})$ $\beta \leftarrow$  updatePartialSums(i,  $\hat{u}_i,\beta)$  // like SCD   
+ $i\gets i + 1$    
+else   
+ $[\hat{u}^{(0)},\mathrm{cState}^{(0)}]\gets \mathrm{conv1bTrans}(0,\mathrm{cState},\mathrm{g})$ $[\hat{u}^{(1)},\mathrm{cState}^{(1)}]\gets \mathrm{conv1bTrans}(1,\mathrm{cState},\mathrm{g})$ $\mu^{(0)}\gets \mu_{i - 1} + m(\lambda_i^0,\hat{u}^{(0)}) - \alpha_q\cdot \log (1 - p_{e,j})$ $\mu^{(1)}\gets \mu_{i - 1} + m(\lambda_i^0,\hat{u}^{(1)}) - \alpha_q\cdot \log (1 - p_{e,j})$ $[\mu_{max},\hat{\nu}_{max}]\gets [\mu^{(0)},0]$  if  $\mu^{(0)} > \mu^{(1)}$  , else  $[\mu^{(1)},1]$ $[\mu_{min},\hat{\nu}_{min}]\gets [\mu^{(0)},0]$  if  $\mu^{(0)} <   \mu^{(1)}$  , else  $[\mu^{(1)},1]$    
+if onMAINpath=True and isBackTracking = True then   
+if  $\mu_{min} > T$  and  $\mathcal{CS}[j] = 1$  and  $j <   j_{end}$  then [onMAINpath,  $\delta_j^s$  ,  $j_{stem}] \gets [False,1,j]$ $[\lambda^s,\beta^s ]\gets [\lambda ,\beta ]$  else if  $j = j_{end}$  then   
+isBackTracking  $=$  False   
+ $T = \lfloor \frac{\mu_{end}}{\Delta}\rfloor \Delta$  //Updating threshold   
+if  $\mu_{max} > T$  then   
+if toDiverge  $=$  False then   
+ $[\hat{v}_i,\hat{u}_i]\gets [\hat{v}_{max},\hat{u}^{(\hat{v}_{max})}]$    
+if onMAINpath  $=$  True and  $\delta_j^s = 1$  then [  $\left[\mu_i,\mu_i'\right]\gets \left[\mu_{max},\mu_{min}\right]$  else [  $\left[\mu_i,\mu_i'\right]\gets \left[\mu_{max},\mu_i''\right]$ $\delta_j\gets 0$    
+else [  $\hat{v}_i,\hat{u}_i]\gets [\hat{v}_{min},\hat{u}^{(\hat{v}_{min})}]$  [  $\left[\mu_i,\mu_i'\right]\gets \left[\mu_{min},\mu_{max}\right]$  [  $\delta_j$  , toDiverge]  $\leftarrow$  [1, False] [currState[j],cState]--[cState,cState(vi)]   
+ $\beta \leftarrow$  updatePartialSums(i,  $\hat{u}_i,\beta)$    
+[i,j]  $\leftarrow$  [i+1,j+1]   
+else if biasUpdated  $=$  False and  $i <   i_{bu}$  then  $T = \lfloor \frac{\mu_{max}}{\Delta}\rfloor \Delta / /$  Updating threshold else <Go to Algorithm 5>
+
+68 return  $(\hat{\mathbf{d}}\gets \mathrm{extract}(\hat{\mathbf{v}},\mathcal{A}))$  // Dropping 0s
+
+degradation of error correction performance, we can reduce the maximum number of diversions while exploring the alternative paths. This would limit the number of visited nodes. For the example shown in Fig. 7, this number can be set to  $b = 3$  or 4 bit-positions in order to reduce the number of visited node and consequently the time complexity. We will show a result after
+
+Algorithm 5: Lines 46-67 in Algorithm 4  
+46 if biasUpdated  $=$  False and  $i = i_{bu}$  then   
+47 if  $\mu_{max} <   B$  then   
+48  $\alpha_{q} = \lceil \frac{\mu_{max}}{B\cdot\Delta_{q}}\rceil \Delta_{q}$    
+49 biasUpdated  $=$  True   
+50 for  $k\gets 0$  to  $j$  do   
+51  $\begin{array}{rl} & {\mu^{\prime}_{\mathcal{B}[k]} = \mu^{\prime}_{\mathcal{B}[k]} + (\alpha_{q} - 1)\cdot B^{c}_{\mathcal{B}[k]}}\\ & {\mu_{\mathcal{B}[0] - 1} = \mu_{\mathcal{B}[0] - 1} + (\alpha_{q} - 1)\cdot B^{c}_{\mathcal{B}[0] - 1}}\\ & {\mu_{\mathcal{B}[j] - 1} = \mu_{\mathcal{B}[j] - 1} + (\alpha_{q} - 1)\cdot B^{c}_{\mathcal{B}[j] - 1}} \end{array}$    
+52   
+53   
+54 currState[j]  $\leftarrow$  cState   
+55 if onMAINpath  $=$  False then   
+56 if  $\mu_{\mathcal{B}[j_{stem}]}^{\prime \prime} <   \mu_{max}$  then   
+57  $\begin{array}{rl}{\mu^{\prime \prime}_{\mathcal{B}[j_{stem}]}} & {\leftarrow \mu_{max}} \end{array}$    
+58 else   
+59 [jend,  $\mu_{end}]\gets [j,\mu_{max}]$    
+60 [frmMAINpath,isBackTracking]  $\leftarrow$  [True, True]   
+61 [T,  $j^{\prime}$  ,toDiverge]  $\leftarrow$  moveBack  $(\mu_{0,i}^{\prime},j,T,\delta_{0,j},\hat{\mathbf{u}},\mathcal{CS},$  frmMAINpath) //  $\mu_0^{\prime},i = \mu_0^{\prime},\mu_1^{\prime},\dots,\mu_i^{\prime}$    
+62 if toDiverge  $=$  False and  $(j^{\prime} = j_{stem}$  or  $j^{\prime} = j)$  then   
+63 onMAINpath  $=$  True   
+64 else   
+65 onMAINpath  $=$  False   
+66 [i,  $j$  ,frmMAINpath]  $\leftarrow$  [B[j],  $j^{\prime}$  ,False]   
+67 cState  $\leftarrow$  currState[j]
+
+![](images/c7732775b9762c13e34dde0ccd683cb7228f020dc5bad9e023f88d6ca3ded3ce.jpg)  
+Figure 7: Distribution (in %) of the number of error occurrence, extracted from 4000 decoding failures of PAC(128,64) with RM-profile at  $E_{b} / N_{0} = 2.5$  dB
+
+applying this constraint in Section VI. In algorithm 6, lines 21-22 implement the constraint for the maximum diversions.
+
+# 2) Exploring a Subset of bad branches
+
+The reliability of the bit-channels is known from methods such as density evolution [28]. Hence, during backtracking, we do not need to extend the partial path to the bad branches connecting to the nodes representing high-reliability bit-channels even if they satisfy the threshold condition. Thus, we only explore the sub-paths that originate from bad branches of the low-reliability bit-channels. This might introduce a small error rate degradation (due to not exploring all the bad branches),
+
+Algorithm 6: moveBack: Checking the previous ex- amined nodes for moving backward   
+input : the channel output  $\mu^{\prime}$ $j$ $T$ $\delta_{0,j}$  ,  $\hat{\mathbf{u}}$  ,CS, frmMAINpath   
+output:  $T$ $j^{\prime}$  , toDiverge,   
+1 isMovingBack  $\leftarrow$  False   
+2 while True do   
+3  $j^{\prime}\gets j$    
+4 if frmMAINpath  $=$  True then // Top-down move   
+5 for  $k\gets 0$  to  $j^{\prime} - 1$  do if  $\mu_B^{'}[k] > T$  and  $\mathcal{CS}[k] = 1$  then [j',jstem,isMovingBack]  $\leftarrow$  [k,k,True] [s,  $\beta^{\mathrm{s}}]\gets [\lambda ,\beta ]$  break   
+8   
+9   
+10 if  $j^{\prime} = j$  then   
+11 toDiverge  $\leftarrow$  False   
+12 return [T,  $j$  , toDiverge]   
+13 else // Bottom-up move   
+14 for  $k\gets j^{\prime} - 1$  to 0 do if  $j_{stem} = k$  then  $\begin{array}{l}{j^{\prime}\gets k}\\ {\left[\lambda ,\beta \right]\gets \left[\lambda^{s},\beta^{s}\right]}\\ {\mathrm{toDiverge}\leftarrow \mathrm{False}}\\ {\mathrm{return}\left[T,j^{\prime},\mathrm{toDiverge}\right]}\\ {\mathrm{if}\mu_{B[k]}^{\prime} > T\mathrm{and}\mathcal{CS}[k] = 1\mathrm{then}}\\ {\mathrm{if}\sum (\delta_{0,k})\geq \max Diversions\mathrm{then}}\\ {\mathrm{|continue}}\\ {\mathrm{if}\delta_k = 1\mathrm{then}}\\ {\left[j^{\prime},\mathrm{isMovingBack}\right]\leftarrow [k,\mathrm{True}]}\\ {\mathrm{break}} \end{array}$    
+15   
+16   
+17   
+18   
+19   
+20   
+21   
+22   
+23   
+24   
+25   
+26 if isMovingBack  $=$  True then   
+27 [icur,istart]  $\leftarrow$  [B[j],B[j'])   
+28 [λ,β]  $\leftarrow$  updateLLRsPSs(istart,icur,u,λ,β) // Alg.3   
+29 if  $\delta_{j^{\prime}} = 0$  then   
+30 toDiverge  $\leftarrow$  True   
+31 return [T,  $j^{\prime}$  , toDiverge]   
+32 else if  $j^{\prime} = 0$  then   
+33 toDiverge  $\leftarrow$  False   
+34 return [T,  $j^{\prime}$  , toDiverge]
+
+but it reduces the time complexity significantly. To this end, we collect the indices of the low-reliability bit-channels in the critical set  $\mathcal{CS}$  [25], [17] and in the backtracking procedure, we only compare the threshold with the metrics of bad branches that are listed in the critical set. Lines 6 and 20 in Algorithm 6 enforce this constraint in top-down and bottom-up schemes (discussed in the next section), respectively.
+
+Additionally, the constraint can be set to stop decoding and declaring decoding failure when the number of steps or clock iterations exceeds some limit or the path metric drops below a
+
+certain value. This could avoid cases with excessive run-time due to visiting a huge number of nodes. Also, we can stop decoding when the path metric drops below a certain value, since in this case, the decoder either fails correcting the error(s) or it may lead to a long decoding delay due to visiting a huge number of nodes in order to find the correct path.
+
+# C. Direction of Backtracking Traversal
+
+Considering the properties of PAC codes which are mainly inherited from polar codes, we can devise different strategies that help to reduce the total number of nodes to visit during backtracking. When a decision error occurs during forward tree traversal, this error is propagated to the subsequent bits due to the sequential nature of decoding. In the conventional Fano decoding, backtracking starts from the latest decoded bit in a depth-first bottom-up direction, step by step as shown in Fig. 5. For example, in a code with 3 bits, in the first backtracking iteration shown by 1 in Fig. 5, the 3rd bit diverges from the SC path, i.e.,  $u_0 - u_1 - \bar{u}_2$ . In the 2nd backtracking iteration, the 2nd bit diverges only, i.e.,  $u_0 - \bar{u}_1 - u_2$ . Then the 2nd and 3rd bits diverge together, i.e.,  $u_0 - \bar{u}_1 - \bar{u}_2$ . This process continues towards the top of the tree until (in the worst case) all the combinations of 1-bit, 2-bit, and 3-bit diversions are explored, assuming the threshold condition is satisfied by all the branches. However, as our observations show, the probability that the first error due to channel noise has occurred at one of the first decoded bits is higher. Further, there is no point in correcting the error that occurred due to error propagation. Thus, backtracking in a top-down fashion as shown in Fig. 6 is more consistent with the location of the first error and the subsequent propagated errors.
+
+The top-down backtracking can only be performed on the bad branches that originate from the SC path as a reference path. The rest of the backtracking iterations follows the bottom-up fashion. Note that a good branch is determined as a local branch with a higher likelihood among two branches emerging from a parent node. Thus, a good branch could form a non-SC path any where on the decoding tree. However, the SC path is distinguished by following the good branches at all the decoding steps from the root to the leaf of the tree. This SC path is shown by the bold line in Fig. 5 and Fig. 6.
+
+Choosing a bad branch in the backtracking is called a diversion and its corresponding metric is denoted by a prime symbol, i.e.,  $\mu'$ , in Fig. 5 and Fig. 6. This diversion is equivalent to flipping a bit/bits [31] from the SC path in the SC decoding. In Algorithm 6, lines 5-12 and 14-25 implement the top-down and the bottom-up traversals, respectively.
+
+# D. Threshold Update Strategy
+
+When the channel noise has a high impact on the decision LLRs of low-reliability bits, as discussed in Section IV-B, the best path metric  $\mu$  drops significantly over a burst of low-reliability bit-channels such that  $\mu \ll T$ . On the other hand, at every iteration of backtracking (i.e., exploring all the potential sub-paths branching off from the current path), the threshold is reduced by  $\Delta$ . Thus, several backtracking iterations are required to satisfy  $\mu > T - m\Delta$  for  $m > 1$  ( $m$  is the number
+
+input: the channel output  $\mu^{\prime},j,T,\delta_{0,j},\hat{\mathbf{u}},\mathcal{CS},$    
+frmMAINpath   
+output:  $T,j^{\prime}$  , toDiverge,   
+1 isMovingBack  $\leftarrow$  False   
+2 while True do   
+3  $j^{\prime}\gets j$    
+4 if frmMAINpath  $=$  True then // Top-down move   
+5 for  $k\gets 0$  to  $j^{\prime} - 1$  do   
+6 if  $\mu_{\mathcal{B}[k]}^{\prime} > T$  and  $\mathcal{CS}[k] = 1$  then [j',jstem,isMovingBack]  $\leftarrow$  [k,k,True] [s,βs]  $\leftarrow$  [λ,β] break   
+8   
+9   
+10 if  $j^{\prime} = j$  then   
+11 toDiverge  $\leftarrow$  False   
+12 return [T,j,toDiverge]   
+13 else // Bottom-up move   
+14 for  $k\gets j^{\prime} - 1$  to 0 do   
+15 if  $j_{stem} = k$  then  $\begin{array}{l}{j^{\prime}\gets k}\\ {\left[\lambda ,\beta \right]\gets \left[\lambda^{s},\beta^{s}\right]}\\ {\mathrm{toDiverge}\gets \mathrm{False}}\\ {\mathrm{return}[\mathrm{T},j^{\prime},\mathrm{toDiverge}]}\\ {\mathrm{if}\mu_{\mathcal{B}[k]}^{\prime} > T\mathrm{and}\mathcal{CS}[k] = 1\mathrm{then}}\\ {\mathrm{if}\sum (\delta_{0,k})\geq \mathrm{maxDiversions~then}}\\ {\mathrm{continue}}\\ {\mathrm{if}\delta_k = 1\mathrm{then}}\\ {\mathrm{[j^{\prime},isMovingBack]}\leftarrow [k,True]}\\ {\mathrm{break}} \end{array}$    
+16   
+17   
+18   
+19   
+20   
+21   
+22   
+23   
+24   
+25   
+26 if isMovingBack  $=$  True then   
+27 [icur,istart]  $\leftarrow$  [B[j],B[j'])   
+28 [λ,β]  $\leftarrow$  updateLLRsPSs(istart,icur,u,λ,β) //Alg.3   
+29 if  $\delta_{j^{\prime}} = 0$  then   
+30 toDiverge  $\leftarrow$  True   
+31 return [T,j',toDiverge]   
+32 else if  $j^{\prime} = 0$  then   
+33 toDiverge  $\leftarrow$  False   
+34 return [T,j',toDiverge]
+
+![](images/bb8e2e33cf5651291a396fbd372527c498da61829fdb99eccc1497effe36ffd9.jpg)  
+Figure 8: Updating the Metric of Explored Branches
+
+of backtracking iterations). If we skip the  $m - 1$  iterations and just we perform one iteration and then update the threshold at once using  $T = \lfloor \frac{\mu}{\Delta} \rfloor \Delta$  to satisfy the condition  $\mu > T$ , we can proceed with the decoding of the current best path and avoid extra delay. There is a possibility that the correct path is not the most likely path and the decoder could find another path in one of the backtracking iterations that we are going to skip. However, our observation shows that the degradation due to skipping  $m - 1$  backtracking iterations is about  $0.05 \mathrm{~dB}$  at the high SNR regime. The lines 24-26 in Algorithm 4 show the implementation of this strategy.
+
+# E. Updating Expected Metrics of Explored Paths
+
+During backtracking, the sub-paths originated from the current best path through bad branches are partially explored. The exploration of the same paths (possibly with longer length) might be repeated later as we proceed with the decoding. Our aim is to benefit from the time spent to explore the sub-paths. By updating the path metric,  $\mu_j^{\prime}$ , at the bad branch originated from the current best path, as shown in Fig. 8, with the actual result of the exploration rather than the expected path metric, we may avoid re-exploring these paths in the next cycle(s) of backtracking. Since many sub-paths might originate from the same branch, we update  $\mu_j^{\prime}$  with the largest metric obtained among sub-paths. This process is performed in lines 55-57 of Algorithm 5. Here, we use  $\mu''$  instead for temporarily storing the actual path metric of first sub-path explored and then comparing it with the actual metric of any new sub-path explored later. Then  $\mu^{\prime}$  is updated in line 33 of Algorithm 4. Note that by employing the adaptive heuristic metric, the effect of this updating becomes insignificant.
+
+# VI. NUMERICAL RESULTS
+
+In this Section, the error correction performance and the complexity of different tree search algorithms with different setups, using the previously discussed tree search complexity-reduction ideas and adaptive metric, are analyzed.
+
+To obtain the numerical results in this Section, we use different rate-profiles such as Reed-Muller (RM), density evolution with Gaussian approximation, and the polarization weight (PW) [30] with minimum row-weights eliminated. Fig.9 illustrates the aforementioned rate-profiles. Here, we briefly revise the RM-profile and the modified PW-profile.
+
+![](images/fa3128e7a6b1db1b360b9142036ef0caa6627b8494f78c70b44c66004e25f4f5.jpg)  
+Figure 9: Rate-profile Schemes
+
+# 1) Reed-Muller (RM) Rate-profile
+
+The bit-channels for information bits are selected according to the row-weights  $(w_{i} = wt(g_{N}^{i})$  where  $g_{N}^{i}$  is the  $i$ -th row) of  $G_{N}$ . When the candidate bit-channels with the smallest row-weight is more than need, the more reliable ones are selected. In this case, the rate-profile is called RM-polar [29]. In this work, the reliability measure is the mean LLR obtained from density evolution with Gaussian approximation (DEGA).
+
+# 2) A Modified Polarization Weight (PW) Rate-profile
+
+In this method, the bit-channels for information bits are selected among the ones with the largest polarization weight  $(W_{i})$ ,  $W_{i} = \sum_{j=0}^{n-1} b_{j} \cdot 2^{j \cdot \frac{1}{4}}$ , where  $i = b_{n-1} \dots b_{0}$  is the binary representation of  $i$  [30]. In order to improve the distance property, we propose to freeze the selected bit-channels with minimum row-weight and replace them with the bit-channels with lower  $W_{i}$ , but larger  $w_{i}$ .
+
+In the simulations, we employ different generator polynomials (0o36, 0o133, 0o177, and 0o1563 in octal format) with constraint lengths 5,7,7, and 10, respectively. The numerical results show that the difference among them in terms of FER is negligible in the low SNR regime and small in high SNRs.
+
+Finally, for the purpose of comparison in the figures, we use the dispersion bound [8] a.k.a. Polyanskiy-Poor-Verdu (PPV) bound or finite-length bound which is a Gaussian approximation on the block error probability of finite-length block codes. Additionally, we employ lower bound on ML performance as well. This bound is obtained under list decoding with  $L = 256$  by assuming that ML decoder would fail when  $\hat{\mathbf{v}} \neq \mathbf{v}$  but  $\sum_{i=0}^{N-1} ||\hat{x}_i - y_i|| < \sum_{i=0}^{N-1} ||x_i - y_i||$  where  $\hat{\mathbf{x}} = \hat{\mathbf{v}}\mathbf{GP}_{\mathbf{n}}$ .
+
+# A. Distance Spectrum
+
+As discussed in Section III, by convolutional pre-coding, we are no longer transmitting fixed known values, e.g., 0 frozen bits, over low-reliability (bad) synthetic channels, but random values generated by a linear combination of information bits. To analyze the impact of this difference on polar codes, we use the multilevel SCLD-based search method in [27] to enumerate
+
+<sup>1</sup>Note that the RM-Polar rate profile  $\mathcal{A}^{\mathrm{RM - Polar}} = \mathcal{A}^{\mathrm{RM}}\cup \mathcal{A}^{\mathrm{Polar}}$  suggested in Section VI-1 is quite different from [29] since  $K^{\prime} = \sum_{j = 0}^{r^{\prime}}\binom{n}{j}$  channel indices forming  $\mathcal{A}^{\mathrm{RM}}$  are chosen based on the row-weight rule, among the  $\mathbf{G}_N$ -rows with weight larger than  $d_{min}$ , and the rest, that is,  $K - K^{\prime}\leq \binom{n}{r^{\prime} + 1}$  among the most reliable channels corresponding to rows with weight  $d_{min}$ , as demonstrated in Fig. 9 (middle). See the method rmPolar_build_mask in rate_profile.py on github.
+
+the codewords with the minimum Hamming distance,  $d_{\text{min}}$ . We use the size of  $L = 2^{17}$  and in each iteration we introduce a one-bit error in the positions corresponding to the minimum row weight in  $P_n$ , when the all-zero codeword is transmitted and no noise is added. Re-encoding the candidate messages remaining in the list at the end of decoding, shows that the number of codewords with the minimum Hamming weight  $d_{\text{min}} = 16$  is  $A_{16} = 94488$  for the polar code  $P(128,64)$  constructed with RM-profile, whereas  $A_{16} = 3120$  for the PAC code  $PAC(128,64)$  with the same rate profile. Furthermore, the second minimum distance for the polar code is 24 with  $A_{24} = 4465024$  while for the PAC code we observe  $A_{18} = 2696$ $A_{20} = 95828$ $A_{22} = 352311$  and  $A_{24} = 3065194$ . Note that the minimum Hamming distance for  $PAC(128,64)$  with PW [30] rate profile is  $d_{\text{min}} = 8$  with  $A_8 = 256$  and  $A_{12} = 960$  hence the FER performance of PW-profile is inferior to RM profile. Hence, PW-profile for  $PAC(128,64)$  is not considered
+
+From the truncated union bound of the block error probability under ML decoding,  $P_{e}^{ML} \approx A_{d_{min}} Q(\sqrt{2d_{min} RE_{b} / N_{0}})$  [20], we can conclude that given the same  $d_{min}$  and decoder, the code with smaller  $A_{d_{min}}$  should perform better. In [12], the authors show that a properly designed upper-triangular pre-transformation matrix for polar codes can reduce  $A_{d_{min}}$  of the concatenated code. Note that the convolutional pre-transform in PAC codes has an upper-triangular Toeplitz matrix.
+
+# B. List Decoding
+
+The list decoding of PAC codes over binary-input additive white Gaussian noise (BIAWGN) channels with BPSK modulation is simulated. The constraint length and the coefficients of the generator polynomial for the convolutional code are 7 ( $m = 6$ ) and 0o133, respectively. For PAC(128,64), the rate-profile is formed by the Reed-Muller (RM) construction [29] with dSNR=3.5. In the list decoding, different list sizes are employed and the performance is compared with the performance of the P(128,64) polar code and finite-length bound [8] as shown in Fig. 10. The performance of the RM-profile and the modified PW-profile are identical as the resulted rate-profiles are identical. A serial concatenation of CRC with relatively short codes such as PAC(128,64) does not improve the error correction performance due to a significant rate loss and negative impact on the distance properties (e.g. in the case of PAC(128,64), the minimum Hamming distance drops to  $d_{min} = 8$ ). However, an 8-bit CRC with a generator polynomial with coefficients 0xA6 improves the performance of PAC(512,256) in the high SNR regime significantly as shown in Fig. 10. The notation CxA-SCL used in Fig. 10 is defined as CRC-aided SCL decoding with x-bit CRC and  $L$  in  $\mathrm{SCL}(L)$  is the list size. The rate-profile for this code is formed by density evolution with Gaussian approximation (DEGA) [28] with dSNR=2. One can observe that as the block-length increases, the performance of PAC codes under list decoding cannot compete with that of polar codes under CRC-aided list decoding and we need to add CRC bits as the outer code to detect the correct path in the list decoding.
+
+![](images/5e92b4df205fc4079b4013f8fc44d543b877391da5b9152625f25260a226ffce.jpg)  
+Figure 10: Performance of PAC codes under list decoding
+
+![](images/133270a657967ac53bf2f014c0669183d37af65173a691b92248e5bed8090354.jpg)
+
+# C. Fano Decoding
+
+The Fano decoding algorithm provides a performance near the dispersion bound, but as a variable-complexity decoding scheme, its average time complexity is extremely high. The Fano decoding of PAC(128,64) with RM-profile over BIAWGN channel is simulated. Similar to list decoding, the constraint length and the coefficients of the generator polynomial for convolutional codes are  $7(m = 6)$  and 0o133, respectively. The non-optimized design-SNR for obtaining the pre-computed bias term is 4 dB. By applying the ideas introduced in Section IV, such as adaptive metric (AD), top-down (TD) search strategy and imposing constraint on the number of diversions (Div) from SC path, it is observed in Fig. 11 (left) and Fig. 12 (left) that while the average time complexity drops significantly by  $50\%$  to  $80\%$ , depending on the techniques employed, the degradation in error correction performance is not high. Since the curves in Fig. 12 are almost straight in semi-logarithm scale, the complexity gains are preserved at high SNR regimes as well. Fig. 12 (right) shows the computational complexity of Fano, stack, and list decoding under different parameters and techniques. The computational complexity is measured by the total number of operations per codeword (comparisons and additions) performed through the factor graph in Fig. 2. As can be seen, the computational complexity of list decoding is significantly higher than Fano and stack decoding to achieve the same performance. Fig. 12 (left) shows the time complexity in terms of time steps, where each time step is defined as the time required for processing the node(s) in one stage of the factor graph shown in Fig. 2. Although the time complexity of the list decoding is significantly lower than Fano and stack decoding (left), we note that one time step in list decoding is longer than a time step in Fano decoding, due to the required sorting process.
+
+Note that stack decoding has a lower time and computational complexity than Fano decoding because it does not need to trace back on the tree and explore other paths to find a promising one if there is any. The partial paths (sorted
+
+![](images/b0b5daf04c24be7cdd6e4d8740ffcc705b4431d78fbc9b69aee374f78e4c4683.jpg)  
+Figure 11: Performance of PAC codes with RM rate-profil under Fano decoding with constrained search (CS), adaptive metric (AD), top-down tree traversal (TD), and a limited number of diversions (Div.) in comparison with other decoding schemes SC, SCL, stack, and Viterbi. Also showing performance of polar codes under Fano decoding "Fano (Polar)".
+
+![](images/a6e094dfca66251e70dc6bb40adfc42e2d1330bfd4cfcf34e0f2c68503d8f045.jpg)
+
+with respect to the metric) and their associated intermediate information are already available in the stack. Hence, stack decoding can save a significant amount of computations and time at the cost of a huge memory requirement. To compute the number of time steps (or clock cycles), we consider an architecture that is similar to that in [18]. In this type of design,  $2N - 2$  time steps are required to decode a codeword [18]. However, in Fano decoding, due to possible backtracking, the number of required time steps is typically significantly larger than  $2N - 2$ . Here, we take the average time steps over a large number of decoding iteration into account. For comparison, we also implemented Fano decoding for polar codes with RM-profile. Although, the average computational complexities of polar codes and PAC codes under Fano decoding are close, due to poor weight distribution of polar codes, PAC codes outperform polar codes.
+
+Another important observation in Fig. 11 (left) is that the performance gain of PAC codes over polar codes under Fano decoding is quite significant while the time and computational complexity of these two families of codes are close. However, this performance gain under list decoding as shown in Fig. 10 is smaller. Additionally, one can observe from the comparison of the performance of PAC(128,64) under list, stack, and Fano decoding in Fig. 11 (right) that Fano decoding provides a similar performance as list decoding but outperforms the stack decoding, while it requires significantly less hardware resources than list decoding and stack decoding. As shown in Table I, the memory required for paths, intermediate LLRs and partial sums, which account for the majority of memory space, for list and stack decoding is  $L$  and  $D$  times that of Fano decoding. Note that in order to obtain a FER performance similar to Fano decoding, we need a very large list size  $L$  or stack depth  $D$  in the order of 128 or 256. This highlights
+
+![](images/6dbd893b4db3c65674e1ec1ab20bd7b452009967a881b49757dd570affbe736d.jpg)
+
+![](images/f4f0add8cabb9258a713f8e808d036ab2e18779e6ac3726ccc704fa467039a1c.jpg)  
+Figure 12: Time and computational Complexity.
+
+![](images/526fb70efd67ddaa0d39b2189b710443fda1815affcfa125665220965b97e3ae.jpg)
+
+the huge gap between Fano decoder and the other decoders in terms of hardware resources
+
+<table><tr><td></td><td>Fano</td><td>Stack</td><td>List</td></tr><tr><td colspan="4">Memory Requirement [bits]</td></tr><tr><td>Path memory, u</td><td>N</td><td>DN</td><td>LN</td></tr><tr><td>Intermediate LLRs, λ</td><td>(N-1)Q1</td><td>D(N-1)Q1</td><td>L(N-1)Q1</td></tr><tr><td>Partial Sums, β</td><td>N-1</td><td>D(N-1)</td><td>L(N-1)</td></tr><tr><td>Path Metric, M</td><td>2(N-K)Q2</td><td>DQ2</td><td>LQ2</td></tr><tr><td>Current State</td><td>K·m</td><td>D·m</td><td>L·m</td></tr><tr><td>Critical Set flag, CS</td><td>N</td><td>0</td><td>0</td></tr><tr><td>Diversion flag, δ</td><td>N</td><td>0</td><td>0</td></tr><tr><td>Error probability, pe</td><td>NQ3</td><td>NQ3</td><td>0</td></tr><tr><td colspan="4">Computing Resources</td></tr><tr><td>Processing Elements</td><td>P</td><td>P</td><td>LP</td></tr><tr><td>Comparison</td><td>A comparator</td><td>D-sorter</td><td>2L-sorter</td></tr></table>
+
+Table I: Comparison of hardware resources
+
+The parameters  $P$ , and  $Q_{i}$  for  $i = 1,2,3$  denote the number of processing elements (PE) [18] and the number of quantization bits, respectively.
+
+Finally, Viterbi algorithm (VA) [32] with similar hardware resources as list decoding (except the  $2L$ -value sorter, replaced by a 2-value comparator) provides a close performance to Fano and list decoders.
+
+# VII. CONCLUSION
+
+In this paper, we investigate the implementation of list decoding and Fano decoding for PAC codes. Under list decoding, there is a significant performance gap between polar codes and PAC codes. However, this gap between polar and PAC codes is reduced when employing another layer of concatenation, such as CRC or parity check (PC) bits. Also, the results show that a large list size  $L$  or stack depth  $D$  of 256 under list and stack decoding, respectively, is needed to approach the performance of PAC codes under Fano decoding.
+
+Fano decoding has a large average time complexity but a small computational complexity relative to list decoding. For mitigating the time complexity, we propose several techniques
+
+and strategies including adaptive path metric and a heuristic to estimate a metric for the continuation of the partial paths, search constraints, and a combination of top-down and bottom-up search strategies. This strategies reduce the computational complexity as well. Also, to overcome the difficulty of obtaining the intermediate LLRs and partial sums during backtracking, we propose an algorithm to compute these intermediate information (LLRs and partial sums) efficiently without using extra memory to store them or any need to restart the decoding process. The numerical results show that by using these techniques, the average time complexity drops by  $50\%$  to  $80\%$  at the cost of a relatively small performance degradation. The adaptive heuristic metric and the search strategies proposed in this paper can be used in polar coding as well. Although the time complexity of the Fano Decoding is variable and high, the software Fano decoder is significantly faster than software list decoder with large list size without using parallelism.
+
+Due to need for backtracking in Fano decoding, as the code-length increases, the frequency of backtracking through the decoding increases prohibitively. Hence, we conclude that the Fano decoding can be used for short codes with medium to low code rates.
+
+Overall, it appears that any proper pre-transformation such as convolutional transform [7], moving parity check bits [10], dynamic frozen bits [11], use of CRC bits for error detection [6], and a combination of them can improve the distance spectrum and results in an error correction performance gain. However, each pre-transformation may provide a different gain depending on the rate-profile, block-length and code rate.
+
+# ACKNOWLEDGMENT
+
+The authors are grateful to the anonymous reviewers for their useful comments and suggestions which improved the clarity and the inclusiveness of the paper.
+
+# REFERENCES
+
+[1] E. Arikan, "Channel polarization: A method for constructing capacity-achieving codes for symmetric binary-input memoryless channels," IEEE Trans. Inf. Theory, vol. 55, no. 7, pp. 3051-3073, Jul. 2009.  
+[2] E. Arikan, “On the Origin of Polar Coding,” in IEEE Journal on Sel. Areas in Commun., vol. 34, no. 2, pp. 209-223, Feb. 2016.  
+[3] J. Massey, "Capacity, cutoff rate, and coding for a direct-detection optical channel," IEEE Trans. Commun., vol. 29, pp. 1615-1621, Nov. 1981.  
+[4] M. S. Pinsker, “On the complexity of decoding,” Problemy Peredachi Informatsii, vol. 1, no. 1, pp. 84-86, 1965.  
+[5] H. Imai and S. Hirakawa, “A new multilevel coding method using errorcorrecting codes,” IEEE Transactions on Information Theory, vol. 23, pp. 371-377, May 1977.  
+[6] I. Tal and A. Vardy, "List decoding of polar codes," IEEE Int. Symp. on Information Theory, St. Petersburg, Russia, Jul. 2011, pp. 1-5.  
+[7] E. Arikan, "From sequential decoding to channel polarization and back again," arXiv preprint arXiv:1908.09594 (2019).  
+[8] Y. Polyanskiy, H. V. Poor and S. Verdu, "Channel Coding Rate in the Finite Blocklength Regime," IEEE Trans. Inf. Theory, vol. 56, no. 5, pp. 2307-2359, May 2010.  
+[9] A. Balatsoukas-Stimming, M. Bastani Parizi, and A. Burg, "LLR-based successive cancellation list decoding of polar codes," IEEE Trans. Signal Processing, vol. 63, no. 19, pp. 5165-5179, Oct 2015.  
+[10] H. Zhang et al., "Parity-Check Polar Coding for 5G and Beyond," 2018 IEEE Int. Conf. Commun. (ICC), Kansas City, MO, 2018, pp. 1-7.  
+[11] P. Trifonov and G. Trofimiuk, “A randomized construction of polar subcodes,” 2017 IEEE International Symposium on Information Theory (ISIT), Aachen, 2017, pp. 1863-1867.
+
+[12] B. Li, H. Zhang, J. Gu, "On Pre-transformed Polar Codes," arXiv preprint arXiv:1912.06359 (2019).  
+[13] C. Lin and J. Anderson, “M-algorithm decoding of channel convolutional codes,” Princeton Conference on Information Sciences and Systems, Princeton, NJ, Mar. 1986, pp. 362-366.  
+[14] M. Rowshan, A. Burg and E. Viterbo, "Polarization-adjusted Convolutional (PAC) Codes: Fano Decoding vs List Decoding," arXiv preprint arXiv:2002.06805 (2020).  
+[15] H. Yao, A. Fazeli and A. Vardy, “Polarization-adjusted Convolutional (PAC) Codes: Fano Decoding vs List Decoding,” arXiv preprint arXiv:2005.13711 (2020).  
+[16] M. Rowshan and E. Viterbo, “Stepped List Decoding for Polar Codes,” 2018 IEEE 10th International Symposium on Turbo Codes & Iterative Information Processing (ISTC), Hong Kong, Hong Kong, 2018, pp. 1-5.  
+[17] M. Rowshan and E. Viterbo, “Improved List Decoding of Polar Codes by Shifted-pruning,” 2019 IEEE Information Theory Workshop (ITW), Visby, Sweden, Aug 25-28, 2019, pp. 1-5.  
+[18] C. Leroux, A. J. Raymond, G. Sarkis, I. Tal, A. Vardy, W. J. Gross, "Hardware implementation of successive-cancellation decoders for polar codes", J. Signal Process. Syst., vol. 69, no. 3, pp. 305-315, Jul. 2012  
+[19] M. Rowshan, E. Viterbo, R. Micheloni and A. Marelli, "Repetition-assisted Decoding of Polar Codes," in IET Electron. Lett., vol. 55, no. 5, pp. 270-272, 2019.  
+[20] T. K. Moon, "Error Correction Coding: Mathematical Methods and Algorithms," John Wiley & Sons, New Jersey, 2005, pp 451-534.  
+[21] R. G. Gallager, "Information Theory and Reliable Communication," John Wiley & Sons, New Jersey, 1968, pp 263-286.  
+[22] P. Trifonov, “A Score Function for Sequential Decoding of Polar Codes,” 2018 IEEE International Symposium on Information Theory (ISIT), Vail, CO, 2018, pp. 1470-1474.  
+[23] M. Jeong and S. Hong, "SC-Fano Decoding of Polar Codes," in IEEE Access, vol. 7, pp. 81682-81690, 2019.  
+[24] M. Sikora and D. J. Costello, "Supercode heuristics for tree search decoding," 2008 IEEE Inf. Theory Workshop, Porto, 2008, pp. 411-415.  
+[25] J. Cui, Z. Zhang, X. Zhang, H. Li and Q. Zeng, “A Low-Complexity Improved Progressive Bit-Flipping Decoding for Polar Codes,” 2018 IEEE 4th International Conference on Computer and Communications (ICCC), Chengdu, China, 2018, pp. 39-44.  
+[26] W. Tong, “Polar Code Design Aspects and Future Challenges,” invited talk in special session Polar Codes at IEEE Inf. Theory Workshop, Visby, Sweden, Aug. 2019  
+[27] Q. Zhang, A. Liu, X. Pan and K. Pan, "CRC Code Design for List Decoding of Polar Codes," in IEEE Communications Letters, vol. 21, no. 6, pp. 1229-1232, June 2017.  
+[28] P. Trifonov, "Efficient design and decoding of polar codes," IEEE Trans. on Communications, vol. 60, no. 11 pp. 3221-3227, Nov. 2012.  
+[29] B. Li, H. Shen, and D. Tse, “A RM-polar codes,” arXiv preprint arXiv:1407.5483 (2014).  
+[30] X. Liu et al., “ $\beta$ -expansion A Theoretical Framework for Fast and Recursive Construction of Polar Codes,” in Proc GLOBECOM, Dec. 2017.  
+[31] O. Afsiadis, A. Balatsoukas-Stimming, and A. Burg, “A low-complexity improved successive cancellation decoder for polar codes,” IEEE 48th Asilomar Conf. on Signals, Systems and Computers, 2014, pp. 2116-2120.  
+[32] M. Rowshan, and E. Viterbo, “List Viterbi Decoding of PAC Codes,” arXiv preprint, 2020. [Online]. Available: https://arxiv.org/abs/2007.05353.

2002.06xxx/2002.06805/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c9862f902c1c5efa49232660a66ad76776b81e2dbdabcdc474e3d51a50a80cc
+size 588511

2002.06xxx/2002.06820/b62d4baf-aeea-4bff-82d1-b6e4044e1482_content_list.json

@@ -0,0 +1,1975 @@
+[
+    {
+        "type": "text",
+        "text": "Text Perceptron: Towards End-to-End Arbitrary-Shaped Text Spotting",
+        "text_level": 1,
+        "bbox": [
+            140,
+            119,
+            854,
+            142
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Liang Qiao $^{1}$  Sanli Tang $^{1}$  Zhanzhan Cheng $^{21*}$  Yunlu Xu $^{1}$  Yi Niu $^{1}$  Shiliang Pu $^{1}$  Fei Wu $^{2}$",
+        "text_level": 1,
+        "bbox": [
+            138,
+            170,
+            854,
+            189
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "$^{1}$ Hikvision Research Institute, China;  $^{2}$ Zhejiang University, China",
+        "bbox": [
+            276,
+            188,
+            720,
+            203
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{qiaoliang6, tangsanli, chengzhanzhan, xuyunlu, niuyi, pushiliang}@hikvision.com wufei@cs.zju.edu.cn",
+        "bbox": [
+            135,
+            203,
+            861,
+            218
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract",
+        "text_level": 1,
+        "bbox": [
+            248,
+            273,
+            313,
+            286
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many approaches have recently been proposed to detect irregular scene text and achieved promising results. However, their localization results may not well satisfy the following text recognition part mainly because of two reasons: 1) recognizing arbitrary shaped text is still a challenging task, and 2) prevalent non-trainable pipeline strategies between text detection and text recognition will lead to suboptimal performances. To handle this incompatibility problem, in this paper we propose an end-to-end trainable text spotting approach named Text Perceptron. Concretely, Text Perceptron first employs an efficient segmentation-based text detector that learns the latent text reading order and boundary information. Then a novel Shape Transform Module (abbr. STM) is designed to transform the detected feature regions into regular morphologies without extra parameters. It unites text detection and the following recognition part into a whole framework, and helps the whole network achieve global optimization. Experiments show that our method achieves competitive performance on two standard text benchmarks, i.e., ICDAR 2013 and ICDAR 2015, and also obviously outperforms existing methods on irregular text benchmarks SCUT-CTW1500 and Total-Text.",
+        "bbox": [
+            98,
+            292,
+            460,
+            559
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction",
+        "text_level": 1,
+        "bbox": [
+            210,
+            575,
+            351,
+            590
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Spotting scene text is a hot research topic due to its various applications such as invoice recognition and road sign reading in advanced driver assistance systems. With the advances of deep learning, many deep neural-network-based methods (Wang et al. 2012; Jaderberg, Vedaldi, and Zisserman 2014; Li, Wang, and Shen 2017; Liu et al. 2018; He et al. 2018) have been proposed for spotting text from a natural image, and have achieved promising results.",
+        "bbox": [
+            81,
+            594,
+            477,
+            705
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, in the real-world, many texts appear in arbitrary layouts (e.g. multi-oriented or curved), which make quadrangle-based methods (Liao et al. 2017; Zhou et al. 2017; Zhang et al. 2018) cannot be well adapted in many situations. Some works (Dai et al. 2018; Long et al. 2018; Xie et al. 2019) began to focus on irregular text localization by segmenting text masks as detection results and achieved relatively good performance in terms of Intersection-over-Union (IoU) evaluation. However, they still leave many challenges to the following recognizing task. For example, a",
+        "bbox": [
+            81,
+            705,
+            477,
+            844
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/d3275e8fb3295d88187bc1739b67da1ad612cc0f29a9fa909ab4731ed8bb59ba.jpg",
+        "image_caption": [
+            "(a)",
+            "Figure 1: Illustration of the traditional pipelined text spotting process and Text Perceptron. Sub-figure (a) is a traditional pipeline strategy by combining text detection, rectification and recognition into a framework. Sub-figure (b) is an end-to-end trainable text spotting approach by applying the proposed STM. The black and red arrows mean the forward and backward processing, respectively. The red points denote generated fiducial points generated."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            542,
+            276,
+            911,
+            422
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "common pipeline of text spotting is to crop the masked texts within bounding-box regions, and then adopt a recognition model with rectification functions to generate final character sequences. Unfortunately, such strategy decreases the robustness of text spotting mainly in two aspects: 1) one needs to design extra rectification network, like methods in (Luo, Jin, and Sun 2019) and (Zhan and Lu 2019), to transform irregular texts into regular ones. In practice, it is hard to be optimized without human-labeled geometric ground truth, and also introduces extra computational cost. 2) Pipelined text spotting methods are not end-to-end trainable and result in suboptimal performance because the errors from the recognition model cannot be utilized for optimizing the text detector. In Figure 1(a), although the text detector provides true positive results, the clipped text masks still lead to wrong recognition results. We denote above problem incompatibility between text detection and recognition.",
+        "bbox": [
+            514,
+            580,
+            911,
+            816
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, two methods were proposed for spotting irregular text in the end-to-end manners. (Lyu et al. 2018) proposed an end-to-end trainable network inspired by Mask-RCNN (He et al. 2017), aiming at reading irregular text character-by-character. However, this approach loses the",
+        "bbox": [
+            514,
+            818,
+            913,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "aside_text",
+        "text": "arXiv:2002.06820v2 [cs.CV] 25 Oct 2021",
+        "bbox": [
+            22,
+            267,
+            57,
+            707
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_footnote",
+        "text": "*Corresponding author. Copyright © 2020, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.",
+        "bbox": [
+            81,
+            849,
+            478,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "context information among characters, and also requires amounts of expenditure on character-level annotations. (Sun et al. 2018) attempted to transform irregular text with a perspective ROI module, but this operation has difficulty in handling some complicated distortions such as curved shapes.",
+        "bbox": [
+            86,
+            69,
+            477,
+            137
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "These limitations motivate us to explore new and more effective method to spot irregular scene text. Inspired by (Shi et al. 2016), thin-plate splines (abbr. TPS) (Bookstein 1989) may be a feasible approach to rectify various-shaped text into regular form using a group of fiducial points. Although these points can be implicitly learned from cropped rectangular text by a deep spatial transform network (Jaderberg et al. 2015), the learning process of fiducial points is hard to be optimized. As a result, such methods are not robust especially for texts in some complex distortions.",
+        "bbox": [
+            86,
+            138,
+            477,
+            276
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In a more achievable way, we attempt to solve this problem as follows: 1) explicitly finding out a group of reliable fiducial points over text regions so that irregular text can be directly rectified by TPS, and 2) dynamically tuning fiducial points by back-propagating errors from recognition to detection. Specifically, we develop a Shape Transform Module (abbr. STM) to build a robust irregular text spotter and eliminate the incompatibility problem. STM integrates irregular text detection and recognition into an end-to-end trainable model, and iteratively adjusts fiducial points to satisfy the following recognition module. As shown in Figure 1(b), in the early training stage, despite high IoU in detection evaluation, the transformed text regions may not satisfy the recognition module. With end-to-end training, fiducial points will be gradually adjusted to obtain better recognition results.",
+        "bbox": [
+            86,
+            277,
+            477,
+            484
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose an end-to-end trainable irregular text spotter named Text Perceptron which consists of three parts: 1) A segmentation-based detection module which orderly describes a text region as four subregions: the center region, head, tail and top&bottom boundary regions, detailed in Section 3. Here, boundary information not only helps separate text regions that are very close to each other, but also contributes to capture latent reading-orders. 2) STM for iteratively generating potential fiducial points and dynamically tuning their positions, which alleviates incompatibility between text detection and recognition. 3) A sequence-based recognition module for generating final character sequences.",
+        "bbox": [
+            86,
+            484,
+            477,
+            662
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Major contributions of this paper are listed as follows: 1) We design an efficient order-aware text detector to extract arbitrary-shaped text. 2) We develop the differentiable STM devoting to optimizing both detection and recognition in an end-to-end trainable manner. 3) Extensive experiments show that our method achieves competitive results on two regular text benchmarks, and also significantly surpasses previous methods on two irregular text benchmarks.",
+        "bbox": [
+            86,
+            664,
+            477,
+            773
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Works",
+        "text_level": 1,
+        "bbox": [
+            205,
+            787,
+            359,
+            801
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here, we briefly review the recent advances in text detection and end-to-end text spotting.",
+        "bbox": [
+            86,
+            805,
+            477,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Text Detection",
+        "text_level": 1,
+        "bbox": [
+            86,
+            844,
+            236,
+            857
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Methods of text detection can usually be divided into two categories: anchor-based methods and segmentation-based",
+        "bbox": [
+            86,
+            861,
+            477,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "methods.",
+        "bbox": [
+            521,
+            70,
+            578,
+            80
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Anchor-based methods. These methods usually follow the technique of Faster R-CNN (Ren et al. 2015) or SSD (Liu et al. 2016) that uses anchors to provide rectangular region proposals. To overcome the significantly varying aspect ratios of texts, (Liao et al. 2017) designed long default boxes and filters to enhance text detection, and then (Liao, Shi, and Bai 2018) extended this work by generating quadrilateral boxes to fit the texts with perspective distortions. (Ma et al. 2018) proposed a rotated regional proposal network to enhance multi-oriented text detection. To detect arbitrary-shaped text, many Mask RCNN (He et al. 2017)-based methods, e.g., CSE (Liu et al. 2019b), LOMO (Zhang et al. 2019) and SPCNet (Xie et al. 2019), were developed to capture irregular texts and achieved good performance.",
+        "bbox": [
+            519,
+            87,
+            911,
+            282
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Segmentation-based methods. These methods usually learn a global semantic segmentation without region proposals, which is more efficient compared to anchor-based methods. Segmentation can easily be used to describe text in arbitrary shapes but highly relies on complicated post-processes to separate different text instances. To solve this problem, (Wu and Natarajan 2017) introduced boundary semantic segmentation to reduce the efforts in post-proposing. EAST (Zhou et al. 2017) learned a shrink text region and directly regressed the multi-oriented quadrilateral boxes from text pixels. (Long et al. 2018) designed a series of overlapping disks with different radii and orientations to describe arbitrary-shaped text regions. (Wang et al. 2019) proposed a method that first generates text region masks with various shrinkage ratios and then uses a progressive expansion algorithm to produce the final text region masks. (Xu et al. 2019) predicted each text pixel and assigned them with a regression value denoting the direction to its nearest boundary to help separate different texts.",
+        "bbox": [
+            519,
+            286,
+            911,
+            549
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 Text Spotting",
+        "text_level": 1,
+        "bbox": [
+            521,
+            577,
+            663,
+            593
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most of existing text-spotting methods (Liao, Shi, and Bai 2018; Liao et al. 2017; Wang et al. 2012) generally first localize each text with a trained detector such as (Zhou et al. 2017) and then recognize the cropped text region with a sequence decoder (Shi, Bai, and Yao 2017). For sufficiently exploiting the complementarity between detection and recognition, some works (He et al. 2018; Li, Wang, and Shen 2017; Liu et al. 2018) were proposed to jointly detect and recognize text instances in an end-to-end trainable manner, which utilized the recognition information to optimize the localization task. However, these methods are incapable of spotting arbitrary-shaped text due to the irrationality of rectangles or quadrangles. To address these problems, (Sun et al. 2018) adopted a perspective ROI transforming module to rectify perspective text, but this operation still has difficulty in handling serious curved text. (Lyu et al. 2018) proposed an end-to-end text spotter inspired by Mask-RCNN for detecting arbitrary-shaped text character-by-character, but this method loses the context information among characters and also requires character-level location annotations.",
+        "bbox": [
+            519,
+            611,
+            911,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 Methodology",
+        "text_level": 1,
+        "bbox": [
+            207,
+            66,
+            354,
+            84
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Overview",
+        "text_level": 1,
+        "bbox": [
+            83,
+            85,
+            202,
+            101
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose a text spotter named Text Perceptron whose overall architecture is shown in Figure 2, which consists of three parts:",
+        "bbox": [
+            81,
+            104,
+            478,
+            145
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "(1) The text detector adopts ResNet (He et al. 2016) and Feature Pyramid Network (abbr. FPN) (Lin et al. 2017) as backbone, and is implemented by simultaneously learning three tasks: an order-aware multiple-class semantic segmentation, a corner regression, and a boundary offset regression. In this way, the text detector can localize arbitrary-shaped text and achieve state of the art on text detection.",
+            "(2) STM is responsible for uniting text detection and recognition into an end-to-end trainable framework. This module iteratively generates fiducial points on text boundaries based on the predicted score and geometry maps, and then applies the differentiable TPS to rectify irregular text into regular form.",
+            "(3) The text recognizer is used to generate the predicted character sequences, which can be any traditional sequence-based method, such as CRNN (Shi, Bai, and Yao 2017), attention-based method (Cheng et al. 2017)."
+        ],
+        "bbox": [
+            81,
+            146,
+            478,
+            382
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 Text Detection Module",
+        "text_level": 1,
+        "bbox": [
+            83,
+            392,
+            302,
+            406
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Order-aware Semantic Segmentation The text detector learns a global multi-class semantic segmentation, which is much more efficient than those Mask-RCNN-based methods. Inspired by (Xue, Lu, and Zhan 2018), we introduce text boundary segmentation to separate different text instances. Considering text with arbitrary shapes, we further category boundaries into head, tail, and top&bottom boundary types, respectively. In Figure 3, the green, yellow, blue and pink regions separately denote the head, tail, top&bottom boundaries and the center text region. Here, head and tail also capture potential information about text reading order (e.g. top to bottom for vertical text). Therefore, we learn the text detector by conducting the multi-class semantic segmentation task using several binary Dices Coefficient Loss (Milletari, Navab, and Ahmadi 2016) (denoted by  $\\mathcal{L}_{cls}$ ).",
+        "bbox": [
+            81,
+            410,
+            480,
+            619
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Corner and Boundary Regressions To boost the arbitrary-shaped segmentation performance as well as provide position information for fiducial points, we integrate two other regression tasks into the learning process, as shown in Figure 3 (c) and (d),",
+        "bbox": [
+            81,
+            625,
+            478,
+            696
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- Corner Regression. For pixels in head and tail regions, we regress the offsets (e.g. the  $\\Delta dx_{1}, \\Delta dy_{1}, \\Delta dx_{2}$  and  $\\Delta dy_{2}$ ) to their corresponding two corner points, which is denoted by  $\\mathcal{L}_{\\text {corner }}$ .",
+            "- Boundary Offset Regression. For pixels in center region, we regress the vertical and horizontal offsets to their nearest boundaries (e.g. the  $\\Delta dx_1'$ ,  $\\Delta dy_1'$ ,  $\\Delta dx_2'$  and  $\\Delta dy_2'$ ), which is denoted by  $\\mathcal{L}_{boundary}$ ."
+        ],
+        "bbox": [
+            84,
+            699,
+            478,
+            816
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, we adopt a proximity regression strategy to solve the inaccurate large-offset regression problem like in EAST (Zhou et al. 2017). That is, the Corner Regressions only regress their neighboring corresponding corners. In the Boundary Offset Regression, we can simply ignore or lower",
+        "bbox": [
+            81,
+            818,
+            480,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "the loss weights of regression value generated from the larger side (e.g.  $\\Delta dx_1'$ ,  $\\Delta dx_2'$  for a horizontal text). In this way, our detector can well describe the texts with very large width-height ratios. Both of two regressions are trained with Smooth-L1 loss:",
+        "bbox": [
+            514,
+            69,
+            911,
+            138
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathcal {L} _ {\\text {c o r n e r}} \\text {o r} \\mathcal {L} _ {\\text {b o u n d a r y}} = \\left\\{ \\begin{array}{l l} 0. 5 (\\sigma z) ^ {2} & | z | <   1 / \\sigma^ {2} \\\\ | z | - 0. 5 / \\sigma^ {2} & \\text {o t h e r w i s e} \\end{array} , \\right. \\tag {1}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            527,
+            142,
+            911,
+            186
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where  $z$  is the geometry offset value, and  $\\sigma$  is a tunable parameter (default by 3).",
+        "bbox": [
+            514,
+            186,
+            911,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The Detection Inference In the forward process, we generate predicted segmentation maps by orderly overlaying the segmented center, head, tail, and top&bottom boundary feature maps. Subsequently, text instances can be found as connected-regions of center pixels. We see that all text instances are easily separated by boundaries, and different head (or tail) regions will also be separated by up&bottom boundary region. Therefore, each center region can be matched with a neighboring pair of head and tail region during the pixel traversal process. Specifically, for text with more than 1 head (or tail) regions, we choose the one with the maximum area as its head (or tail). While for predicted center text regions without corresponding head or tail region, we just treat them as false positives and filter them out.",
+        "bbox": [
+            514,
+            220,
+            911,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Ground-Truth Generation The process of ground-truth of segmentation and geometry map can be divided into three steps, as shown in Figure 3.",
+        "bbox": [
+            514,
+            422,
+            911,
+            464
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(1) Identifying four corners. We denote the 1st and 4th corners as the two corners in the head region, while the 2nd and 3rd corners are corresponding to the tail region, as shown in Figure 3(a). This weak-supervised information is not provided by most of the datasets, but we found that in general, polygon points  $\\{P_1',\\dots,P_M'\\}$  are usually annotated from the left-top corner to the left-bottom corner in a clockwise manner for text instances. Differently, for polygon annotations with a fixed number of points like SCUT-CTW1500 (Liu et al. 2019a), we can directly identify the four corner points by their indexes. However, for annotations with varying number of points like Total-Text (Ch'ng and Chan 2017), we can only obtain the 1st corner  $(P_1')$  and 4th corner  $(P_M')$ . To search the 2nd and 3rd corners, we design a heuristic corner estimating strategy based on the assumptions that 1) two boundaries neighboring tail are nearly parallel, and 2) two neighbor interior angles of tail are closed to  $\\frac{\\pi}{2}$ . Therefore, the probable 2nd corner can be estimated as:",
+        "bbox": [
+            514,
+            464,
+            913,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\arg \\min  _ {P _ {i} ^ {\\prime}} [ \\gamma (| \\angle P _ {i} ^ {\\prime} - \\frac {\\pi}{2} | + | \\angle P _ {i + 1} ^ {\\prime} - \\frac {\\pi}{2} |) + | \\angle P _ {i} ^ {\\prime} + \\angle P _ {i + 1} ^ {\\prime} - \\pi | ] \\tag {2}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            519,
+            720,
+            911,
+            763
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where  $\\angle P_i^\\prime$  is the degree of interior angle for polygon point  $P_{i}^{\\prime}$ , and  $\\gamma$  is a weighting parameter (default by 0.5). Then the point  $P_{i + 1}^{\\prime}$  following  $P_{i}^{\\prime}$  is treated as the 3-rd corner point. Specifically, for vertical text annotated from the top-left corner, we reassign its top-right corner as the 1st key corner.",
+        "bbox": [
+            514,
+            762,
+            911,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(2) Generating score maps. Figure 3(b) shows the generated score maps. We firstly generate the center text regions follows by their annotations and then generate boundaries by referring to the shrink and expansion mechanism used",
+        "bbox": [
+            514,
+            833,
+            913,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/5a5ca9c156c240be64d70a34df163c205eeb2b7f20af00bd3b5d2e2d636869c8.jpg",
+        "image_caption": [
+            "Figure 2: The workflow of Text Perceptron. The black and red arrows separately mean the forward and backward process."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            107,
+            66,
+            883,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/dbe4d3dd71afbf0aaac326800c3a925508c24e299dc65f59cf5bd355314638ee.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            107,
+            320,
+            287,
+            393
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/a3900f6a82a2bf59b2ff793deaabac575c637b7cee7fcf2b3e081f758e4ebb75.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            292,
+            321,
+            454,
+            393
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/24b4ec94b3a0ba40f2b4aa147873560359555da1f59fc2e0fa9a20884e540161.jpg",
+        "image_caption": [
+            "Figure 3: The label generation process."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            104,
+            398,
+            302,
+            467
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/c2567035035050163ae4561c553271666e27ed3cf8e8f01ee72a9f3eafad1532.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            299,
+            398,
+            455,
+            467
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "in (Wu and Natarajan 2017). Differently, the head and tail score maps are generated by only applying the shrink operation, which submerges part of the center region. And top&bottom boundary region is then generated by applying both the expansion and shrink operations, which will partly submerge all of the other regions. In this way, we need less effort on post-processing to separate different text instances and it is easy to match their relative head (or tail) region with a center region. Boundary widths are constrained as  $\\delta \\times \\min Len$ , where minLen is the minimum length of edges in the text polygon and  $\\delta$  is a ratio parameter. Here, we set  $\\delta = 0.2$  for top&bottom boundaries and  $\\delta = 0.3$  for head and tail.",
+        "bbox": [
+            81,
+            523,
+            478,
+            702
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(3) Generating geometry maps. As mentioned in Corner and Boundary Regression, pixels belonging to the head region are assigned geometry offset values in 4 channels  $(\\Delta dx_{1}, \\Delta dy_{1}, \\Delta dx_{2}$  and  $\\Delta dy_{2})$  corresponding the 1st and 4th key corner, as shown in Figure 3(c). Similarly, the geometry map of the tail region is also formed in 4 channels. The geometry values of the center text region are computed as the horizontal and vertical offsets to the nearest boundaries, shown as  $\\Delta dx_{1}^{\\prime}, \\Delta dy_{1}^{\\prime}, \\Delta dx_{2}^{\\prime}$  and  $\\Delta dy_{2}^{\\prime}$  in Figure 3(d).",
+        "bbox": [
+            81,
+            704,
+            478,
+            830
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Shape Transform Module",
+        "text_level": 1,
+        "bbox": [
+            83,
+            840,
+            323,
+            857
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "STM is designed to iteratively generate initial fiducial points around text instances and transform text feature regions into",
+        "bbox": [
+            81,
+            859,
+            478,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/ee26c35bdc91ca027badac72a56d0fc3c240fc553f1ebf14f20e3c607989e998.jpg",
+        "image_caption": [
+            "Figure 4: The fiducial points generation process."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            547,
+            320,
+            890,
+            407
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "regular shapes with the supervision of following recognition.",
+        "bbox": [
+            514,
+            460,
+            911,
+            474
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Fiducial Points Generation With the learned segmentation maps and geometry maps, we propose to generate preset  $2 \\times N$  potential fiducial points ( $N \\geq 2$ ) for each text instance, denoted as  $\\{P_1, \\dots, P_N, P_{N+1}, \\dots, P_{2 \\times N}\\}$ , which can be divided into two stages.",
+        "bbox": [
+            514,
+            481,
+            911,
+            550
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(1) Generating four corner points. We first obtain the positions of four corner fiducial points for each text feature region by averaging the coordinate of pixels with their predicted offsets in corresponding boundaries. Taking the 1-st corner point  $(P_{1})$  as an example, it is computed based on all pixels in the head region  $\\mathcal{R}_{\\mathcal{H}}$ , and formalized by",
+        "bbox": [
+            514,
+            551,
+            913,
+            635
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nP _ {1} = \\left(\\frac {\\sum_ {(x , y) \\in \\mathcal {R} _ {\\mathcal {H}}} (x + \\Delta d x)}{| | \\mathcal {R} _ {\\mathcal {H}} | |}, \\frac {\\sum_ {(x , y) \\in \\mathcal {R} _ {\\mathcal {H}}} (y + \\Delta d y)}{| | \\mathcal {R} _ {\\mathcal {H}} | |}\\right) \\tag {3}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            521,
+            642,
+            911,
+            694
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where  $||.||$  means the number of pixels in  $\\mathcal{R}_{\\mathcal{H}}$ , and  $\\Delta dx, \\Delta dy$  mean the predicted corner offsets corresponding to  $P_{1}$ . The other three corner points  $(P_{N}$  in  $\\mathcal{R}_{\\mathcal{H}}, P_{N+1}, P_{2 \\times N}$  in tail region  $\\mathcal{R}_{\\mathcal{T}})$  can be calculated similarly.",
+        "bbox": [
+            514,
+            694,
+            911,
+            750
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(2) Generating other fiducial points. After obtaining four corner fiducial points, the other fiducial points can be located using a dichotomous method. This strategy is suitable for any arbitrary shaped text even serious curved or in different reading orders.",
+        "bbox": [
+            514,
+            750,
+            913,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An example of the generation process is shown in Figure 4. We firstly connect  $P_{1}$  and  $P_{N}$ , and judge whether the connected line has a longer span in horizontal direction or vertical direction. Without loss generality, if it has a longer span in horizontal direction as shown, we calculate a middle",
+        "bbox": [
+            514,
+            819,
+            911,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "point  $P_{\\lfloor (N + 1) / 2\\rfloor}$  between  $P_{1}$  and  $P_N$  whose x-coordinate formed as:",
+        "bbox": [
+            81,
+            68,
+            478,
+            95
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nx _ {m i d} = \\frac {\\lceil (N - 1) / 2 \\rceil}{N - 1} \\times P _ {1, x} + \\frac {\\lfloor (N - 1) / 2 \\rfloor}{N - 1} \\times P _ {N, x} \\tag {4}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            89,
+            98,
+            478,
+            128
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Then we use the learned boundary offsets from detector to predict the y-coordinate of  $P_{\\lfloor (N + 1) / 2\\rfloor}$ . Concretely, we define the band region  $\\mathcal{B}_i$  as the part of the center region  $\\mathcal{R}_C$ :",
+        "bbox": [
+            83,
+            132,
+            478,
+            176
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathcal {B} _ {\\lfloor \\frac {1 + N}{2} \\rfloor} = \\{(x, y) \\in \\mathcal {R} _ {\\mathcal {C}} | x \\in [ x _ {m i d} - \\Delta e p, x _ {m i d} + \\Delta e p ] \\} \\tag {5}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            84,
+            179,
+            478,
+            210
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where  $\\Delta ep$  defines the range of the band region (default by 3). Similar to the generation of four corner fiducial points, we can use all pixels in the corresponding band region to predict an average y-coordinate for this fiducial point. Then, the coordinate of  $P_{\\lfloor (N + 1) / 2\\rfloor}$  can be formed as:",
+        "bbox": [
+            81,
+            210,
+            478,
+            282
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nP _ {\\left\\lfloor \\frac {1 + N}{2} \\right\\rfloor} = \\left(x _ {m i d}, \\frac {\\sum_ {\\left(x _ {t} , y _ {t}\\right) \\in \\mathcal {B} _ {\\left\\lfloor \\frac {1 + N}{2} \\right\\rfloor}} y _ {t} + \\Delta d y _ {t} ^ {\\prime}}{\\left| \\left| \\mathcal {B} _ {\\left\\lfloor \\frac {1 + N}{2} \\right\\rfloor} \\right| \\right|}\\right) \\tag {6}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            102,
+            286,
+            478,
+            335
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where  $\\Delta dy_t'$  is the learned boundary offset value to the top-boundary  $(\\Delta dy_1')$ . This process can be iteratively conducted using corresponding  $\\Delta dx_t'$  or  $\\Delta dy_t'$  until all of the fiducial points be calculated. Similarly, the fiducial points on the bottom boundary can be calculated by connecting  $P_{N+1}$  and  $P_{2\\times N}$  and using the same strategy.",
+        "bbox": [
+            81,
+            339,
+            478,
+            425
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Shape Transformation With the generated potential fiducial points on text boundaries, we can explicitly transform an irregular feature region  $\\mathcal{R}$  into a regular form  $\\mathcal{R}^*$ . Here, fiducial points are mapped into some preset positions of the transformed feature map by directly applying TPS to the original feature regions. Specifically, we transform all feature regions into a region with width  $W$  and height  $H$ :",
+        "bbox": [
+            81,
+            429,
+            480,
+            527
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathcal {R} ^ {*} = T P S ^ {- 1} (\\mathcal {P}, \\mathcal {R}), \\tag {7}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            204,
+            531,
+            478,
+            547
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the fiducial point  $P_{i}\\in \\mathcal{P}$  will be mapped into:",
+        "bbox": [
+            83,
+            551,
+            434,
+            568
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nP _ {i} ^ {*} = \\left\\{ \\begin{array}{c} \\left((i - 1) \\times \\frac {H - 2 \\times \\Delta w}{N - 1} + \\Delta w, \\Delta h\\right), 1 \\leq i \\leq N \\\\ \\left((2 \\times N - i) \\times \\frac {H - 2 \\times \\Delta w}{N - 1} + \\Delta w, H - \\Delta h\\right), \\\\ N <   i \\leq 2 \\times N \\end{array} \\right. \\tag {8}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            83,
+            571,
+            478,
+            646
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where  $\\Delta w$  and  $\\Delta h$  are preset offsets (default by  $0.1\\times W$  and  $0.1\\times H$ ) to preserve space for fiducial points tuning.",
+        "bbox": [
+            81,
+            646,
+            478,
+            674
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Then, all text feature regions are packed into a batch and sent to the following recognition part. Here, we assume that the final predicted character strings  $Y$  are generated as:",
+        "bbox": [
+            81,
+            674,
+            480,
+            715
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nY = \\operatorname {R e c o g} \\left(\\mathcal {R} ^ {*}\\right), \\tag {9}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            218,
+            720,
+            478,
+            736
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where 'Recog' is the sequence recognition process.",
+        "bbox": [
+            83,
+            741,
+            424,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Dynamically Finetuning Fiducial Points The assumption here is that although text detector supervised by polygon annotations can generate satisfying polygon masks, the results may not always suitable for the following recognition. To avoid the suboptimal problem and improve overall performance, Text Perceptron will back-propagate differences from 'Recog' to each pixel value in  $\\mathcal{R}$  via STM, i.e.",
+        "bbox": [
+            81,
+            761,
+            480,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\Delta \\mathcal {R} = \\frac {\\partial Y}{\\partial \\mathcal {R} ^ {*}} \\frac {\\partial \\mathcal {R} ^ {*}}{\\partial \\mathcal {R}}. \\tag {10}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            863,
+            478,
+            893
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Then we can calculate the adjustment values of  $\\mathcal{P}$  by",
+        "bbox": [
+            517,
+            68,
+            867,
+            84
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\Delta \\mathcal {P} = \\frac {\\partial Y}{\\partial \\mathcal {R} ^ {*}} \\frac {\\partial \\mathcal {R} ^ {*}}{\\partial \\mathcal {R}} \\frac {\\partial \\mathcal {R}}{\\partial \\mathcal {P}}. \\tag {11}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            637,
+            89,
+            911,
+            121
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, we back-propagate  $\\Delta \\mathcal{P}$  to the corresponding geometry maps in head, tail and band regions. Formally, for each pixel  $pi$ , we have",
+        "bbox": [
+            516,
+            126,
+            913,
+            169
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\Delta p i = \\Delta \\hat {p i} + \\frac {\\Delta \\mathcal {P}}{\\| \\mathcal {R} _ {\\mathcal {R} ^ {*}} \\|}, \\tag {12}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            633,
+            176,
+            911,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where  $\\mathcal{R}_{\\mathcal{R}^*}\\in \\{\\mathcal{R}_H,\\mathcal{R}_T,\\mathcal{B}\\}$  and  $\\Delta \\hat{p i}$  is calculated from  $\\mathcal{L}_{\\text{corner}}$  or  $\\mathcal{L}_{\\text{boundary}}$ .",
+        "bbox": [
+            516,
+            217,
+            913,
+            248
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 End-to-End Training",
+        "text_level": 1,
+        "bbox": [
+            516,
+            258,
+            725,
+            273
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our recognition part can be implemented by any sequence-based recognition network, such as CRNN (Shi, Bai, and Yao 2017) or (Cheng et al. 2017).",
+        "bbox": [
+            516,
+            277,
+            913,
+            319
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The loss of the whole framework contains the following parts: the order-aware multi-class semantic segmentation, the corner regressions for pixels in head and tail, the boundary offset regression for pixels in the center region and the word recognition, that is,",
+        "bbox": [
+            516,
+            319,
+            913,
+            390
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathcal {L} = \\mathcal {L} _ {c l s} + \\lambda_ {b} \\mathcal {L} _ {\\text {c o r n e r}} + \\lambda_ {c} \\mathcal {L} _ {\\text {b o u n d a r y}} + \\lambda_ {r} \\mathcal {L} _ {\\text {r e c o g}}, \\tag {13}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            529,
+            397,
+            911,
+            415
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where  $\\lambda_{b},\\lambda_{c}$  and  $\\lambda_{r}$  are auto-tunable parameters, and  $\\mathcal{L}_{recog}$  is the loss from recognition.",
+        "bbox": [
+            516,
+            421,
+            911,
+            449
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since learning fiducial points highly depends on the segmentation map learning, we use a soft loss weight strategy to automatically tune  $\\lambda_{b},\\lambda_{c}$  and  $\\lambda_{r}$ . In other words, in the first few epochs, fiducial points are mainly adjusted by regression tasks; while at the last few epochs, points are mainly restricted to recognition. Formally,",
+        "bbox": [
+            516,
+            449,
+            913,
+            532
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\lambda_ {b} = \\lambda_ {c} = \\lambda^ {*} - \\max  (0. 0 2 \\times E, 0. 5), \\tag {14}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            584,
+            541,
+            911,
+            556
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\lambda_ {r} = \\min  \\left(\\max  (- 0. 1 + 0. 0 2 \\times E, 0), \\lambda_ {r} ^ {*}\\right), \\tag {15}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            555,
+            564,
+            911,
+            580
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where  $E$  is the number of training epochs, and  $\\lambda^{*}$  and  $\\lambda_r^*$  separately control the maximum loss weight of regression and recognition. In our experiments, we set  $\\lambda^{*} = 0.6$  and  $\\lambda_r^* = 0.8$ .",
+        "bbox": [
+            516,
+            584,
+            913,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments",
+        "text_level": 1,
+        "bbox": [
+            643,
+            654,
+            785,
+            671
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Datasets",
+        "text_level": 1,
+        "bbox": [
+            516,
+            674,
+            627,
+            688
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The datasets used in this work are listed as follows:",
+        "bbox": [
+            516,
+            693,
+            857,
+            705
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "SynthText 800k (Gupta, Vedaldi, and Zisserman 2016) contains 800k synthetic images that are generated by rendering synthetic text with natural images, and it is used as the pre-training dataset.",
+        "bbox": [
+            516,
+            707,
+            913,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ICDAR2013 (Karatzas et al. 2013) (abbr. IC13) is collected as the focused scene text, which is mainly horizontal text containing 229 training images and 233 testing images.",
+        "bbox": [
+            516,
+            763,
+            913,
+            805
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ICDAR2015 (Karatzas et al. 2015) (abbr. IC15) is collected as incidental scene text consisting of many perspective text. It contains 1000 training and 500 testing images.",
+        "bbox": [
+            516,
+            805,
+            913,
+            847
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Total-Text (Ch'ng and Chan 2017) consists of multi-oriented and curve text and is therefore one of the important benchmarks in evaluating shape-robust text spotting tasks. It",
+        "bbox": [
+            516,
+            845,
+            913,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/21775afdfd3d5de31a0fe0826b09a76eb405812829b2457723f2f0769fef016d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset</td><td rowspan=\"2\">Method</td><td colspan=\"4\">Detection</td><td colspan=\"3\">End-to-End</td><td colspan=\"3\">Word Spotting</td></tr><tr><td>P</td><td>R</td><td>F</td><td>FPS</td><td>S</td><td>W</td><td>G</td><td>S</td><td>W</td><td>G</td></tr><tr><td rowspan=\"9\">IC13</td><td>Textboxes (2017)</td><td>88.0</td><td>83.0</td><td>85.0</td><td>1.37</td><td>91.6</td><td>89.7</td><td>83.9</td><td>93.9</td><td>92.0</td><td>85.9</td></tr><tr><td>Li et al. (2017)</td><td>91.4</td><td>80.5</td><td>85.6</td><td>-</td><td>91.1</td><td>89.8</td><td>84.6</td><td>94.2</td><td>92.4</td><td>88.2</td></tr><tr><td>TextSpotter (2017)</td><td>-</td><td>-</td><td>-</td><td>-</td><td>89.0</td><td>86.0</td><td>77.0</td><td>92.0</td><td>89.0</td><td>81.0</td></tr><tr><td>He et al. (2018)</td><td>91.0</td><td>88.0</td><td>90.0</td><td>-</td><td>91.0</td><td>89.0</td><td>86.0</td><td>93.0</td><td>92.0</td><td>87.0</td></tr><tr><td>FOTS (2018)</td><td>-</td><td>-</td><td>88.2</td><td>23.9</td><td>88.8</td><td>87.1</td><td>80.8</td><td>92.7</td><td>90.7</td><td>83.5</td></tr><tr><td>TextNet* (2018)</td><td>93.3</td><td>89.4</td><td>91.3</td><td>-</td><td>89.8</td><td>88.9</td><td>83.0</td><td>94.6</td><td>94.5</td><td>87.0</td></tr><tr><td>Mask TextSpotter* (2018)</td><td>95.0</td><td>88.6</td><td>91.7</td><td>4.6</td><td>92.2</td><td>91.1</td><td>86.5</td><td>92.5</td><td>92.0</td><td>88.2</td></tr><tr><td>Ours (2-stage)</td><td>92.7</td><td>88.7</td><td>90.7</td><td>10.3</td><td>90.8</td><td>90.0</td><td>84.4</td><td>93.7</td><td>93.1</td><td>86.2</td></tr><tr><td>Ours (End-to-end)</td><td>94.7</td><td>88.9</td><td>91.7</td><td>10.3</td><td>91.4</td><td>90.7</td><td>85.8</td><td>94.9</td><td>94.0</td><td>88.5</td></tr><tr><td rowspan=\"11\">IC15</td><td>EAST (2017)</td><td>83.6</td><td>73.5</td><td>78.2</td><td>13.2</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td>TextSnake* (2018)</td><td>84.9</td><td>80.4</td><td>82.6</td><td>1.1</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td>SPCNet* (2019)</td><td>88.7</td><td>85.8</td><td>87.2</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td>PSENet-1s* (2019)</td><td>86.9</td><td>84.5</td><td>85.7</td><td>1.6</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td>TextSpotter (2017)</td><td>-</td><td>-</td><td>-</td><td>-</td><td>54.0</td><td>51.0</td><td>47.0</td><td>58.0</td><td>53.0</td><td>51.0</td></tr><tr><td>He et al. (2018)</td><td>87.0</td><td>86.0</td><td>87.0</td><td>-</td><td>82.0</td><td>77.0</td><td>63.0</td><td>85.0</td><td>80.0</td><td>65.0</td></tr><tr><td>FOTS (2018)</td><td>91.0</td><td>85.2</td><td>88.0</td><td>7.8</td><td>81.1</td><td>75.9</td><td>60.8</td><td>84.7</td><td>79.3</td><td>63.3</td></tr><tr><td>TextNet* (2018)</td><td>89.4</td><td>85.4</td><td>87.4</td><td>-</td><td>78.7</td><td>74.9</td><td>60.5</td><td>82.4</td><td>78.4</td><td>62.4</td></tr><tr><td>Mask TextSpotter* (2018)</td><td>91.6</td><td>81.0</td><td>86.0</td><td>4.8</td><td>79.3</td><td>73.0</td><td>62.4</td><td>79.3</td><td>74.5</td><td>64.2</td></tr><tr><td>Ours (2-stage)</td><td>91.6</td><td>81.8</td><td>86.4</td><td>8.8</td><td>78.2</td><td>74.5</td><td>63.0</td><td>80.6</td><td>76.6</td><td>65.5</td></tr><tr><td>Ours (End-to-end)</td><td>92.3</td><td>82.5</td><td>87.1</td><td>8.8</td><td>80.5</td><td>76.6</td><td>65.1</td><td>84.1</td><td>79.4</td><td>67.9</td></tr></table>",
+        "bbox": [
+            173,
+            65,
+            823,
+            335
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Results on IC13 and IC15. 'P', 'R' and 'F' separately mean the 'Precision', 'Recall' and 'F-Measure'. 'S', 'W' and 'G' mean recognition with strong, weak and generic lexicon, respectively. Superscript '\\*' means that the method considered the detection of irregular text.",
+        "bbox": [
+            81,
+            345,
+            911,
+            390
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "contains 1255 training and 300 testing images, and each text is annotated by a word-level polygon with transcription.",
+        "bbox": [
+            81,
+            415,
+            477,
+            443
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "SCUT-CTW1500 (Liu et al. 2019a) (abbr. CTW1500) is a curved text benchmark consists of 1000 training and 500 testing images. In contrast to Total-Text, all text instances are annotated with 14-point polygons in the line-level.",
+        "bbox": [
+            81,
+            443,
+            478,
+            501
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Implementation Details",
+        "text_level": 1,
+        "bbox": [
+            83,
+            510,
+            308,
+            525
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The detector uses ResNet-50 as the backbone and further be modified following the suggestions from (Huang et al. 2017) for obtaining dense features. We remove the fifth stage, modify conv4_1 layer with stride=1 instead of 2, and apply atrous convolution for all subsequent layers to maintain enough receptive field. Training loss is calculated from the outputs of three stages: the fourth stage  $(8\\times)$ , the third stage  $(8\\times)$ , and the second stage  $(4\\times)$  feature maps of FPN, and testing is only conducted on  $4\\times$  feature map. We directly adopt the attention-based network described in (Cheng et al. 2017) as the recognition model. All experiments are implemented in Caffe with 8 32GB-Tesla-V100 GPUs. The code will be published soon.",
+        "bbox": [
+            81,
+            527,
+            478,
+            708
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Data augmentation. We conduct data augmentation by simultaneously 1) randomly scaling the longer side of input images with length in range of [720, 1600], 2) randomly rotating the images with the degree in range of  $[-15^{\\circ}, 15^{\\circ}]$ , and 3) applying random brightness, jitters, and contrast on input images.",
+        "bbox": [
+            81,
+            708,
+            478,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training details. The networks are trained by SGD with batch-size=8, momentum=0.9 and weight-decay=5 × 10 $^{-4}$ . For both detection and recognition part, we separately pretrain them on SynthText for 5 epochs with initial learning rate 2 × 10 $^{-3}$ . Then, we jointly fine-tune the whole network using the soft loss weight strategy mention previously on each dataset for other 80 epochs. The initial learning rate is",
+        "bbox": [
+            81,
+            791,
+            480,
+            891
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$1 \\times 10^{-3}$ . The learning rate will be divided by 10 for every 20 epochs. Online hard example mining (OHEM) (Shrivastava, Gupta, and Girshick 2016) strategy is also applied for balancing the foreground and background samples.",
+        "bbox": [
+            514,
+            415,
+            911,
+            470
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Testing details. We resize input images with the longer side 1440 for IC13, 2000 for IC15, 1350 for Total-text and 1250 for CTW1500. We set the number of fiducial points as 4 for two standard text datasets and 14 for two irregular text datasets. The detection results are given by connecting the predicted fiducial points. Note that, all images are tested in the single-scale.",
+        "bbox": [
+            514,
+            470,
+            913,
+            569
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Results on Standard Text Benchmarks",
+        "text_level": 1,
+        "bbox": [
+            516,
+            579,
+            856,
+            593
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation on horizontal text. We first evaluate our method on IC13 mainly consisting of horizontal texts. Table 1 shows the results, and represents that our method achieve competitive performance compared to previous methods on the 'Detection', 'End-to-End' and 'Word Spotting' evaluation items. Besides, our method is also very efficient and achieves '10.3' of Frame Per Second (abbr. FPS).",
+        "bbox": [
+            514,
+            595,
+            911,
+            694
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation on perspective text. We evaluate our method on IC15 containing many perspective texts, and the results are shown in Table 1. In the detection stage, our method achieves comparable performance with the irregular text spotting methods such as TextNet and Mask TextSpotter. In the 'End-to-End' and 'Word Spotting' tasks, our method significantly outperforms previous irregular-text-based methods and achieves the remarkable state-of-the-art performance on general lexicon cases, which demonstrates the effectiveness of our method.",
+        "bbox": [
+            514,
+            694,
+            913,
+            832
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 Results on Irregular Text Benchmarks",
+        "text_level": 1,
+        "bbox": [
+            516,
+            842,
+            856,
+            858
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We test our method on two irregular text benchmarks: Total-Text and CTW1500, as shown in Table 2 and 3. In the de",
+        "bbox": [
+            516,
+            859,
+            911,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/1dbc7cc65f3d5bebf2ef5863750c8e9f445e5937d7b1184e04c059d407f4da1f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"3\">Detection</td><td colspan=\"2\">End-to-End</td></tr><tr><td>P</td><td>R</td><td>F</td><td>None</td><td>Full</td></tr><tr><td>TextSnake (2018)</td><td>82.7</td><td>74.5</td><td>78.4</td><td>-</td><td>-</td></tr><tr><td>FTSN (2018)</td><td>84.7</td><td>78.0</td><td>81.3</td><td>-</td><td>-</td></tr><tr><td>TextField (2019)</td><td>81.2</td><td>79.9</td><td>80.6</td><td>-</td><td>-</td></tr><tr><td>SPCNet (2019)</td><td>83.0</td><td>82.8</td><td>82.9</td><td>-</td><td>-</td></tr><tr><td>CSE (2019b)</td><td>81.4</td><td>79.1</td><td>80.2</td><td>-</td><td>-</td></tr><tr><td>PSENet-1s (2019)</td><td>84.0</td><td>78.0</td><td>80.9</td><td>-</td><td>-</td></tr><tr><td>LOMO (2019)</td><td>75.7</td><td>88.6</td><td>81.6</td><td>-</td><td>-</td></tr><tr><td>Mask TextSpotter (2018)</td><td>69.0</td><td>55.0</td><td>61.3</td><td>52.9</td><td>71.8</td></tr><tr><td>TextNet (2018)</td><td>68.2</td><td>59.5</td><td>63.5</td><td>54.0</td><td>-</td></tr><tr><td>Ours (2-stage)</td><td>88.1</td><td>78.9</td><td>83.3</td><td>63.3</td><td>73.9</td></tr><tr><td>Ours (End-to-end)</td><td>88.8</td><td>81.8</td><td>85.2</td><td>69.7</td><td>78.3</td></tr></table>",
+        "bbox": [
+            112,
+            65,
+            450,
+            209
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "tection stage, our method outperforms all previous methods and surpasses the best result  $2.3\\%$  on Total-Text and  $2.4\\%$  on CTW1500 on F-measure evaluation.",
+        "bbox": [
+            81,
+            275,
+            478,
+            316
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Moreover, our method significantly outperforms previous methods on the precision item, which attributes to the false-positive filtering strategy. In the end-to-end case, our method significantly surpasses the best-reported results (Sun et al. 2018) by  $15.7\\%$  on 'None' and the best of results (Lyu et al. 2018) by  $6.5\\%$  on 'Full', which mainly attributes to STM achieving the end-to-end training strategies. Since CTW1500 releases the recognition annotation recently, there is no reported result on the end-to-end evaluation. Here, we report the end-to-end results lexicon-freeely, and believe our method will significantly outperform previous methods.",
+        "bbox": [
+            81,
+            316,
+            478,
+            470
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8c949cb8e3dcbb2d64f6c5937b6530546d97834fb4539096f88ba8a8b2a937d1.jpg",
+        "table_caption": [
+            "Table 2: Result on Total-Text. \"Full\" indicates lexicons of all images are combined. \"None\" means lexicon-free."
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"3\">Detection</td><td>End-to-End</td></tr><tr><td>P</td><td>R</td><td>F</td><td>None</td></tr><tr><td>TextSnake (2018)</td><td>69.7</td><td>85.3</td><td>75.6</td><td>-</td></tr><tr><td>TextField (2019)</td><td>83.0</td><td>79.8</td><td>81.4</td><td>-</td></tr><tr><td>CSE (2019b)</td><td>81.1</td><td>76.0</td><td>78.4</td><td>-</td></tr><tr><td>PSENet-1s (2019)</td><td>84.8</td><td>79.7</td><td>82.2</td><td>-</td></tr><tr><td>LOMO (2019)</td><td>69.6</td><td>89.2</td><td>78.4</td><td>-</td></tr><tr><td>Ours (2-stage)</td><td>88.7</td><td>78.2</td><td>83.1</td><td>48.6</td></tr><tr><td>Ours (End-to-end)</td><td>87.5</td><td>81.9</td><td>84.6</td><td>57.0</td></tr></table>",
+        "bbox": [
+            132,
+            483,
+            431,
+            583
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In summary, the results on Total-Text and CTW1500 demonstrate the effectiveness of our method for arbitrary-shaped text spotting. Moreover, compared with 2-staged results, the end-to-end trainable strategy markedly boosts text spotting performance, especially for the recognition part.",
+        "bbox": [
+            81,
+            621,
+            478,
+            691
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.5 Ablation Results of Fiducial Points",
+        "text_level": 1,
+        "bbox": [
+            83,
+            703,
+            393,
+            717
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The number of fiducial points directly influences the detection and end-to-end results when texts are displayed in the curve or even waved shapes. Table 4 shows the result that how the number of fiducial points affects the detection and end-to-end evaluations on different benchmarks. It is clear that 4 points annotation is enough for regular benchmark such as IC15, and there is almost no influence on the result when the number of fiducial points increases. On the other hand, for two irregular benchmarks, the detection F-score as well as end-to-end F-score raises along with the increasing number of fiducial points, and the performance becomes stable when  $2 \\times N \\geq 10$ .",
+        "bbox": [
+            81,
+            720,
+            478,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/addde07bf5259c984c4507703aa9b3bf447fe8602ecc1db5e80295f95e782925.jpg",
+        "table_caption": [
+            "Table 3: Result on CTW1500. 'None' means lexicon-free."
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset</td><td colspan=\"8\">Number of fiducial points</td></tr><tr><td>4</td><td>6</td><td>8</td><td>10</td><td>12</td><td>14</td><td>16</td><td>18</td></tr><tr><td>IC15</td><td>87.1</td><td>87.0</td><td>87.0</td><td>86.9</td><td>87.0</td><td>86.9</td><td>86.8</td><td>86.8</td></tr><tr><td>Total-Text</td><td>71.5</td><td>82.8</td><td>84.5</td><td>85.0</td><td>85.2</td><td>85.2</td><td>85.2</td><td>85.3</td></tr><tr><td>CTW1500</td><td>68.7</td><td>81.9</td><td>84.1</td><td>84.3</td><td>84.4</td><td>84.6</td><td>84.4</td><td>84.5</td></tr><tr><td>Total-Text</td><td>55.9</td><td>68.5</td><td>69.8</td><td>69.6</td><td>69.8</td><td>69.7</td><td>69.5</td><td>69.9</td></tr><tr><td>CTW1500</td><td>40.2</td><td>52.2</td><td>56.2</td><td>57.0</td><td>57.1</td><td>57.0</td><td>56.5</td><td>56.4</td></tr></table>",
+        "bbox": [
+            529,
+            65,
+            903,
+            148
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Detection (top part) and end-to-end (bottom part) evaluation (F-measure) under varied number of fiducial points for different benchmarks.",
+        "bbox": [
+            514,
+            157,
+            911,
+            200
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1b358eb28937f4a020b5eb7a2c03eb8c30391abfd6993c4b9d7e3f7c7b80f582.jpg",
+        "image_caption": [
+            "N=2"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            521,
+            214,
+            619,
+            277
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/4058d7caa4e665f2aea1b84093b927ba6ef30b70f1c02469bd5bd2e08e494d45.jpg",
+        "image_caption": [
+            "N=3"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            622,
+            214,
+            714,
+            277
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3c5d9f93d1da7d76c3681142d9b2b7991de90401371b75249eba9948c7f7980c.jpg",
+        "image_caption": [
+            "N=5",
+            "Figure 5: Results of Text Perceptron with different number of fiducial points (4,6,10,12)."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            718,
+            214,
+            812,
+            277
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/09849c0bc7515eaf7e898fb5d836fcc176f6c568b238b30e2e2689375d4dc2ee.jpg",
+        "image_caption": [
+            "N=6"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            815,
+            214,
+            911,
+            277
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 shows an example of end-to-end evaluation under different number of fiducial points. We see that the generated text masks by few fiducial points are hard to cover the entire curve texts. As the growing number of fiducial points, STM has more power to catch and rectify irregular text instances, which yields higher recognition accuracy.",
+        "bbox": [
+            514,
+            359,
+            911,
+            443
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In contrast to previous works, our method can generate any fixed number of fiducial points on text boundaries. The fiducial points generation method can also be used to annotate arbitrary-shaped text.",
+        "bbox": [
+            516,
+            443,
+            911,
+            500
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.6 Visualization Results",
+        "text_level": 1,
+        "bbox": [
+            517,
+            511,
+            723,
+            526
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c3159fd9b8b69be8d348b035db10733f5459d3a5ca972f282473d4192046ea76.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            522,
+            542,
+            645,
+            614
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/859b16d31c15b99fd90a0e0cc90ea1c8296957686a725cc29c60b7168771373b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            522,
+            616,
+            643,
+            681
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/604c4c3b46be864b8853eb4529042b3ed32820b237d3d36082609bac0f0ced36.jpg",
+        "image_caption": [
+            "Figure 6: Visualization results on origin images."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            522,
+            681,
+            643,
+            744
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/535445b731db597f7357ffbc1ada3c5e257620cd4eb3f42cd5e7c49c959acc72.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            647,
+            544,
+            767,
+            614
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/aa057c6fcfb38dea1529b41097c6b9f9a213f696b76330345cae48f65be1c317.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            647,
+            616,
+            767,
+            681
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/4729d4d065189713a97b5210634d51964a929d719c4a4ec6aff996a607fccfca.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            647,
+            681,
+            767,
+            744
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/afdd9645fb106dfc10cfd24a071cb834c051e93cffde3902dddfa40c18541380.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            785,
+            542,
+            898,
+            563
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b7dcb35e90b89a6bb7a492a54273ad8e3926255c16c51c2b24456cb8063d2e52.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            787,
+            568,
+            874,
+            588
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7ede54a778143ecb656b8a8f05e2dd6eeebfbfc6898d04140caa9ffc68fe2a19.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            787,
+            595,
+            872,
+            614
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5b34686e6d265baab16de4eaeae97e0aa49134747c1877399bdfdc94a5fed59a.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            787,
+            619,
+            888,
+            643
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f0a596a3e44ad6a494ac775180b87c6a5be2b4e157faa77faf7d37016d487deb.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            787,
+            648,
+            903,
+            675
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a8047e20532a377b50d842852af5d10e9527f52cf0cfaf34a4ee83f1a4db84a0.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            787,
+            683,
+            877,
+            710
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/4c8ed77adac87aabbc0f9638077743ded65948aeb99952bcf5076be40226b8c7.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            787,
+            715,
+            885,
+            739
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 and Figure 7 demonstrate some visualization results in Total-Text and CTW1500 datasets. Text Perceptron shows its powerful ability in catching the reading order of irregular scene text (including curved, long perspective, vertical, etc.), and with the help of fiducial points which can further recognize text in a much simpler way. From the segmentation results, we find that many of text-like false posi",
+        "bbox": [
+            514,
+            790,
+            913,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/88e5dba7330a5921431da9bffc7fbee85cf8f8fcc49e9fe0c4dab405a0152b2d.jpg",
+        "image_caption": [
+            "Figure 7: Visualization result on Total-Text and CTW1500. The first row displays the segmented results and the second row shows the end-to-end results. Fiducial points are also visualized as colored points on text boundaries."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            106,
+            66,
+            890,
+            354
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/3bde24202cfaea7f4ee3358daf334de9c60dfa08e62240ef88c2c5420c5950b7.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            125,
+            424,
+            315,
+            507
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/3a2a9b4669b639a56dcf3ba19ac8cc1dc77709ade15baed85182c1b220bced8a.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            321,
+            422,
+            437,
+            493
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/37bcb011a3d23d973197eea5336c16de239113e6f7cad8d67baacce20fd39abf.jpg",
+        "image_caption": [
+            "Figure 8: Visualization of some failure samples."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            125,
+            508,
+            313,
+            590
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/8cacb221934d97822fb4fcae5f6733fea3622e4c0fa0c9a87f04d990947ad1e5.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            323,
+            500,
+            437,
+            569
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/2b3b41e9181a88ec352ff5135a89f2118a60658b46e019a2379b80a145481983.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            325,
+            575,
+            437,
+            590
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "tives have been filtered out due to the missing of head or tail boundary. This means the features of head or tail boundaries contain the different semantic information with that of the center region. Figure 6 also shows the visualization of some rectified irregular text instances, in which vertical texts can be well transformed into the \"lying-down\" shapes.",
+        "bbox": [
+            81,
+            654,
+            480,
+            739
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Failure Samples We illustrate some failure samples that are difficult for Text Perceptron, as shown in Figure 8.",
+        "bbox": [
+            81,
+            748,
+            478,
+            776
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Overlapped text. It is a common tough task for segmentation-based detection methods. Pixels belong to the center text region for one text instance may also become the boundary region for another one. Even though our orderly overlaying strategy allows pixels to have multiple classes and makes boundary pixels have higher priority than center text pixels, which encourages inner instance to be separated from the outer instance. But experiments found that",
+        "bbox": [
+            81,
+            777,
+            478,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "many times, the boundaries of inner instance cannot be fully recalled to embrace such instance, and connecting between center text pixels will result in the failure of detecting such inner an instance.",
+        "bbox": [
+            514,
+            426,
+            911,
+            482
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Recognition of vertical instance. On the one hand, vertical texts appear in little frequency in the common datasets. One the other hand, although Text Perceptron can read vertical instances from left to right, it is still a challenge for recognition algorithm to distinguish whether the instance is a horizontal text or a 'lying-down' vertical one. Therefore, there are some correctly detected instances cannot be recognized right. It is also a common difficult problem for all existing recognition algorithms.",
+        "bbox": [
+            514,
+            483,
+            913,
+            609
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion",
+        "text_level": 1,
+        "bbox": [
+            650,
+            619,
+            779,
+            636
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose an end-to-end trainable text spotter named Text Perceptron aiming at spotting text with arbitrary-shapes. To achieve global optimization, a Shape Transform Module is proposed to unite the text detection and recognition into a whole framework. A segmentation-based detector is carefully designed to distinguish text instances and capture the latent information of text reading orders. Extensive experiments show that our method achieves competitive result in standard text benchmarks and the state-of-the-art in both detection and end-to-end evaluations on popular irregular text benchmarks.",
+        "bbox": [
+            514,
+            638,
+            913,
+            792
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "References",
+        "text_level": 1,
+        "bbox": [
+            233,
+            66,
+            330,
+            82
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "[Bookstein 1989] Bookstein, F. L. 1989. Principal Warps: Thin-Plate Splines and the Decomposition of Deformations. IEEE TPAMI 11(6):567-585.",
+            "[Bušta, Neumann, and Matas 2017] Bušta, M.; Neumann, L.; and Matas, J. 2017. Deep Textspotter: An End-to-End Trainable Scene Text Localization and Recognition Framework. In ICCV, 2223-2231.",
+            "[Cheng et al. 2017] Cheng, Z.; Bai, F.; Xu, Y.; Zheng, G.; Pu, S.; and Zhou, S. 2017. Focusing Attention: Towards Accurate Text Recognition in Natural Images. In ICCV, 5076-5084.",
+            "[Ch'ng and Chan 2017] Ch'ng, C. K., and Chan, C. S. 2017. Total-text: A Comprehensive Dataset for Scene Text Detection and Recognition. In ICDAR, volume 1, 935-942.",
+            "[Dai et al. 2018] Dai, Y.; Huang, Z.; Gao, Y.; Xu, Y.; Chen, K.; Guo, J.; and Qiu, W. 2018. Fused Text Segmentation Networks for Multi-oriented Scene Text Detection. In ICPR, 3604-3609.",
+            "[Gupta, Vedaldi, and Zisserman 2016] Gupta, A.; Vedaldi, A.; and Zisserman, A. 2016. Synthetic Data for Text Localisation in Natural Images. In CVPR, 2315-2324.",
+            "[He et al. 2016] He, K.; Zhang, X.; Ren, S.; and Sun, J. 2016. Deep Residual Learning for Image Recognition. In CVPR, 770-778.",
+            "[He et al. 2017] He, K.; Gkioxari, G.; Dollar, P.; and Girshick, R. 2017. Mask R-CNN. In ICCV, 2980-2988.",
+            "[He et al. 2018] He, T.; Tian, Z.; Huang, W.; Shen, C.; Qiao, Y.; and Sun, C. 2018. An End-to-End TextSpotter with Explicit Alignment and Attention. In CVPR, 5020–5029.",
+            "[Huang et al. 2017] Huang, J.; Rathod, V.; Sun, C.; Zhu, M.; Korattikara, A.; Fathi, A.; Fischer, I.; Wojna, Z.; Song, Y.; Guadarrama, S.; et al. 2017. Speed Accuracy Trade-offs for Modern Convolutional Object Detectors. In CVPR, 7310-7311.",
+            "[Jaderberg et al. 2015] Jaderberg, M.; Simonyan, K.; Zisserman, A.; et al. 2015. Spatial Transformer Networks. In NeurIPS, 2017-2025.",
+            "[Jaderberg, Vedaldi, and Zisserman 2014] Jaderberg, M.; Vedaldi, A.; and Zisserman, A. 2014. Deep Features for Text Spotting. In ECCV, 512-528.",
+            "[Karatzas et al. 2013] Karatzas, D.; Shafait, F.; Uchida, S.; Iwamura, M.; i Bigorda, L. G.; Mestre, S. R.; Mas, J.; Mota, D. F.; Almazan, J. A.; and De Las Heras, L. P. 2013. ICDAR 2013 Robust Reading Competition. In ICDAR, 1484-1493.",
+            "[Karatzas et al. 2015] Karatzas, D.; Gomez-Bigorda, L.; Nicolaou, A.; Ghosh, S.; Bagdanov, A.; Iwamura, M.; Matas, J.; Neumann, L.; Chandrasekhar, V. R.; Lu, S.; et al. 2015. ICDAR 2015 Competition on Robust Reading. In ICDAR, 1156-1160.",
+            "[Li, Wang, and Shen 2017] Li, H.; Wang, P.; and Shen, C. 2017. Towards End-to-end Text Spotting with Convolutional Recurrent Neural Networks. In ICCV, 5248-5256.",
+            "[Liao et al. 2017] Liao, M.; Shi, B.; Bai, X.; Wang, X.; and Liu, W. 2017. TextBoxes: A Fast Text Detector with a Single Deep Neural Network. In AAAI, 4161-4167.",
+            "[Liao, Shi, and Bai 2018] Liao, M.; Shi, B.; and Bai, X. 2018. TextBoxes++: A Single-Shot Oriented Scene Text Detector. IEEE TIP 27(8):3676-3690.",
+            "[Lin et al. 2017] Lin, T.-Y.; Dollar, P.; Girshick, R.; He, K.; Hariharan, B.; and Belongie, S. 2017. Feature Pyramid Networks for Object Detection. In CVPR, 2117-2125.",
+            "[Liu et al. 2016] Liu, W.; Anguelov, D.; Erhan, D.; Szegedy, C.; Reed, S.; Fu, C.-Y.; and Berg, A. C. 2016. SSD: Single Shot Multibox Detector. In ECCV, 21-37. Springer.",
+            "[Liu et al. 2018] Liu, X.; Liang, D.; Yan, S.; Chen, D.; Qiao, Y.; and Yan, J. 2018. FOTS: Fast Oriented Text Spotting with a Unified Network. In CVPR, 5676-5685.",
+            "[Liu et al. 2019a] Liu, Y.; Jin, L.; Zhang, S.; Luo, C.; and Zhang, S. 2019a. Curved Scene Text Detection via Transverse and Longitudinal Sequence Connection. PR 90:337-345."
+        ],
+        "bbox": [
+            76,
+            87,
+            480,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "[Liu et al. 2019b] Liu, Z.; Lin, G.; Yang, S.; Liu, F.; Lin, W.; and Goh, W. L. 2019b. Towards Robust Curve Text Detection With Conditional Spatial Expansion. In CVPR.",
+            "[Long et al. 2018] Long, S.; Ruan, J.; Zhang, W.; He, X.; Wu, W.; and Yao, C. 2018. Textsnake: A Flexible Representation for Detecting Text of Arbitrary Shapes. In ECCV, 19-35.",
+            "[Luo, Jin, and Sun 2019] Luo, C.; Jin, L.; and Sun, Z. 2019. MORAN: A Multi-Object Rectified Attention Network for Scene Text Recognition. PR.",
+            "[Lyu et al. 2018] Lyu, P.; Liao, M.; Yao, C.; Wu, W.; and Bai, X. 2018. Mask Textspotter: An End-to-End Trainable Neural Network for Spotting Text with Arbitrary Shapes. In ECCV, 71-88.",
+            "[Ma et al. 2018] Ma, J.; Shao, W.; Ye, H.; Wang, L.; Wang, H.; Zheng, Y.; and Xue, X. 2018. Arbitrary-Oriented Scene Text Detection via Rotation Proposals. IEEE TMM 20(11):3111-3122.",
+            "[Milletari, Navab, and Ahmadi 2016] Milletari, F.; Navab, N.; and Ahmadi, S.-A. 2016. V-net: Fully Convolutional Neural Networks for Volumetric Medical Image Segmentation. In 3DV, 565-571.",
+            "[Ren et al. 2015] Ren, S.; He, K.; Girshick, R.; and Sun, J. 2015. Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks. In NeurIPS, 91-99.",
+            "[Shi, Bai, and Yao 2017] Shi, B.; Bai, X.; and Yao, C. 2017. An End-to-End Trainable Neural Network for Image-based Sequence Recognition and Its Application to Scene Text Recognition. IEEE TPAMI 39(11):2298-2304.",
+            "[Shi et al. 2016] Shi, B.; Wang, X.; Lyu, P.; Yao, C.; and Bai, X. 2016. Robust Scene Text Recognition with Automatic Rectification. In CVPR, 4168-4176.",
+            "[Shrivastava, Gupta, and Girshick 2016] Shrivastava, A.; Gupta, A.; and Girshick, R. 2016. Training Region-based Object Detectors with Online Hard Example Mining. In CVPR, 761-769.",
+            "[Sun et al. 2018] Sun, Y.; Zhang, C.; Huang, Z.; Liu, J.; Han, J.; and Ding, E. 2018. TextNet: Irregular Text Reading from Images with an End-to-End Trainable Network. In ACCV.",
+            "[Wang et al. 2012] Wang, T.; Wu, D. J.; Coates, A.; and Ng, A. Y. 2012. End-to-End Text Recognition with Convolutional Neural Networks. In ICPR, 3304–3308.",
+            "[Wang et al. 2019] Wang, W.; Xie, E.; Li, X.; Hou, W.; Lu, T.; Yu, G.; and Shao, S. 2019. Shape Robust Text Detection With Progressive Scale Expansion Network. In CVPR.",
+            "[Wu and Natarajan 2017] Wu, Y., and Natarajan, P. 2017. Self-organized Text Detection with Minimal Post-processing via Border Learning. In ICCV, 5010-5019.",
+            "[Xie et al. 2019] Xie, E.; Zang, Y.; Shao, S.; Yu, G.; Yao, C.; and Li, G. 2019. Scene Text Detection with Supervised Pyramid Context Network. In AAAI.",
+            "[Xu et al. 2019] Xu, Y.; Wang, Y.; Zhou, W.; Wang, Y.; Yang, Z.; and Bai, X. 2019. Textfield: Learning a deep direction field for irregular scene text detection. IEEE TIP.",
+            "[Xue, Lu, and Zhan 2018] Xue, C.; Lu, S.; and Zhan, F. 2018. Accurate Scene Text Detection through Border Semantics Awareness and Bootstrapping. In ECCV, 370-387.",
+            "[Zhan and Lu 2019] Zhan, F., and Lu, S. 2019. Esir: End-to-end scene text recognition via iterative image rectification. In CVPR, 2059-2068.",
+            "[Zhang et al. 2018] Zhang, S.; Liu, Y.; Jin, L.; and Luo, C. 2018. Feature Enhancement Network: A Refined Scene Text Detector. In AAAI.",
+            "[Zhang et al. 2019] Zhang, C.; Liang, B.; Huang, Z.; En, M.; Han, J.; Ding, E.; and Ding, X. 2019. Look More Than Once: An Accurate Detector for Text of Arbitrary Shapes. In CVPR.",
+            "[Zhou et al. 2017] Zhou, X.; Yao, C.; Wen, H.; Wang, Y.; Zhou, S.; He, W.; and Liang, J. 2017. EAST: An Efficient and Accurate Scene Text Detector. In CVPR, 2642-2651."
+        ],
+        "bbox": [
+            509,
+            70,
+            911,
+            820
+        ],
+        "page_idx": 8
+    }
+]

2002.06xxx/2002.06820/b62d4baf-aeea-4bff-82d1-b6e4044e1482_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ccaad3a1385c23a975d1be24a8f711e5b6bf1b4d4e66111f84977a12853c6283
+size 1136737

2002.06xxx/2002.06820/full.md

@@ -0,0 +1,409 @@
+# Text Perceptron: Towards End-to-End Arbitrary-Shaped Text Spotting
+
+# Liang Qiao $^{1}$  Sanli Tang $^{1}$  Zhanzhan Cheng $^{21*}$  Yunlu Xu $^{1}$  Yi Niu $^{1}$  Shiliang Pu $^{1}$  Fei Wu $^{2}$
+
+$^{1}$ Hikvision Research Institute, China;  $^{2}$ Zhejiang University, China
+
+{qiaoliang6, tangsanli, chengzhanzhan, xuyunlu, niuyi, pushiliang}@hikvision.com wufei@cs.zju.edu.cn
+
+# Abstract
+
+Many approaches have recently been proposed to detect irregular scene text and achieved promising results. However, their localization results may not well satisfy the following text recognition part mainly because of two reasons: 1) recognizing arbitrary shaped text is still a challenging task, and 2) prevalent non-trainable pipeline strategies between text detection and text recognition will lead to suboptimal performances. To handle this incompatibility problem, in this paper we propose an end-to-end trainable text spotting approach named Text Perceptron. Concretely, Text Perceptron first employs an efficient segmentation-based text detector that learns the latent text reading order and boundary information. Then a novel Shape Transform Module (abbr. STM) is designed to transform the detected feature regions into regular morphologies without extra parameters. It unites text detection and the following recognition part into a whole framework, and helps the whole network achieve global optimization. Experiments show that our method achieves competitive performance on two standard text benchmarks, i.e., ICDAR 2013 and ICDAR 2015, and also obviously outperforms existing methods on irregular text benchmarks SCUT-CTW1500 and Total-Text.
+
+# 1 Introduction
+
+Spotting scene text is a hot research topic due to its various applications such as invoice recognition and road sign reading in advanced driver assistance systems. With the advances of deep learning, many deep neural-network-based methods (Wang et al. 2012; Jaderberg, Vedaldi, and Zisserman 2014; Li, Wang, and Shen 2017; Liu et al. 2018; He et al. 2018) have been proposed for spotting text from a natural image, and have achieved promising results.
+
+However, in the real-world, many texts appear in arbitrary layouts (e.g. multi-oriented or curved), which make quadrangle-based methods (Liao et al. 2017; Zhou et al. 2017; Zhang et al. 2018) cannot be well adapted in many situations. Some works (Dai et al. 2018; Long et al. 2018; Xie et al. 2019) began to focus on irregular text localization by segmenting text masks as detection results and achieved relatively good performance in terms of Intersection-over-Union (IoU) evaluation. However, they still leave many challenges to the following recognizing task. For example, a
+
+![](images/d3275e8fb3295d88187bc1739b67da1ad612cc0f29a9fa909ab4731ed8bb59ba.jpg)  
+(a)  
+Figure 1: Illustration of the traditional pipelined text spotting process and Text Perceptron. Sub-figure (a) is a traditional pipeline strategy by combining text detection, rectification and recognition into a framework. Sub-figure (b) is an end-to-end trainable text spotting approach by applying the proposed STM. The black and red arrows mean the forward and backward processing, respectively. The red points denote generated fiducial points generated.
+
+common pipeline of text spotting is to crop the masked texts within bounding-box regions, and then adopt a recognition model with rectification functions to generate final character sequences. Unfortunately, such strategy decreases the robustness of text spotting mainly in two aspects: 1) one needs to design extra rectification network, like methods in (Luo, Jin, and Sun 2019) and (Zhan and Lu 2019), to transform irregular texts into regular ones. In practice, it is hard to be optimized without human-labeled geometric ground truth, and also introduces extra computational cost. 2) Pipelined text spotting methods are not end-to-end trainable and result in suboptimal performance because the errors from the recognition model cannot be utilized for optimizing the text detector. In Figure 1(a), although the text detector provides true positive results, the clipped text masks still lead to wrong recognition results. We denote above problem incompatibility between text detection and recognition.
+
+Recently, two methods were proposed for spotting irregular text in the end-to-end manners. (Lyu et al. 2018) proposed an end-to-end trainable network inspired by Mask-RCNN (He et al. 2017), aiming at reading irregular text character-by-character. However, this approach loses the
+
+context information among characters, and also requires amounts of expenditure on character-level annotations. (Sun et al. 2018) attempted to transform irregular text with a perspective ROI module, but this operation has difficulty in handling some complicated distortions such as curved shapes.
+
+These limitations motivate us to explore new and more effective method to spot irregular scene text. Inspired by (Shi et al. 2016), thin-plate splines (abbr. TPS) (Bookstein 1989) may be a feasible approach to rectify various-shaped text into regular form using a group of fiducial points. Although these points can be implicitly learned from cropped rectangular text by a deep spatial transform network (Jaderberg et al. 2015), the learning process of fiducial points is hard to be optimized. As a result, such methods are not robust especially for texts in some complex distortions.
+
+In a more achievable way, we attempt to solve this problem as follows: 1) explicitly finding out a group of reliable fiducial points over text regions so that irregular text can be directly rectified by TPS, and 2) dynamically tuning fiducial points by back-propagating errors from recognition to detection. Specifically, we develop a Shape Transform Module (abbr. STM) to build a robust irregular text spotter and eliminate the incompatibility problem. STM integrates irregular text detection and recognition into an end-to-end trainable model, and iteratively adjusts fiducial points to satisfy the following recognition module. As shown in Figure 1(b), in the early training stage, despite high IoU in detection evaluation, the transformed text regions may not satisfy the recognition module. With end-to-end training, fiducial points will be gradually adjusted to obtain better recognition results.
+
+In this paper, we propose an end-to-end trainable irregular text spotter named Text Perceptron which consists of three parts: 1) A segmentation-based detection module which orderly describes a text region as four subregions: the center region, head, tail and top&bottom boundary regions, detailed in Section 3. Here, boundary information not only helps separate text regions that are very close to each other, but also contributes to capture latent reading-orders. 2) STM for iteratively generating potential fiducial points and dynamically tuning their positions, which alleviates incompatibility between text detection and recognition. 3) A sequence-based recognition module for generating final character sequences.
+
+Major contributions of this paper are listed as follows: 1) We design an efficient order-aware text detector to extract arbitrary-shaped text. 2) We develop the differentiable STM devoting to optimizing both detection and recognition in an end-to-end trainable manner. 3) Extensive experiments show that our method achieves competitive results on two regular text benchmarks, and also significantly surpasses previous methods on two irregular text benchmarks.
+
+# 2 Related Works
+
+Here, we briefly review the recent advances in text detection and end-to-end text spotting.
+
+# 2.1 Text Detection
+
+Methods of text detection can usually be divided into two categories: anchor-based methods and segmentation-based
+
+methods.
+
+Anchor-based methods. These methods usually follow the technique of Faster R-CNN (Ren et al. 2015) or SSD (Liu et al. 2016) that uses anchors to provide rectangular region proposals. To overcome the significantly varying aspect ratios of texts, (Liao et al. 2017) designed long default boxes and filters to enhance text detection, and then (Liao, Shi, and Bai 2018) extended this work by generating quadrilateral boxes to fit the texts with perspective distortions. (Ma et al. 2018) proposed a rotated regional proposal network to enhance multi-oriented text detection. To detect arbitrary-shaped text, many Mask RCNN (He et al. 2017)-based methods, e.g., CSE (Liu et al. 2019b), LOMO (Zhang et al. 2019) and SPCNet (Xie et al. 2019), were developed to capture irregular texts and achieved good performance.
+
+Segmentation-based methods. These methods usually learn a global semantic segmentation without region proposals, which is more efficient compared to anchor-based methods. Segmentation can easily be used to describe text in arbitrary shapes but highly relies on complicated post-processes to separate different text instances. To solve this problem, (Wu and Natarajan 2017) introduced boundary semantic segmentation to reduce the efforts in post-proposing. EAST (Zhou et al. 2017) learned a shrink text region and directly regressed the multi-oriented quadrilateral boxes from text pixels. (Long et al. 2018) designed a series of overlapping disks with different radii and orientations to describe arbitrary-shaped text regions. (Wang et al. 2019) proposed a method that first generates text region masks with various shrinkage ratios and then uses a progressive expansion algorithm to produce the final text region masks. (Xu et al. 2019) predicted each text pixel and assigned them with a regression value denoting the direction to its nearest boundary to help separate different texts.
+
+# 2.2 Text Spotting
+
+Most of existing text-spotting methods (Liao, Shi, and Bai 2018; Liao et al. 2017; Wang et al. 2012) generally first localize each text with a trained detector such as (Zhou et al. 2017) and then recognize the cropped text region with a sequence decoder (Shi, Bai, and Yao 2017). For sufficiently exploiting the complementarity between detection and recognition, some works (He et al. 2018; Li, Wang, and Shen 2017; Liu et al. 2018) were proposed to jointly detect and recognize text instances in an end-to-end trainable manner, which utilized the recognition information to optimize the localization task. However, these methods are incapable of spotting arbitrary-shaped text due to the irrationality of rectangles or quadrangles. To address these problems, (Sun et al. 2018) adopted a perspective ROI transforming module to rectify perspective text, but this operation still has difficulty in handling serious curved text. (Lyu et al. 2018) proposed an end-to-end text spotter inspired by Mask-RCNN for detecting arbitrary-shaped text character-by-character, but this method loses the context information among characters and also requires character-level location annotations.
+
+# 3 Methodology
+
+# 3.1 Overview
+
+We propose a text spotter named Text Perceptron whose overall architecture is shown in Figure 2, which consists of three parts:
+
+(1) The text detector adopts ResNet (He et al. 2016) and Feature Pyramid Network (abbr. FPN) (Lin et al. 2017) as backbone, and is implemented by simultaneously learning three tasks: an order-aware multiple-class semantic segmentation, a corner regression, and a boundary offset regression. In this way, the text detector can localize arbitrary-shaped text and achieve state of the art on text detection.  
+(2) STM is responsible for uniting text detection and recognition into an end-to-end trainable framework. This module iteratively generates fiducial points on text boundaries based on the predicted score and geometry maps, and then applies the differentiable TPS to rectify irregular text into regular form.  
+(3) The text recognizer is used to generate the predicted character sequences, which can be any traditional sequence-based method, such as CRNN (Shi, Bai, and Yao 2017), attention-based method (Cheng et al. 2017).
+
+# 3.2 Text Detection Module
+
+Order-aware Semantic Segmentation The text detector learns a global multi-class semantic segmentation, which is much more efficient than those Mask-RCNN-based methods. Inspired by (Xue, Lu, and Zhan 2018), we introduce text boundary segmentation to separate different text instances. Considering text with arbitrary shapes, we further category boundaries into head, tail, and top&bottom boundary types, respectively. In Figure 3, the green, yellow, blue and pink regions separately denote the head, tail, top&bottom boundaries and the center text region. Here, head and tail also capture potential information about text reading order (e.g. top to bottom for vertical text). Therefore, we learn the text detector by conducting the multi-class semantic segmentation task using several binary Dices Coefficient Loss (Milletari, Navab, and Ahmadi 2016) (denoted by  $\mathcal{L}_{cls}$ ).
+
+Corner and Boundary Regressions To boost the arbitrary-shaped segmentation performance as well as provide position information for fiducial points, we integrate two other regression tasks into the learning process, as shown in Figure 3 (c) and (d),
+
+- Corner Regression. For pixels in head and tail regions, we regress the offsets (e.g. the  $\Delta dx_{1}, \Delta dy_{1}, \Delta dx_{2}$  and  $\Delta dy_{2}$ ) to their corresponding two corner points, which is denoted by  $\mathcal{L}_{\text {corner }}$ .  
+- Boundary Offset Regression. For pixels in center region, we regress the vertical and horizontal offsets to their nearest boundaries (e.g. the  $\Delta dx_1'$ ,  $\Delta dy_1'$ ,  $\Delta dx_2'$  and  $\Delta dy_2'$ ), which is denoted by  $\mathcal{L}_{boundary}$ .
+
+Here, we adopt a proximity regression strategy to solve the inaccurate large-offset regression problem like in EAST (Zhou et al. 2017). That is, the Corner Regressions only regress their neighboring corresponding corners. In the Boundary Offset Regression, we can simply ignore or lower
+
+the loss weights of regression value generated from the larger side (e.g.  $\Delta dx_1'$ ,  $\Delta dx_2'$  for a horizontal text). In this way, our detector can well describe the texts with very large width-height ratios. Both of two regressions are trained with Smooth-L1 loss:
+
+$$
+\mathcal {L} _ {\text {c o r n e r}} \text {o r} \mathcal {L} _ {\text {b o u n d a r y}} = \left\{ \begin{array}{l l} 0. 5 (\sigma z) ^ {2} & | z | <   1 / \sigma^ {2} \\ | z | - 0. 5 / \sigma^ {2} & \text {o t h e r w i s e} \end{array} , \right. \tag {1}
+$$
+
+where  $z$  is the geometry offset value, and  $\sigma$  is a tunable parameter (default by 3).
+
+The Detection Inference In the forward process, we generate predicted segmentation maps by orderly overlaying the segmented center, head, tail, and top&bottom boundary feature maps. Subsequently, text instances can be found as connected-regions of center pixels. We see that all text instances are easily separated by boundaries, and different head (or tail) regions will also be separated by up&bottom boundary region. Therefore, each center region can be matched with a neighboring pair of head and tail region during the pixel traversal process. Specifically, for text with more than 1 head (or tail) regions, we choose the one with the maximum area as its head (or tail). While for predicted center text regions without corresponding head or tail region, we just treat them as false positives and filter them out.
+
+Ground-Truth Generation The process of ground-truth of segmentation and geometry map can be divided into three steps, as shown in Figure 3.
+
+(1) Identifying four corners. We denote the 1st and 4th corners as the two corners in the head region, while the 2nd and 3rd corners are corresponding to the tail region, as shown in Figure 3(a). This weak-supervised information is not provided by most of the datasets, but we found that in general, polygon points  $\{P_1',\dots,P_M'\}$  are usually annotated from the left-top corner to the left-bottom corner in a clockwise manner for text instances. Differently, for polygon annotations with a fixed number of points like SCUT-CTW1500 (Liu et al. 2019a), we can directly identify the four corner points by their indexes. However, for annotations with varying number of points like Total-Text (Ch'ng and Chan 2017), we can only obtain the 1st corner  $(P_1')$  and 4th corner  $(P_M')$ . To search the 2nd and 3rd corners, we design a heuristic corner estimating strategy based on the assumptions that 1) two boundaries neighboring tail are nearly parallel, and 2) two neighbor interior angles of tail are closed to  $\frac{\pi}{2}$ . Therefore, the probable 2nd corner can be estimated as:
+
+$$
+\arg \min  _ {P _ {i} ^ {\prime}} [ \gamma (| \angle P _ {i} ^ {\prime} - \frac {\pi}{2} | + | \angle P _ {i + 1} ^ {\prime} - \frac {\pi}{2} |) + | \angle P _ {i} ^ {\prime} + \angle P _ {i + 1} ^ {\prime} - \pi | ] \tag {2}
+$$
+
+where  $\angle P_i^\prime$  is the degree of interior angle for polygon point  $P_{i}^{\prime}$ , and  $\gamma$  is a weighting parameter (default by 0.5). Then the point  $P_{i + 1}^{\prime}$  following  $P_{i}^{\prime}$  is treated as the 3-rd corner point. Specifically, for vertical text annotated from the top-left corner, we reassign its top-right corner as the 1st key corner.
+
+(2) Generating score maps. Figure 3(b) shows the generated score maps. We firstly generate the center text regions follows by their annotations and then generate boundaries by referring to the shrink and expansion mechanism used
+
+![](images/5a5ca9c156c240be64d70a34df163c205eeb2b7f20af00bd3b5d2e2d636869c8.jpg)  
+Figure 2: The workflow of Text Perceptron. The black and red arrows separately mean the forward and backward process.
+
+![](images/dbe4d3dd71afbf0aaac326800c3a925508c24e299dc65f59cf5bd355314638ee.jpg)
+
+![](images/a3900f6a82a2bf59b2ff793deaabac575c637b7cee7fcf2b3e081f758e4ebb75.jpg)
+
+![](images/24b4ec94b3a0ba40f2b4aa147873560359555da1f59fc2e0fa9a20884e540161.jpg)  
+Figure 3: The label generation process.
+
+![](images/c2567035035050163ae4561c553271666e27ed3cf8e8f01ee72a9f3eafad1532.jpg)
+
+in (Wu and Natarajan 2017). Differently, the head and tail score maps are generated by only applying the shrink operation, which submerges part of the center region. And top&bottom boundary region is then generated by applying both the expansion and shrink operations, which will partly submerge all of the other regions. In this way, we need less effort on post-processing to separate different text instances and it is easy to match their relative head (or tail) region with a center region. Boundary widths are constrained as  $\delta \times \min Len$ , where minLen is the minimum length of edges in the text polygon and  $\delta$  is a ratio parameter. Here, we set  $\delta = 0.2$  for top&bottom boundaries and  $\delta = 0.3$  for head and tail.
+
+(3) Generating geometry maps. As mentioned in Corner and Boundary Regression, pixels belonging to the head region are assigned geometry offset values in 4 channels  $(\Delta dx_{1}, \Delta dy_{1}, \Delta dx_{2}$  and  $\Delta dy_{2})$  corresponding the 1st and 4th key corner, as shown in Figure 3(c). Similarly, the geometry map of the tail region is also formed in 4 channels. The geometry values of the center text region are computed as the horizontal and vertical offsets to the nearest boundaries, shown as  $\Delta dx_{1}^{\prime}, \Delta dy_{1}^{\prime}, \Delta dx_{2}^{\prime}$  and  $\Delta dy_{2}^{\prime}$  in Figure 3(d).
+
+# 3.3 Shape Transform Module
+
+STM is designed to iteratively generate initial fiducial points around text instances and transform text feature regions into
+
+![](images/ee26c35bdc91ca027badac72a56d0fc3c240fc553f1ebf14f20e3c607989e998.jpg)  
+Figure 4: The fiducial points generation process.
+
+regular shapes with the supervision of following recognition.
+
+Fiducial Points Generation With the learned segmentation maps and geometry maps, we propose to generate preset  $2 \times N$  potential fiducial points ( $N \geq 2$ ) for each text instance, denoted as  $\{P_1, \dots, P_N, P_{N+1}, \dots, P_{2 \times N}\}$ , which can be divided into two stages.
+
+(1) Generating four corner points. We first obtain the positions of four corner fiducial points for each text feature region by averaging the coordinate of pixels with their predicted offsets in corresponding boundaries. Taking the 1-st corner point  $(P_{1})$  as an example, it is computed based on all pixels in the head region  $\mathcal{R}_{\mathcal{H}}$ , and formalized by
+
+$$
+P _ {1} = \left(\frac {\sum_ {(x , y) \in \mathcal {R} _ {\mathcal {H}}} (x + \Delta d x)}{| | \mathcal {R} _ {\mathcal {H}} | |}, \frac {\sum_ {(x , y) \in \mathcal {R} _ {\mathcal {H}}} (y + \Delta d y)}{| | \mathcal {R} _ {\mathcal {H}} | |}\right) \tag {3}
+$$
+
+where  $||.||$  means the number of pixels in  $\mathcal{R}_{\mathcal{H}}$ , and  $\Delta dx, \Delta dy$  mean the predicted corner offsets corresponding to  $P_{1}$ . The other three corner points  $(P_{N}$  in  $\mathcal{R}_{\mathcal{H}}, P_{N+1}, P_{2 \times N}$  in tail region  $\mathcal{R}_{\mathcal{T}})$  can be calculated similarly.
+
+(2) Generating other fiducial points. After obtaining four corner fiducial points, the other fiducial points can be located using a dichotomous method. This strategy is suitable for any arbitrary shaped text even serious curved or in different reading orders.
+
+An example of the generation process is shown in Figure 4. We firstly connect  $P_{1}$  and  $P_{N}$ , and judge whether the connected line has a longer span in horizontal direction or vertical direction. Without loss generality, if it has a longer span in horizontal direction as shown, we calculate a middle
+
+point  $P_{\lfloor (N + 1) / 2\rfloor}$  between  $P_{1}$  and  $P_N$  whose x-coordinate formed as:
+
+$$
+x _ {m i d} = \frac {\lceil (N - 1) / 2 \rceil}{N - 1} \times P _ {1, x} + \frac {\lfloor (N - 1) / 2 \rfloor}{N - 1} \times P _ {N, x} \tag {4}
+$$
+
+Then we use the learned boundary offsets from detector to predict the y-coordinate of  $P_{\lfloor (N + 1) / 2\rfloor}$ . Concretely, we define the band region  $\mathcal{B}_i$  as the part of the center region  $\mathcal{R}_C$ :
+
+$$
+\mathcal {B} _ {\lfloor \frac {1 + N}{2} \rfloor} = \{(x, y) \in \mathcal {R} _ {\mathcal {C}} | x \in [ x _ {m i d} - \Delta e p, x _ {m i d} + \Delta e p ] \} \tag {5}
+$$
+
+where  $\Delta ep$  defines the range of the band region (default by 3). Similar to the generation of four corner fiducial points, we can use all pixels in the corresponding band region to predict an average y-coordinate for this fiducial point. Then, the coordinate of  $P_{\lfloor (N + 1) / 2\rfloor}$  can be formed as:
+
+$$
+P _ {\left\lfloor \frac {1 + N}{2} \right\rfloor} = \left(x _ {m i d}, \frac {\sum_ {\left(x _ {t} , y _ {t}\right) \in \mathcal {B} _ {\left\lfloor \frac {1 + N}{2} \right\rfloor}} y _ {t} + \Delta d y _ {t} ^ {\prime}}{\left| \left| \mathcal {B} _ {\left\lfloor \frac {1 + N}{2} \right\rfloor} \right| \right|}\right) \tag {6}
+$$
+
+where  $\Delta dy_t'$  is the learned boundary offset value to the top-boundary  $(\Delta dy_1')$ . This process can be iteratively conducted using corresponding  $\Delta dx_t'$  or  $\Delta dy_t'$  until all of the fiducial points be calculated. Similarly, the fiducial points on the bottom boundary can be calculated by connecting  $P_{N+1}$  and  $P_{2\times N}$  and using the same strategy.
+
+Shape Transformation With the generated potential fiducial points on text boundaries, we can explicitly transform an irregular feature region  $\mathcal{R}$  into a regular form  $\mathcal{R}^*$ . Here, fiducial points are mapped into some preset positions of the transformed feature map by directly applying TPS to the original feature regions. Specifically, we transform all feature regions into a region with width  $W$  and height  $H$ :
+
+$$
+\mathcal {R} ^ {*} = T P S ^ {- 1} (\mathcal {P}, \mathcal {R}), \tag {7}
+$$
+
+where the fiducial point  $P_{i}\in \mathcal{P}$  will be mapped into:
+
+$$
+P _ {i} ^ {*} = \left\{ \begin{array}{c} \left((i - 1) \times \frac {H - 2 \times \Delta w}{N - 1} + \Delta w, \Delta h\right), 1 \leq i \leq N \\ \left((2 \times N - i) \times \frac {H - 2 \times \Delta w}{N - 1} + \Delta w, H - \Delta h\right), \\ N <   i \leq 2 \times N \end{array} \right. \tag {8}
+$$
+
+where  $\Delta w$  and  $\Delta h$  are preset offsets (default by  $0.1\times W$  and  $0.1\times H$ ) to preserve space for fiducial points tuning.
+
+Then, all text feature regions are packed into a batch and sent to the following recognition part. Here, we assume that the final predicted character strings  $Y$  are generated as:
+
+$$
+Y = \operatorname {R e c o g} \left(\mathcal {R} ^ {*}\right), \tag {9}
+$$
+
+where 'Recog' is the sequence recognition process.
+
+Dynamically Finetuning Fiducial Points The assumption here is that although text detector supervised by polygon annotations can generate satisfying polygon masks, the results may not always suitable for the following recognition. To avoid the suboptimal problem and improve overall performance, Text Perceptron will back-propagate differences from 'Recog' to each pixel value in  $\mathcal{R}$  via STM, i.e.
+
+$$
+\Delta \mathcal {R} = \frac {\partial Y}{\partial \mathcal {R} ^ {*}} \frac {\partial \mathcal {R} ^ {*}}{\partial \mathcal {R}}. \tag {10}
+$$
+
+Then we can calculate the adjustment values of  $\mathcal{P}$  by
+
+$$
+\Delta \mathcal {P} = \frac {\partial Y}{\partial \mathcal {R} ^ {*}} \frac {\partial \mathcal {R} ^ {*}}{\partial \mathcal {R}} \frac {\partial \mathcal {R}}{\partial \mathcal {P}}. \tag {11}
+$$
+
+Furthermore, we back-propagate  $\Delta \mathcal{P}$  to the corresponding geometry maps in head, tail and band regions. Formally, for each pixel  $pi$ , we have
+
+$$
+\Delta p i = \Delta \hat {p i} + \frac {\Delta \mathcal {P}}{\| \mathcal {R} _ {\mathcal {R} ^ {*}} \|}, \tag {12}
+$$
+
+where  $\mathcal{R}_{\mathcal{R}^*}\in \{\mathcal{R}_H,\mathcal{R}_T,\mathcal{B}\}$  and  $\Delta \hat{p i}$  is calculated from  $\mathcal{L}_{\text{corner}}$  or  $\mathcal{L}_{\text{boundary}}$ .
+
+# 3.4 End-to-End Training
+
+Our recognition part can be implemented by any sequence-based recognition network, such as CRNN (Shi, Bai, and Yao 2017) or (Cheng et al. 2017).
+
+The loss of the whole framework contains the following parts: the order-aware multi-class semantic segmentation, the corner regressions for pixels in head and tail, the boundary offset regression for pixels in the center region and the word recognition, that is,
+
+$$
+\mathcal {L} = \mathcal {L} _ {c l s} + \lambda_ {b} \mathcal {L} _ {\text {c o r n e r}} + \lambda_ {c} \mathcal {L} _ {\text {b o u n d a r y}} + \lambda_ {r} \mathcal {L} _ {\text {r e c o g}}, \tag {13}
+$$
+
+where  $\lambda_{b},\lambda_{c}$  and  $\lambda_{r}$  are auto-tunable parameters, and  $\mathcal{L}_{recog}$  is the loss from recognition.
+
+Since learning fiducial points highly depends on the segmentation map learning, we use a soft loss weight strategy to automatically tune  $\lambda_{b},\lambda_{c}$  and  $\lambda_{r}$ . In other words, in the first few epochs, fiducial points are mainly adjusted by regression tasks; while at the last few epochs, points are mainly restricted to recognition. Formally,
+
+$$
+\lambda_ {b} = \lambda_ {c} = \lambda^ {*} - \max  (0. 0 2 \times E, 0. 5), \tag {14}
+$$
+
+$$
+\lambda_ {r} = \min  \left(\max  (- 0. 1 + 0. 0 2 \times E, 0), \lambda_ {r} ^ {*}\right), \tag {15}
+$$
+
+where  $E$  is the number of training epochs, and  $\lambda^{*}$  and  $\lambda_r^*$  separately control the maximum loss weight of regression and recognition. In our experiments, we set  $\lambda^{*} = 0.6$  and  $\lambda_r^* = 0.8$ .
+
+# 4 Experiments
+
+# 4.1 Datasets
+
+The datasets used in this work are listed as follows:
+
+SynthText 800k (Gupta, Vedaldi, and Zisserman 2016) contains 800k synthetic images that are generated by rendering synthetic text with natural images, and it is used as the pre-training dataset.
+
+ICDAR2013 (Karatzas et al. 2013) (abbr. IC13) is collected as the focused scene text, which is mainly horizontal text containing 229 training images and 233 testing images.
+
+ICDAR2015 (Karatzas et al. 2015) (abbr. IC15) is collected as incidental scene text consisting of many perspective text. It contains 1000 training and 500 testing images.
+
+Total-Text (Ch'ng and Chan 2017) consists of multi-oriented and curve text and is therefore one of the important benchmarks in evaluating shape-robust text spotting tasks. It
+
+<table><tr><td rowspan="2">Dataset</td><td rowspan="2">Method</td><td colspan="4">Detection</td><td colspan="3">End-to-End</td><td colspan="3">Word Spotting</td></tr><tr><td>P</td><td>R</td><td>F</td><td>FPS</td><td>S</td><td>W</td><td>G</td><td>S</td><td>W</td><td>G</td></tr><tr><td rowspan="9">IC13</td><td>Textboxes (2017)</td><td>88.0</td><td>83.0</td><td>85.0</td><td>1.37</td><td>91.6</td><td>89.7</td><td>83.9</td><td>93.9</td><td>92.0</td><td>85.9</td></tr><tr><td>Li et al. (2017)</td><td>91.4</td><td>80.5</td><td>85.6</td><td>-</td><td>91.1</td><td>89.8</td><td>84.6</td><td>94.2</td><td>92.4</td><td>88.2</td></tr><tr><td>TextSpotter (2017)</td><td>-</td><td>-</td><td>-</td><td>-</td><td>89.0</td><td>86.0</td><td>77.0</td><td>92.0</td><td>89.0</td><td>81.0</td></tr><tr><td>He et al. (2018)</td><td>91.0</td><td>88.0</td><td>90.0</td><td>-</td><td>91.0</td><td>89.0</td><td>86.0</td><td>93.0</td><td>92.0</td><td>87.0</td></tr><tr><td>FOTS (2018)</td><td>-</td><td>-</td><td>88.2</td><td>23.9</td><td>88.8</td><td>87.1</td><td>80.8</td><td>92.7</td><td>90.7</td><td>83.5</td></tr><tr><td>TextNet* (2018)</td><td>93.3</td><td>89.4</td><td>91.3</td><td>-</td><td>89.8</td><td>88.9</td><td>83.0</td><td>94.6</td><td>94.5</td><td>87.0</td></tr><tr><td>Mask TextSpotter* (2018)</td><td>95.0</td><td>88.6</td><td>91.7</td><td>4.6</td><td>92.2</td><td>91.1</td><td>86.5</td><td>92.5</td><td>92.0</td><td>88.2</td></tr><tr><td>Ours (2-stage)</td><td>92.7</td><td>88.7</td><td>90.7</td><td>10.3</td><td>90.8</td><td>90.0</td><td>84.4</td><td>93.7</td><td>93.1</td><td>86.2</td></tr><tr><td>Ours (End-to-end)</td><td>94.7</td><td>88.9</td><td>91.7</td><td>10.3</td><td>91.4</td><td>90.7</td><td>85.8</td><td>94.9</td><td>94.0</td><td>88.5</td></tr><tr><td rowspan="11">IC15</td><td>EAST (2017)</td><td>83.6</td><td>73.5</td><td>78.2</td><td>13.2</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td>TextSnake* (2018)</td><td>84.9</td><td>80.4</td><td>82.6</td><td>1.1</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td>SPCNet* (2019)</td><td>88.7</td><td>85.8</td><td>87.2</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td>PSENet-1s* (2019)</td><td>86.9</td><td>84.5</td><td>85.7</td><td>1.6</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td>TextSpotter (2017)</td><td>-</td><td>-</td><td>-</td><td>-</td><td>54.0</td><td>51.0</td><td>47.0</td><td>58.0</td><td>53.0</td><td>51.0</td></tr><tr><td>He et al. (2018)</td><td>87.0</td><td>86.0</td><td>87.0</td><td>-</td><td>82.0</td><td>77.0</td><td>63.0</td><td>85.0</td><td>80.0</td><td>65.0</td></tr><tr><td>FOTS (2018)</td><td>91.0</td><td>85.2</td><td>88.0</td><td>7.8</td><td>81.1</td><td>75.9</td><td>60.8</td><td>84.7</td><td>79.3</td><td>63.3</td></tr><tr><td>TextNet* (2018)</td><td>89.4</td><td>85.4</td><td>87.4</td><td>-</td><td>78.7</td><td>74.9</td><td>60.5</td><td>82.4</td><td>78.4</td><td>62.4</td></tr><tr><td>Mask TextSpotter* (2018)</td><td>91.6</td><td>81.0</td><td>86.0</td><td>4.8</td><td>79.3</td><td>73.0</td><td>62.4</td><td>79.3</td><td>74.5</td><td>64.2</td></tr><tr><td>Ours (2-stage)</td><td>91.6</td><td>81.8</td><td>86.4</td><td>8.8</td><td>78.2</td><td>74.5</td><td>63.0</td><td>80.6</td><td>76.6</td><td>65.5</td></tr><tr><td>Ours (End-to-end)</td><td>92.3</td><td>82.5</td><td>87.1</td><td>8.8</td><td>80.5</td><td>76.6</td><td>65.1</td><td>84.1</td><td>79.4</td><td>67.9</td></tr></table>
+
+Table 1: Results on IC13 and IC15. 'P', 'R' and 'F' separately mean the 'Precision', 'Recall' and 'F-Measure'. 'S', 'W' and 'G' mean recognition with strong, weak and generic lexicon, respectively. Superscript '\*' means that the method considered the detection of irregular text.
+
+contains 1255 training and 300 testing images, and each text is annotated by a word-level polygon with transcription.
+
+SCUT-CTW1500 (Liu et al. 2019a) (abbr. CTW1500) is a curved text benchmark consists of 1000 training and 500 testing images. In contrast to Total-Text, all text instances are annotated with 14-point polygons in the line-level.
+
+# 4.2 Implementation Details
+
+The detector uses ResNet-50 as the backbone and further be modified following the suggestions from (Huang et al. 2017) for obtaining dense features. We remove the fifth stage, modify conv4_1 layer with stride=1 instead of 2, and apply atrous convolution for all subsequent layers to maintain enough receptive field. Training loss is calculated from the outputs of three stages: the fourth stage  $(8\times)$ , the third stage  $(8\times)$ , and the second stage  $(4\times)$  feature maps of FPN, and testing is only conducted on  $4\times$  feature map. We directly adopt the attention-based network described in (Cheng et al. 2017) as the recognition model. All experiments are implemented in Caffe with 8 32GB-Tesla-V100 GPUs. The code will be published soon.
+
+Data augmentation. We conduct data augmentation by simultaneously 1) randomly scaling the longer side of input images with length in range of [720, 1600], 2) randomly rotating the images with the degree in range of  $[-15^{\circ}, 15^{\circ}]$ , and 3) applying random brightness, jitters, and contrast on input images.
+
+Training details. The networks are trained by SGD with batch-size=8, momentum=0.9 and weight-decay=5 × 10 $^{-4}$ . For both detection and recognition part, we separately pretrain them on SynthText for 5 epochs with initial learning rate 2 × 10 $^{-3}$ . Then, we jointly fine-tune the whole network using the soft loss weight strategy mention previously on each dataset for other 80 epochs. The initial learning rate is
+
+$1 \times 10^{-3}$ . The learning rate will be divided by 10 for every 20 epochs. Online hard example mining (OHEM) (Shrivastava, Gupta, and Girshick 2016) strategy is also applied for balancing the foreground and background samples.
+
+Testing details. We resize input images with the longer side 1440 for IC13, 2000 for IC15, 1350 for Total-text and 1250 for CTW1500. We set the number of fiducial points as 4 for two standard text datasets and 14 for two irregular text datasets. The detection results are given by connecting the predicted fiducial points. Note that, all images are tested in the single-scale.
+
+# 4.3 Results on Standard Text Benchmarks
+
+Evaluation on horizontal text. We first evaluate our method on IC13 mainly consisting of horizontal texts. Table 1 shows the results, and represents that our method achieve competitive performance compared to previous methods on the 'Detection', 'End-to-End' and 'Word Spotting' evaluation items. Besides, our method is also very efficient and achieves '10.3' of Frame Per Second (abbr. FPS).
+
+Evaluation on perspective text. We evaluate our method on IC15 containing many perspective texts, and the results are shown in Table 1. In the detection stage, our method achieves comparable performance with the irregular text spotting methods such as TextNet and Mask TextSpotter. In the 'End-to-End' and 'Word Spotting' tasks, our method significantly outperforms previous irregular-text-based methods and achieves the remarkable state-of-the-art performance on general lexicon cases, which demonstrates the effectiveness of our method.
+
+# 4.4 Results on Irregular Text Benchmarks
+
+We test our method on two irregular text benchmarks: Total-Text and CTW1500, as shown in Table 2 and 3. In the de
+
+<table><tr><td rowspan="2">Method</td><td colspan="3">Detection</td><td colspan="2">End-to-End</td></tr><tr><td>P</td><td>R</td><td>F</td><td>None</td><td>Full</td></tr><tr><td>TextSnake (2018)</td><td>82.7</td><td>74.5</td><td>78.4</td><td>-</td><td>-</td></tr><tr><td>FTSN (2018)</td><td>84.7</td><td>78.0</td><td>81.3</td><td>-</td><td>-</td></tr><tr><td>TextField (2019)</td><td>81.2</td><td>79.9</td><td>80.6</td><td>-</td><td>-</td></tr><tr><td>SPCNet (2019)</td><td>83.0</td><td>82.8</td><td>82.9</td><td>-</td><td>-</td></tr><tr><td>CSE (2019b)</td><td>81.4</td><td>79.1</td><td>80.2</td><td>-</td><td>-</td></tr><tr><td>PSENet-1s (2019)</td><td>84.0</td><td>78.0</td><td>80.9</td><td>-</td><td>-</td></tr><tr><td>LOMO (2019)</td><td>75.7</td><td>88.6</td><td>81.6</td><td>-</td><td>-</td></tr><tr><td>Mask TextSpotter (2018)</td><td>69.0</td><td>55.0</td><td>61.3</td><td>52.9</td><td>71.8</td></tr><tr><td>TextNet (2018)</td><td>68.2</td><td>59.5</td><td>63.5</td><td>54.0</td><td>-</td></tr><tr><td>Ours (2-stage)</td><td>88.1</td><td>78.9</td><td>83.3</td><td>63.3</td><td>73.9</td></tr><tr><td>Ours (End-to-end)</td><td>88.8</td><td>81.8</td><td>85.2</td><td>69.7</td><td>78.3</td></tr></table>
+
+tection stage, our method outperforms all previous methods and surpasses the best result  $2.3\%$  on Total-Text and  $2.4\%$  on CTW1500 on F-measure evaluation.
+
+Moreover, our method significantly outperforms previous methods on the precision item, which attributes to the false-positive filtering strategy. In the end-to-end case, our method significantly surpasses the best-reported results (Sun et al. 2018) by  $15.7\%$  on 'None' and the best of results (Lyu et al. 2018) by  $6.5\%$  on 'Full', which mainly attributes to STM achieving the end-to-end training strategies. Since CTW1500 releases the recognition annotation recently, there is no reported result on the end-to-end evaluation. Here, we report the end-to-end results lexicon-freeely, and believe our method will significantly outperform previous methods.
+
+Table 2: Result on Total-Text. "Full" indicates lexicons of all images are combined. "None" means lexicon-free.  
+
+<table><tr><td rowspan="2">Method</td><td colspan="3">Detection</td><td>End-to-End</td></tr><tr><td>P</td><td>R</td><td>F</td><td>None</td></tr><tr><td>TextSnake (2018)</td><td>69.7</td><td>85.3</td><td>75.6</td><td>-</td></tr><tr><td>TextField (2019)</td><td>83.0</td><td>79.8</td><td>81.4</td><td>-</td></tr><tr><td>CSE (2019b)</td><td>81.1</td><td>76.0</td><td>78.4</td><td>-</td></tr><tr><td>PSENet-1s (2019)</td><td>84.8</td><td>79.7</td><td>82.2</td><td>-</td></tr><tr><td>LOMO (2019)</td><td>69.6</td><td>89.2</td><td>78.4</td><td>-</td></tr><tr><td>Ours (2-stage)</td><td>88.7</td><td>78.2</td><td>83.1</td><td>48.6</td></tr><tr><td>Ours (End-to-end)</td><td>87.5</td><td>81.9</td><td>84.6</td><td>57.0</td></tr></table>
+
+In summary, the results on Total-Text and CTW1500 demonstrate the effectiveness of our method for arbitrary-shaped text spotting. Moreover, compared with 2-staged results, the end-to-end trainable strategy markedly boosts text spotting performance, especially for the recognition part.
+
+# 4.5 Ablation Results of Fiducial Points
+
+The number of fiducial points directly influences the detection and end-to-end results when texts are displayed in the curve or even waved shapes. Table 4 shows the result that how the number of fiducial points affects the detection and end-to-end evaluations on different benchmarks. It is clear that 4 points annotation is enough for regular benchmark such as IC15, and there is almost no influence on the result when the number of fiducial points increases. On the other hand, for two irregular benchmarks, the detection F-score as well as end-to-end F-score raises along with the increasing number of fiducial points, and the performance becomes stable when  $2 \times N \geq 10$ .
+
+Table 3: Result on CTW1500. 'None' means lexicon-free.  
+
+<table><tr><td rowspan="2">Dataset</td><td colspan="8">Number of fiducial points</td></tr><tr><td>4</td><td>6</td><td>8</td><td>10</td><td>12</td><td>14</td><td>16</td><td>18</td></tr><tr><td>IC15</td><td>87.1</td><td>87.0</td><td>87.0</td><td>86.9</td><td>87.0</td><td>86.9</td><td>86.8</td><td>86.8</td></tr><tr><td>Total-Text</td><td>71.5</td><td>82.8</td><td>84.5</td><td>85.0</td><td>85.2</td><td>85.2</td><td>85.2</td><td>85.3</td></tr><tr><td>CTW1500</td><td>68.7</td><td>81.9</td><td>84.1</td><td>84.3</td><td>84.4</td><td>84.6</td><td>84.4</td><td>84.5</td></tr><tr><td>Total-Text</td><td>55.9</td><td>68.5</td><td>69.8</td><td>69.6</td><td>69.8</td><td>69.7</td><td>69.5</td><td>69.9</td></tr><tr><td>CTW1500</td><td>40.2</td><td>52.2</td><td>56.2</td><td>57.0</td><td>57.1</td><td>57.0</td><td>56.5</td><td>56.4</td></tr></table>
+
+Table 4: Detection (top part) and end-to-end (bottom part) evaluation (F-measure) under varied number of fiducial points for different benchmarks.
+
+![](images/1b358eb28937f4a020b5eb7a2c03eb8c30391abfd6993c4b9d7e3f7c7b80f582.jpg)  
+N=2
+
+![](images/4058d7caa4e665f2aea1b84093b927ba6ef30b70f1c02469bd5bd2e08e494d45.jpg)  
+N=3
+
+![](images/3c5d9f93d1da7d76c3681142d9b2b7991de90401371b75249eba9948c7f7980c.jpg)  
+N=5  
+Figure 5: Results of Text Perceptron with different number of fiducial points (4,6,10,12).
+
+![](images/09849c0bc7515eaf7e898fb5d836fcc176f6c568b238b30e2e2689375d4dc2ee.jpg)  
+N=6
+
+Figure 5 shows an example of end-to-end evaluation under different number of fiducial points. We see that the generated text masks by few fiducial points are hard to cover the entire curve texts. As the growing number of fiducial points, STM has more power to catch and rectify irregular text instances, which yields higher recognition accuracy.
+
+In contrast to previous works, our method can generate any fixed number of fiducial points on text boundaries. The fiducial points generation method can also be used to annotate arbitrary-shaped text.
+
+# 4.6 Visualization Results
+
+![](images/c3159fd9b8b69be8d348b035db10733f5459d3a5ca972f282473d4192046ea76.jpg)
+
+![](images/859b16d31c15b99fd90a0e0cc90ea1c8296957686a725cc29c60b7168771373b.jpg)
+
+![](images/604c4c3b46be864b8853eb4529042b3ed32820b237d3d36082609bac0f0ced36.jpg)  
+Figure 6: Visualization results on origin images.
+
+![](images/535445b731db597f7357ffbc1ada3c5e257620cd4eb3f42cd5e7c49c959acc72.jpg)
+
+![](images/aa057c6fcfb38dea1529b41097c6b9f9a213f696b76330345cae48f65be1c317.jpg)
+
+![](images/4729d4d065189713a97b5210634d51964a929d719c4a4ec6aff996a607fccfca.jpg)
+
+![](images/afdd9645fb106dfc10cfd24a071cb834c051e93cffde3902dddfa40c18541380.jpg)
+
+![](images/b7dcb35e90b89a6bb7a492a54273ad8e3926255c16c51c2b24456cb8063d2e52.jpg)
+
+![](images/7ede54a778143ecb656b8a8f05e2dd6eeebfbfc6898d04140caa9ffc68fe2a19.jpg)
+
+![](images/5b34686e6d265baab16de4eaeae97e0aa49134747c1877399bdfdc94a5fed59a.jpg)
+
+![](images/f0a596a3e44ad6a494ac775180b87c6a5be2b4e157faa77faf7d37016d487deb.jpg)
+
+![](images/a8047e20532a377b50d842852af5d10e9527f52cf0cfaf34a4ee83f1a4db84a0.jpg)
+
+![](images/4c8ed77adac87aabbc0f9638077743ded65948aeb99952bcf5076be40226b8c7.jpg)
+
+Figure 6 and Figure 7 demonstrate some visualization results in Total-Text and CTW1500 datasets. Text Perceptron shows its powerful ability in catching the reading order of irregular scene text (including curved, long perspective, vertical, etc.), and with the help of fiducial points which can further recognize text in a much simpler way. From the segmentation results, we find that many of text-like false posi
+
+![](images/88e5dba7330a5921431da9bffc7fbee85cf8f8fcc49e9fe0c4dab405a0152b2d.jpg)  
+Figure 7: Visualization result on Total-Text and CTW1500. The first row displays the segmented results and the second row shows the end-to-end results. Fiducial points are also visualized as colored points on text boundaries.
+
+![](images/3bde24202cfaea7f4ee3358daf334de9c60dfa08e62240ef88c2c5420c5950b7.jpg)
+
+![](images/3a2a9b4669b639a56dcf3ba19ac8cc1dc77709ade15baed85182c1b220bced8a.jpg)
+
+![](images/37bcb011a3d23d973197eea5336c16de239113e6f7cad8d67baacce20fd39abf.jpg)  
+Figure 8: Visualization of some failure samples.
+
+![](images/8cacb221934d97822fb4fcae5f6733fea3622e4c0fa0c9a87f04d990947ad1e5.jpg)
+
+![](images/2b3b41e9181a88ec352ff5135a89f2118a60658b46e019a2379b80a145481983.jpg)
+
+tives have been filtered out due to the missing of head or tail boundary. This means the features of head or tail boundaries contain the different semantic information with that of the center region. Figure 6 also shows the visualization of some rectified irregular text instances, in which vertical texts can be well transformed into the "lying-down" shapes.
+
+Failure Samples We illustrate some failure samples that are difficult for Text Perceptron, as shown in Figure 8.
+
+Overlapped text. It is a common tough task for segmentation-based detection methods. Pixels belong to the center text region for one text instance may also become the boundary region for another one. Even though our orderly overlaying strategy allows pixels to have multiple classes and makes boundary pixels have higher priority than center text pixels, which encourages inner instance to be separated from the outer instance. But experiments found that
+
+many times, the boundaries of inner instance cannot be fully recalled to embrace such instance, and connecting between center text pixels will result in the failure of detecting such inner an instance.
+
+Recognition of vertical instance. On the one hand, vertical texts appear in little frequency in the common datasets. One the other hand, although Text Perceptron can read vertical instances from left to right, it is still a challenge for recognition algorithm to distinguish whether the instance is a horizontal text or a 'lying-down' vertical one. Therefore, there are some correctly detected instances cannot be recognized right. It is also a common difficult problem for all existing recognition algorithms.
+
+# 5 Conclusion
+
+In this paper, we propose an end-to-end trainable text spotter named Text Perceptron aiming at spotting text with arbitrary-shapes. To achieve global optimization, a Shape Transform Module is proposed to unite the text detection and recognition into a whole framework. A segmentation-based detector is carefully designed to distinguish text instances and capture the latent information of text reading orders. Extensive experiments show that our method achieves competitive result in standard text benchmarks and the state-of-the-art in both detection and end-to-end evaluations on popular irregular text benchmarks.
+
+# References
+
+[Bookstein 1989] Bookstein, F. L. 1989. Principal Warps: Thin-Plate Splines and the Decomposition of Deformations. IEEE TPAMI 11(6):567-585.  
+[Bušta, Neumann, and Matas 2017] Bušta, M.; Neumann, L.; and Matas, J. 2017. Deep Textspotter: An End-to-End Trainable Scene Text Localization and Recognition Framework. In ICCV, 2223-2231.  
+[Cheng et al. 2017] Cheng, Z.; Bai, F.; Xu, Y.; Zheng, G.; Pu, S.; and Zhou, S. 2017. Focusing Attention: Towards Accurate Text Recognition in Natural Images. In ICCV, 5076-5084.  
+[Ch'ng and Chan 2017] Ch'ng, C. K., and Chan, C. S. 2017. Total-text: A Comprehensive Dataset for Scene Text Detection and Recognition. In ICDAR, volume 1, 935-942.  
+[Dai et al. 2018] Dai, Y.; Huang, Z.; Gao, Y.; Xu, Y.; Chen, K.; Guo, J.; and Qiu, W. 2018. Fused Text Segmentation Networks for Multi-oriented Scene Text Detection. In ICPR, 3604-3609.  
+[Gupta, Vedaldi, and Zisserman 2016] Gupta, A.; Vedaldi, A.; and Zisserman, A. 2016. Synthetic Data for Text Localisation in Natural Images. In CVPR, 2315-2324.  
+[He et al. 2016] He, K.; Zhang, X.; Ren, S.; and Sun, J. 2016. Deep Residual Learning for Image Recognition. In CVPR, 770-778.  
+[He et al. 2017] He, K.; Gkioxari, G.; Dollar, P.; and Girshick, R. 2017. Mask R-CNN. In ICCV, 2980-2988.  
+[He et al. 2018] He, T.; Tian, Z.; Huang, W.; Shen, C.; Qiao, Y.; and Sun, C. 2018. An End-to-End TextSpotter with Explicit Alignment and Attention. In CVPR, 5020–5029.  
+[Huang et al. 2017] Huang, J.; Rathod, V.; Sun, C.; Zhu, M.; Korattikara, A.; Fathi, A.; Fischer, I.; Wojna, Z.; Song, Y.; Guadarrama, S.; et al. 2017. Speed Accuracy Trade-offs for Modern Convolutional Object Detectors. In CVPR, 7310-7311.  
+[Jaderberg et al. 2015] Jaderberg, M.; Simonyan, K.; Zisserman, A.; et al. 2015. Spatial Transformer Networks. In NeurIPS, 2017-2025.  
+[Jaderberg, Vedaldi, and Zisserman 2014] Jaderberg, M.; Vedaldi, A.; and Zisserman, A. 2014. Deep Features for Text Spotting. In ECCV, 512-528.  
+[Karatzas et al. 2013] Karatzas, D.; Shafait, F.; Uchida, S.; Iwamura, M.; i Bigorda, L. G.; Mestre, S. R.; Mas, J.; Mota, D. F.; Almazan, J. A.; and De Las Heras, L. P. 2013. ICDAR 2013 Robust Reading Competition. In ICDAR, 1484-1493.  
+[Karatzas et al. 2015] Karatzas, D.; Gomez-Bigorda, L.; Nicolaou, A.; Ghosh, S.; Bagdanov, A.; Iwamura, M.; Matas, J.; Neumann, L.; Chandrasekhar, V. R.; Lu, S.; et al. 2015. ICDAR 2015 Competition on Robust Reading. In ICDAR, 1156-1160.  
+[Li, Wang, and Shen 2017] Li, H.; Wang, P.; and Shen, C. 2017. Towards End-to-end Text Spotting with Convolutional Recurrent Neural Networks. In ICCV, 5248-5256.  
+[Liao et al. 2017] Liao, M.; Shi, B.; Bai, X.; Wang, X.; and Liu, W. 2017. TextBoxes: A Fast Text Detector with a Single Deep Neural Network. In AAAI, 4161-4167.  
+[Liao, Shi, and Bai 2018] Liao, M.; Shi, B.; and Bai, X. 2018. TextBoxes++: A Single-Shot Oriented Scene Text Detector. IEEE TIP 27(8):3676-3690.  
+[Lin et al. 2017] Lin, T.-Y.; Dollar, P.; Girshick, R.; He, K.; Hariharan, B.; and Belongie, S. 2017. Feature Pyramid Networks for Object Detection. In CVPR, 2117-2125.  
+[Liu et al. 2016] Liu, W.; Anguelov, D.; Erhan, D.; Szegedy, C.; Reed, S.; Fu, C.-Y.; and Berg, A. C. 2016. SSD: Single Shot Multibox Detector. In ECCV, 21-37. Springer.  
+[Liu et al. 2018] Liu, X.; Liang, D.; Yan, S.; Chen, D.; Qiao, Y.; and Yan, J. 2018. FOTS: Fast Oriented Text Spotting with a Unified Network. In CVPR, 5676-5685.  
+[Liu et al. 2019a] Liu, Y.; Jin, L.; Zhang, S.; Luo, C.; and Zhang, S. 2019a. Curved Scene Text Detection via Transverse and Longitudinal Sequence Connection. PR 90:337-345.
+
+[Liu et al. 2019b] Liu, Z.; Lin, G.; Yang, S.; Liu, F.; Lin, W.; and Goh, W. L. 2019b. Towards Robust Curve Text Detection With Conditional Spatial Expansion. In CVPR.  
+[Long et al. 2018] Long, S.; Ruan, J.; Zhang, W.; He, X.; Wu, W.; and Yao, C. 2018. Textsnake: A Flexible Representation for Detecting Text of Arbitrary Shapes. In ECCV, 19-35.  
+[Luo, Jin, and Sun 2019] Luo, C.; Jin, L.; and Sun, Z. 2019. MORAN: A Multi-Object Rectified Attention Network for Scene Text Recognition. PR.  
+[Lyu et al. 2018] Lyu, P.; Liao, M.; Yao, C.; Wu, W.; and Bai, X. 2018. Mask Textspotter: An End-to-End Trainable Neural Network for Spotting Text with Arbitrary Shapes. In ECCV, 71-88.  
+[Ma et al. 2018] Ma, J.; Shao, W.; Ye, H.; Wang, L.; Wang, H.; Zheng, Y.; and Xue, X. 2018. Arbitrary-Oriented Scene Text Detection via Rotation Proposals. IEEE TMM 20(11):3111-3122.  
+[Milletari, Navab, and Ahmadi 2016] Milletari, F.; Navab, N.; and Ahmadi, S.-A. 2016. V-net: Fully Convolutional Neural Networks for Volumetric Medical Image Segmentation. In 3DV, 565-571.  
+[Ren et al. 2015] Ren, S.; He, K.; Girshick, R.; and Sun, J. 2015. Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks. In NeurIPS, 91-99.  
+[Shi, Bai, and Yao 2017] Shi, B.; Bai, X.; and Yao, C. 2017. An End-to-End Trainable Neural Network for Image-based Sequence Recognition and Its Application to Scene Text Recognition. IEEE TPAMI 39(11):2298-2304.  
+[Shi et al. 2016] Shi, B.; Wang, X.; Lyu, P.; Yao, C.; and Bai, X. 2016. Robust Scene Text Recognition with Automatic Rectification. In CVPR, 4168-4176.  
+[Shrivastava, Gupta, and Girshick 2016] Shrivastava, A.; Gupta, A.; and Girshick, R. 2016. Training Region-based Object Detectors with Online Hard Example Mining. In CVPR, 761-769.  
+[Sun et al. 2018] Sun, Y.; Zhang, C.; Huang, Z.; Liu, J.; Han, J.; and Ding, E. 2018. TextNet: Irregular Text Reading from Images with an End-to-End Trainable Network. In ACCV.  
+[Wang et al. 2012] Wang, T.; Wu, D. J.; Coates, A.; and Ng, A. Y. 2012. End-to-End Text Recognition with Convolutional Neural Networks. In ICPR, 3304–3308.  
+[Wang et al. 2019] Wang, W.; Xie, E.; Li, X.; Hou, W.; Lu, T.; Yu, G.; and Shao, S. 2019. Shape Robust Text Detection With Progressive Scale Expansion Network. In CVPR.  
+[Wu and Natarajan 2017] Wu, Y., and Natarajan, P. 2017. Self-organized Text Detection with Minimal Post-processing via Border Learning. In ICCV, 5010-5019.  
+[Xie et al. 2019] Xie, E.; Zang, Y.; Shao, S.; Yu, G.; Yao, C.; and Li, G. 2019. Scene Text Detection with Supervised Pyramid Context Network. In AAAI.  
+[Xu et al. 2019] Xu, Y.; Wang, Y.; Zhou, W.; Wang, Y.; Yang, Z.; and Bai, X. 2019. Textfield: Learning a deep direction field for irregular scene text detection. IEEE TIP.  
+[Xue, Lu, and Zhan 2018] Xue, C.; Lu, S.; and Zhan, F. 2018. Accurate Scene Text Detection through Border Semantics Awareness and Bootstrapping. In ECCV, 370-387.  
+[Zhan and Lu 2019] Zhan, F., and Lu, S. 2019. Esir: End-to-end scene text recognition via iterative image rectification. In CVPR, 2059-2068.  
+[Zhang et al. 2018] Zhang, S.; Liu, Y.; Jin, L.; and Luo, C. 2018. Feature Enhancement Network: A Refined Scene Text Detector. In AAAI.  
+[Zhang et al. 2019] Zhang, C.; Liang, B.; Huang, Z.; En, M.; Han, J.; Ding, E.; and Ding, X. 2019. Look More Than Once: An Accurate Detector for Text of Arbitrary Shapes. In CVPR.  
+[Zhou et al. 2017] Zhou, X.; Yao, C.; Wen, H.; Wang, Y.; Zhou, S.; He, W.; and Liang, J. 2017. EAST: An Efficient and Accurate Scene Text Detector. In CVPR, 2642-2651.

2002.06xxx/2002.06820/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f029c8f39c6aab7e60b49de7f3eda10242352069f481b3f29dc42a8b35ee82b1
+size 732452

2002.06xxx/2002.06823/1208346c-943e-418a-bd6c-6ac7c06ca7ef_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:46d4e7702f3dc91aca43e4ee43659f2b65ea80cfd758dc1719202c4d4a1bdb00
+size 755008

2002.06xxx/2002.06823/full.md

@@ -0,0 +1,435 @@
+# INCORPORATING BERT INTO NEURAL MACHINE TRANSLATION
+
+Jinhua Zhu $^{1,*}$ , Yingce Xia $^{2,*}$ , Lijun Wu $^{3}$ , Di He $^{4}$
+
+Tao Qin $^{2}$ , Wengang Zhou $^{1}$ , Houqiang Li $^{1}$ , Tie-Yan Liu $^{2}$
+
+$^{1}$ CAS Key Laboratory of GIPAS, EEIS Department, University of Science and Technology of China;  
+2Microsoft Research;  
+$^{3}$ Sun Yat-sen University;  
+<sup>4</sup>Key Laboratory of Machine Perception (MOE), School of EECS, Peking University  
+teslazhu@mail.ustc.edu.cn,{zhwg,lihq}@ustc.edu.cn  
+2yingce.xia@gmail.com, {taoqin,tyliu}@microsoft.com  
+$^{3}$ wulijun3@mail2.sysu.edu.cn  $^{4}$ di_he@pku.edu.cn
+
+# ABSTRACT
+
+The recently proposed BERT (Devlin et al., 2019) has shown great power on a variety of natural language understanding tasks, such as text classification, reading comprehension, etc. However, how to effectively apply BERT to neural machine translation (NMT) lacks enough exploration. While BERT is more commonly used as fine-tuning instead of contextual embedding for downstream language understanding tasks, in NMT, our preliminary exploration of using BERT as contextual embedding is better than using for fine-tuning. This motivates us to think how to better leverage BERT for NMT along this direction. We propose a new algorithm named BERT-fused model, in which we first use BERT to extract representations for an input sequence, and then the representations are fused with each layer of the encoder and decoder of the NMT model through attention mechanisms. We conduct experiments on supervised (including sentence-level and document-level translations), semi-supervised and unsupervised machine translation, and achieve state-of-the-art results on seven benchmark datasets. Our code is available at https://github.com/bert-nmt/bert-nmt.
+
+# 1 INTRODUCTION
+
+Recently, pre-training techniques, like ELMo (Peters et al., 2018), GPT/GPT-2 (Radford et al., 2018; 2019), BERT (Devlin et al., 2019), cross-lingual language model (briefly, XLM) (Lample & Conneau, 2019), XLNet (Yang et al., 2019b) and RoBERTa (Liu et al., 2019) have attracted more and more attention in machine learning and natural language processing communities. The models are first pre-trained on large amount of unlabeled data to capture rich representations of the input, and then applied to the downstream tasks by either providing context-aware embeddings of an input sequence (Peters et al., 2018), or initializing the parameters of the downstream model (Devlin et al., 2019) for fine-tuning. Such pre-training approaches lead to significant improvements on natural language understanding tasks. Among them, BERT is one of the most powerful techniques that inspires lots of variants like XLNet, XLM, RoBERTa and achieves state-of-the-art results for many language understanding tasks including reading comprehension, text classification, etc (Devlin et al., 2019).
+
+Neural Machine Translation (NMT) aims to translate an input sequence from a source language to a target language. An NMT model usually consists of an encoder to map an input sequence to hidden representations, and a decoder to decode hidden representations to generate a sentence in the target language. Given that BERT has achieved great success in language understanding tasks, a question worthy studying is how to incorporate BERT to improve NMT. Due to the computation resource limitation, training a BERT model from scratch is unaffordable for many researchers. Thus, we focus on the setting of leveraging a pre-trained BERT model (instead of training a BERT model from scratch) for NMT.
+
+Given that there is limited work leveraging BERT for NMT, our first attempt is to try two previous strategies: (1) using BERT to initialize downstream models and then fine-tuning the models, and (2) using BERT as context-aware embeddings for downstream models. For the first strategy, following Devlin et al. (2019), we initialize the encoder of an NMT model with a pre-trained BERT model, and then finetune the NMT model on the downstream datasets. Unfortunately, we did not observe significant improvement. Using a pre-trained XLM (Lample & Conneau, 2019) model, a variant of BERT for machine translation, to warm up an NMT model is another choice. XLM has been verified to be helpful for WMT'16 Romanian-to-English translation. But when applied to a language domain beyond the corpus for training XLM (such as IWSLT dataset (Cettolo et al., 2014), which is about spoken languages) or when large bilingual data is available for downstream tasks, no significant improvement is observed neither. For the second strategy, following the practice of (Peters et al., 2018), we use BERT to provide context-aware embeddings for the NMT model. We find that this strategy outperforms the first one (please refer to Section 3 for more details). This motivates us to go along this direction and design more effective algorithms.
+
+We propose a new algorithm, BERT-fused model, in which we exploit the representation from BERT by feeding it into all layers rather than served as input embeddings only. We use the attention mechanism to adaptively control how each layer interacts with the representations, and deal with the case that BERT module and NMT module might use different word segmentation rules, resulting in different sequence (i.e., representation) lengths. Compared to standard NMT, in addition to BERT, there are two extra attention modules, the BERT-encoder attention and BERT-decoder attention. An input sequence is first transformed into representations processed by BERT. Then, by the BERT-encoder attention module, each NMT encoder layer interacts with the representations obtained from BERT and eventually outputs fused representations leveraging both BERT and the NMT encoder. The decoder works similarly and fuses BERT representations and NMT encoder representations.
+
+We conduct 14 experiments on various NMT tasks to verify our approach, including supervised, semi-supervised and unsupervised settings. For supervised NMT, we work on five tasks of IWSLT datasets and two WMT datasets. Specifically, we achieve 36.11 BLEU score on IWSLT'14 German-to-English translation, setting a new record on this task. We also work on two document-level translations of IWSLT, and further boost the BLEU score of German-to-English translation to 36.69. On WMT'14 datasets, we achieve 30.75 BLEU score on English-to-German translation and 43.78 on English-to-French translation, significantly better over the baselines. For semi-supervised NMT, we boost BLEU scores of WMT'16 Romanian-to-English translation with back translation (Sennrich et al., 2016b), a classic semi-supervised algorithm, from 37.73 to 39.10, achieving the best result on this task. Finally, we verify our algorithm on unsupervised English  $\leftrightarrow$  French and unsupervised English  $\leftrightarrow$  Romanian translations and also achieve state-of-the-art results.
+
+# 2 BACKGROUND AND RELATED WORK
+
+We briefly introduce the background of NMT and review current pre-training techniques.
+
+NMT aims to translate an input sentence from the source language to the target one. An NMT model usually consists of an encoder, a decoder and an attention module. The encoder maps the input sequence to hidden representations and the decoder maps the hidden representations to the target sequence. The attention module is first introduced by Bahdanau et al. (2015), which is used to better align source words and target words. The encoder and decoder can be specialized as LSTM (Hochreiter & Schmidhuber, 1997; Sutskever et al., 2014; Wu et al., 2016), CNN (Gehring et al., 2017) and Transformer (Vaswani et al., 2017). A Transformer layer consists of three sublayers, a self-attention layer that processes sequential data taking the context of each timestep into consideration, an optional encoder-decoder attention layer that bridges the input sequence and target sequence which exists in decoder only, and a feed-forward layer for non-linear transformation. Transformer achieves the state-of-the-art results for NMT (Barrault et al., 2019). In this work, we will use Transformer as the basic architecture of our model.
+
+Pre-training has a long history in machine learning and natural language processing (Erhan et al., 2009; 2010). Mikolov et al. (2013) and Pennington et al. (2014) proposed to use distributional representations (i.e., word embeddings) for individual words. Dai & Le (2015) proposed to train a language model or an auto-encoder with unlabeled data and then leveraged the obtained model to finetune downstream tasks. Pre-training has attracted more and more attention in recent years
+
+and achieved great improvements when the data scale becomes large and deep neural networks are employed. ELMo was proposed in Peters et al. (2018) based on bidirectional LSTMs and its pre-trained models are fed into downstream tasks as context-aware inputs. In GPT (Radford et al., 2018), a Transformer based language model is pre-trained on unlabeled dataset and then finetuned on downstream tasks. BERT (Devlin et al., 2019) is one of the widely adopted pre-training approach for model initialization. The architecture of BERT is the encoder of Transformer (Vaswani et al., 2017). Two kinds of objective functions are used in BERT training: (1) Masked language modeling (MLM), where  $15\%$  words in a sentence are masked and BERT is trained to predict them with their surrounding words. (2) Next sentence prediction (NSP): Another task of pre-training BERT is to predict whether two input sequences are adjacent. For this purpose, the training corpus consists of tuples ([cls], input 1, [sep], input 2, [sep]), with learnable special tokens [cls] to classify whether input 1 and input 2 are adjacent and [sep] to segment two sentences, and with probability  $50\%$ , the second input is replaced with a random input. Variants of BERT have been proposed: In XLM (Lample & Conneau, 2019), the model is pre-trained based on multiple languages and NSP task is removed; in RoBERTa (Liu et al., 2019), more unlabeled data is leveraged without NSP task neither; in XLNet (Yang et al., 2019b), a permutation based modeling is introduced.
+
+# 3 A PRELIMINARY EXPLORATION
+
+While a few pieces of work (Lample & Conneau, 2019; Song et al., 2019) design specific pretraining methods for NMT, they are time and resource consuming given that they need to pre-train large models from scratch using large-scale data, and even one model for each language pair. In this work, we focus on the setting of using a pre-trained BERT model. Detailed model download links can be found in Appendix D.
+
+Considering that pre-trained models have been utilized in two different ways for other natural language tasks, it is straightforward to try them for NMT. Following previous practice, we make the following attempts.
+
+(I) Use pre-trained models to initialize the NMT model. There are different implementations for this approach. (1) Following (Devlin et al., 2019), we initialize the encoder of an NMT model with a pretrained BERT. (2) Following (Lample & Conneau, 2019), we initialize the encoder and/or decoder of an NMT model with XLM.
+
+(II) Use pre-trained models as inputs to the NMT model. Inspired from (Peters et al., 2018), we feed the outputs of the last layer of BERT to an NMT model as its inputs.
+
+We conduct experiments on the IWSLT'14 English  $\rightarrow$  German translation, a widely adopted dataset for machine translation consisting of  $160k$  labeled sentence pairs. We choose Transformer (Vaswani et al., 2017) as the basic model architecture with transformer_iwslt_de_en configuration (a six-layer model with 36.7M parameters). The translation quality is evaluated by BLEU (Papineni et al., 2002) score; the larger, the better. Both  $\mathrm{BERT}_{\mathrm{base}}$  and XLM models are pre-trained and we get them from the Web. More details about the experimental settings are included in Appendix A.2.
+
+Table 1: Preliminary explorations on IWSLT'14 English  $\rightarrow$  German translation.  
+
+<table><tr><td>Algorithm</td><td>BLEU score</td></tr><tr><td>Standard Transformer</td><td>28.57</td></tr><tr><td>Use BERT to initialize the encoder of NMT</td><td>27.14</td></tr><tr><td>Use XLM to initialize the encoder of NMT</td><td>28.22</td></tr><tr><td>Use XLM to initialize the decoder of NMT</td><td>26.13</td></tr><tr><td>Use XLM to initialize both the encoder and decoder of NMT</td><td>28.99</td></tr><tr><td>Leveraging the output of BERT as embeddings</td><td>29.67</td></tr></table>
+
+The results are shown in Table 1. We have several observations: (1) Using BERT to initialize the encoder of NMT can only achieve 27.14 BLEU score, which is even worse than standard Transformer without using BERT. That is, simply using BERT to warm up an NMT model is not a good choice. (2) Using XLM to initialize the encoder or decoder respectively, we get 28.22 or 26.13 BLEU score, which does not outperform the baseline. If both modules are initialized with XLM, the BLEU score
+
+is boosted to 28.99, slightly outperforming the baseline. Although XLM achieved great success on WMT'16 Romanian-to-English, we get limited improvement here. Our conjecture is that the XLM model is pre-trained on news data, which is out-of-domain for IWSLT dataset mainly about spoken languages and thus, leading to limited improvement. (3) When using the output of BERT as context-aware embeddings of the encoder, we achieve 29.67 BLEU, much better than using pretrained models for initialization. This shows that leveraging BERT as a feature provider is more effective in NMT. This motivates us to take one step further and study how to fully exploit such features provided by pre-trained BERT models.
+
+# 4 ALGORITHM
+
+In this section, we first define the necessary notations, then introduce our proposed BERT-fused model and finally provide discussions with existing works.
+
+Notations Let  $\mathcal{X}$  and  $\mathcal{Y}$  denote the source language domain and target language domain respectively, which are the collections of sentences with the corresponding languages. For any sentence  $x\in \mathcal{X}$  and  $y\in \mathcal{Y}$ , let  $l_{x}$  and  $l_{y}$  denote the number of units (e.g., words or sub-words) in  $x$  and  $y$ . The  $i$ -th unit in  $x/y$  is denoted as  $x_i/y_i$ . Denote the encoder, decoder and BERT as Enc, Dec and BERT respectively. For ease of reference, we call the encoder and decoder in our work as the NMT module. W.l.o.g., we assume both the encoder and decoder consists of  $L$  layers. Let  $\mathrm{att}(q,K,V)$  denote the attention layer, where  $q$ ,  $K$  and  $V$  indicate query, key and value respectively (Vaswani et al., 2017). We use the same feed-forward layer as that used in (Vaswani et al., 2017) and denote it as FFN. Mathematical formulations of the above layers are left at Appendix E.
+
+# 4.1 BERT-FUSED MODEL
+
+An illustration of our algorithm is shown in Figure 1. Any input  $x \in \mathcal{X}$  is progressively processed by the BERT, encoder and decoder.
+
+![](images/79105ceb35dcc98df1dacdf2a05e86d69ced1f34f0fdc08588f37d18d8a0e179.jpg)  
+Figure 1: The architecture of BERT-fused model. The left and right figures represent the BERT, encoder and decoder respectively. Dash lines denote residual connections.  $H_{B}$  (red part) and  $H_{E}^{L}$  (green part) denote the output of the last layer from BERT and encoder.
+
+Step-1: Given any input  $x \in \mathcal{X}$ , BERT first encodes it into representation  $H_{B} = \mathrm{BERT}(x)$ .  $H_{B}$  is the output of the last layer in BERT. The  $h_{B,i} \in H_{B}$  is the representation of the  $i$ -th wordpiece in  $x$ .
+
+Step-2: Let  $H_E^l$  denote the hidden representation of  $l$ -th layer in the encoder, and let  $H_E^0$  denote word embedding of sequence  $x$ . Denote the  $i$ -th element in  $H_E^l$  as  $h_i^l$  for any  $i \in [l_x]$ . In the  $l$ -th
+
+layer,  $l\in [L]$
+
+$$
+\tilde {h} _ {i} ^ {l} = \frac {1}{2} \left(\operatorname {a t t n} _ {S} \left(h _ {i} ^ {l - 1}, H _ {E} ^ {l - 1}, H _ {E} ^ {l - 1}\right) + \operatorname {a t t n} _ {B} \left(h _ {i} ^ {l - 1}, H _ {B}, H _ {B}\right)\right), \forall i \in [ l _ {x} ], \tag {1}
+$$
+
+where  $\mathrm{att}_{S}$  and  $\mathrm{att}_{B}$  are attention models (see Eqn.(6)) with different parameters. Then each  $\tilde{h}_i^l$  is further processed by  $\mathrm{FFN}(\cdot)$  defined in Eqn.(7) and we get the output of the  $l$ -th layer:  $H_{E}^{l} = (\mathrm{FFN}(\tilde{h}_{1}^{l}),\dots ,\mathrm{FFN}(\tilde{h}_{l_{x}}^{l}))$ . The encoder will eventually output  $H_{E}^{L}$  from the last layer.
+
+Step-3: Let  $S_{<t}^{l}$  denote the hidden state of  $l$ -th layer in the decoder preceding time step  $t$ , i.e.,  $S_{<t}^{l} = (s_{1}^{l}, \dots, s_{t-1}^{l})$ . Note  $s_{1}^{0}$  is a special token indicating the start of a sequence, and  $s_{t}^{0}$  is the embedding of the predicted word at time-step  $t - 1$ . At the  $l$ -th layer, we have
+
+$$
+\begin{array}{l} \hat {s} _ {t} ^ {l} = \operatorname {a t t n} _ {S} \left(s _ {t} ^ {l - 1}, S _ {<   t + 1} ^ {l - 1}, S _ {<   t + 1} ^ {l - 1}\right); \\ \tilde {s} _ {t} ^ {l} = \frac {1}{2} \left(\operatorname {a t t n} _ {B} \left(\hat {s} _ {t} ^ {l}, H _ {B}, H _ {B}\right) + \operatorname {a t t n} _ {E} \left(\hat {s} _ {t} ^ {l}, H _ {E} ^ {L}, H _ {E} ^ {L}\right)\right), s _ {t} ^ {l} = \text {F F N} \left(\tilde {s} _ {t} ^ {l}\right). \tag {2} \\ \end{array}
+$$
+
+The  $\mathrm{attn}_S$ ,  $\mathrm{attn}_B$  and  $\mathrm{attn}_E$  represent self-attention model, BERT-decoder attention model and encoder-decoder attention model respectively. Eqn.(2) iterates over layers and we can eventually obtain  $s_t^L$ . Finally  $s_t^L$  is mapped via a linear transformation and softmax to get the  $t$ -th predicted word  $\hat{y}_t$ . The decoding process continues until meeting the end-of-sentence token.
+
+In our framework, the output of BERT serves as an external sequence representation, and we use an attention model to incorporate it into the NMT model. This is a general way to leverage the pre-trained model regardless of the tokenization way.
+
+# 4.2 DROP-NET TRICK
+
+Inspired by dropout (Srivastava et al., 2014) and drop-path (Larsson et al., 2017), which can regularize the network training, we propose a drop-net trick to ensure that the features output by BERT and the conventional encoder are fully utilized. The drop-net will effect Eqn.(1) and Eqn.(2). Denote the drop-net rate as  $p_{\mathrm{net}} \in [0,1]$ . At each training iteration, for any layer  $l$ , we uniformly sample a random variable  $U^{l}$  from  $[0,1]$ , then all the  $\tilde{h}_i^l$  in Eqn.(1) are calculated in the following way:
+
+$$
+\begin{array}{l} \tilde {h} _ {i, \text {d r o p - n e t}} ^ {l} = \mathbb {I} \left(U ^ {l} <   \frac {p _ {\text {n e t}}}{2}\right) \cdot \operatorname {a t t n} _ {S} \left(h _ {i} ^ {l - 1}, H _ {E} ^ {l - 1}, H _ {E} ^ {l - 1}\right) + \mathbb {I} \left(U ^ {l} > 1 - \frac {p _ {\text {n e t}}}{2}\right) \cdot \operatorname {a t t n} _ {B} \left(h _ {i} ^ {l - 1}, H _ {B}, H _ {B}\right) \tag {3} \\ + \frac {1}{2} \mathbb {I} \big (\frac {p _ {\mathrm {n e t}}}{2} \leq U ^ {l} \leq 1 - \frac {p _ {\mathrm {n e t}}}{2} \big) \cdot \big (\mathrm {a t t n} _ {S} (h _ {i} ^ {l - 1}, H _ {E} ^ {l - 1}, H _ {E} ^ {l - 1}) + \mathrm {a t t n} _ {B} (h _ {i} ^ {l - 1}, H _ {B}, H _ {B}) \big), \\ \end{array}
+$$
+
+where  $\mathbb{I}(\cdot)$  is the indicator function. For any layer, with probability  $p_{\mathrm{net}} / 2$ , either the BERT-encoder attention or self-attention is used only; w.p.  $(1 - p_{\mathrm{net}})$ , both the two attention models are used. For example, at a specific iteration, the first layer might uses  $\mathrm{att}_S$  only while the second layer uses  $\mathrm{att}_B$  only. During inference time, the expected output of each attention model is used, which is  $\mathbb{E}_{U\sim \mathrm{uniform}[0,1]}(\tilde{h}_{i,\mathrm{drop - net}}^l)$ . The expectation is exactly Eqn.(1).
+
+Similarly, for training of the decoder, with the drop-net trick, we have
+
+$$
+\begin{array}{l} \tilde {s} _ {t, \text {d r o p - n e t}} ^ {l} = \mathbb {I} \left(U ^ {l} <   \frac {p _ {\text {n e t}}}{2}\right) \cdot \operatorname {a t t n} _ {B} \left(\hat {s} _ {t} ^ {l}, H _ {B}, H _ {B}\right) + \mathbb {I} \left(U ^ {l} > 1 - \frac {p _ {\text {n e t}}}{2}\right) \cdot \operatorname {a t t n} _ {E} \left(\hat {s} _ {t} ^ {l}, H _ {E} ^ {L}, H _ {E} ^ {L}\right) \\ + \frac {1}{2} \mathbb {I} \left(\frac {p _ {\text {n e t}}}{2} \leq U ^ {l} \leq 1 - \frac {p _ {\text {n e t}}}{2}\right) \cdot \left(\operatorname {a t t n} _ {B} \left(\hat {s} _ {t} ^ {l}, H _ {B}, H _ {B}\right) + \operatorname {a t t n} _ {E} \left(\hat {s} _ {t} ^ {l}, H _ {E} ^ {L}, H _ {E} ^ {L}\right)\right). \tag {4} \\ \end{array}
+$$
+
+For inference, it is calculated in the same way as Eqn.(2). Using this technique can prevent network from overfitting (see the second part of Section 6 for more details).
+
+# 4.3 DISCUSSION
+
+Comparison with ELMo As introduced in Section 2, ELMo (Peters et al., 2018) provides a context-aware embeddings for the encoder in order to capture richer information of the input sequence. Our approach is a more effective way of leveraging the features from the pre-trained model: (1) The output features of the pre-trained model are fused in all layers of the NMT module, ensuring the well-pre-trained features are fully exploited; (2) We use the attention model to bridge the NMT module and the pre-trained features of BERT, in which the NMT module can adaptively determine how to leverage the features from BERT.
+
+Limitations We are aware that our approach has several limitations. (1) Additional storage cost: our approach leverages a BERT model, which results in additional storage cost. However, considering the BLEU improvement and the fact that we do not need additional training of BERT, we believe that the additional storage is acceptable. (2) Additional inference time: We use BERT to encode the input sequence, which takes about  $45\%$  additional time (see Appendix C for details). We will leave the improvement of the above two limitations as future work.
+
+# 5 APPLICATION TO SUPERVISED NMT AND SEMI-SUPERVISED NMT
+
+We first verify our BERT-fused model on the supervised setting, including low-resource and richresource scenarios. Then we conduct experiments on document-level translation to verify our approach. Finally, we combine BERT-fused model with back translation (Sennrich et al., 2016b) to verify the effectiveness of our method on semi-supervised NMT.
+
+# 5.1 SETTINGS
+
+Dataset For the low-resource scenario, we choose IWSLT'14 English  $\leftrightarrow$  German (En  $\leftrightarrow$  De), English  $\rightarrow$  Spanish (En  $\rightarrow$  Es), IWSLT'17 English  $\rightarrow$  French (En  $\rightarrow$  Fr) and English  $\rightarrow$  Chinese (En  $\rightarrow$  Zh) translation. There are  $160k$ ,  $183k$ ,  $236k$ ,  $235k$  bilingual sentence pairs for En  $\leftrightarrow$  De, En  $\rightarrow$  Es, En  $\rightarrow$  Fr and En  $\rightarrow$  Zh tasks. Following the common practice (Edunov et al., 2018), for En  $\leftrightarrow$  De, we lowercase all words. All sentences are preprocessed by BPE (Sennrich et al., 2016c). The model configuration is transformer_iwslt_de_en, representing a six-layer model with embedding size 512 and FFN layer dimension 1024. For the rich-resource scenario, we work on WMT'14 En  $\rightarrow$  De and En  $\rightarrow$  Fr, whose corpus sizes are  $4.5M$  and  $36M$  respectively. We concatenate newtest2012 and newtest2013 as the validation set and use newtest2014 as the test set. The model configuration is transformer/big, another six-layer network with embedding size 1024 and FFN layer dimension 4096. More details about data and model are left in Appendix A.1.
+
+We choose  $\mathrm{BERT}_{\mathrm{base}}$  for IWSLT tasks and  $\mathrm{BERT}_{\mathrm{large}}$  for WMT tasks, which can ensure that the dimension of the BERT and NMT model almost match. The BERT models are fixed during training. Detailed BERT information for each task is in Appendix D. The drop-net rate  $p_{\mathrm{net}}$  is set as 1.0.
+
+Training Strategy We first train an NMT model until convergence, then initialize the encoder and decoder of the BERT-fused model with the obtained model. The BERT-encoder attention and BERT-decoder attention are randomly initialized. Experiments on IWSLT and WMT tasks are conducted on 1 and 8 M40 GPUs respectively. The batchsize is  $4k$  tokens per GPU. Following (Ott et al., 2018), for WMT tasks, we accumulate the gradient for 16 iterations and then update to simulate a 128-GPU environment. It takes 1, 8 and 14 days to obtain the pre-trained NMT models, and additional 1, 7 and 10 days to finish the whole training process. The optimization algorithm is Adam (Kingma & Ba, 2014) with initial learning rate 0.0005 and inverse_sqrt learning rate scheduler (Vaswani et al., 2017). For WMT'14 En  $\rightarrow$  De, we use beam search with width 4 and length penalty 0.6 for inference following (Vaswani et al., 2017). For other tasks, we use width 5 and length penalty 1.0.
+
+Evaluation We use multi-bleu.perl to evaluate IWSLT'14  $\mathrm{En}\leftrightarrow \mathrm{De}$  and WMT translation tasks for fair comparison with previous work. For the remaining tasks, we use a more advance implementation of BLEU score, sacreBLEU for evaluation. Script urls are in Appendix A.1.
+
+# 5.2 RESULTS
+
+The results of IWSLT translation tasks are reported in Table 2. We implemented standard Transformer as baseline. Our proposed BERT-fused model can improve the BLEU scores of the five tasks by 1.88, 1.47, 2.4, 1.9 and 2.8 points respectively, demonstrating the effectiveness of our method. The consistent improvements on various tasks shows that our method works well for low-resource translations. We achieved state-of-the-art results on IWSLT'14 De  $\rightarrow$  En translation, a widely investigated baseline in ma
+
+Table 2: BLEU of all IWSLT tasks.  
+
+<table><tr><td></td><td>Transformer</td><td>BERT-fused</td></tr><tr><td>En→De</td><td>28.57</td><td>30.45</td></tr><tr><td>De→En</td><td>34.64</td><td>36.11</td></tr><tr><td>En→Es</td><td>39.0</td><td>41.4</td></tr><tr><td>En→Zh</td><td>26.3</td><td>28.2</td></tr><tr><td>En→Fr</td><td>35.9</td><td>38.7</td></tr></table>
+
+chine translation. The comparison with previous methods are shown in Appendix B.4 due to space limitation.
+
+The results of WMT'14  $\mathrm{En}\rightarrow \mathrm{De}$  and  $\mathrm{En}\rightarrow \mathrm{Fr}$  are shown in Table 3. Our reproduced Transformer matches the results reported in Ott et al. (2018), and we can see that our BERT-fused model can improve these two numbers to 30.75 and 43.78, achieving 1.63 and 0.82 points improvement. Our approach also outperforms the well-designed model DynamicConv (Wu et al., 2019) and a model obtained through neural architecture search (So et al., 2019).
+
+Table 3: BLEU scores of WMT'14 translation.  
+
+<table><tr><td>Algorithm</td><td>En→De</td><td>En→Fr</td></tr><tr><td>DynamicConv (Wu et al., 2019)</td><td>29.7</td><td>43.2</td></tr><tr><td>Evolved Transformer (So et al., 2019)</td><td>29.8</td><td>41.3</td></tr><tr><td>Transformer + Large Batch (Ott et al., 2018)</td><td>29.3</td><td>43.0</td></tr><tr><td>Our Reproduced Transformer</td><td>29.12</td><td>42.96</td></tr><tr><td>Our BERT-fused model</td><td>30.75</td><td>43.78</td></tr></table>
+
+# 5.3 TRANSLATION WITH DOCUMENT-LEVEL CONTEXTUAL INFORMATION
+
+BERT is able to capture the relation between two sentences, since the next sentence prediction (NSP) task is to predict whether two sentences are adjacent. We can leverage this property to improve translation with document-level contextual information (Miculicich et al., 2018), which is briefly denoted as document-level translation. The inputs are a couple of sentences extracted from a paragraph/document,  $x_{1}^{d}, x_{2}^{d}, \dots, x_{T}^{d}$ , where the  $T$ $x$ 's are contextually correlated. We want to translate them into target language by considering the contextual information.
+
+Algorithm In our implementation, to translate a sentence  $x$  to target domain, we leverage the contextual information by taking both  $x$  and its preceding sentence  $x_{\mathrm{prev}}$  as inputs.  $x$  is fed into Enc, which is the same as sentence-level translation. For the input of BERT, it is the concatenation of two sequences: ([cls],  $x_{\mathrm{prev}}$ , [sep],  $x$ , [sep]), where both [cls] and [sep] are special tokens of BERT.
+
+Setting We use IWSLT'14  $\mathrm{En}\leftrightarrow \mathrm{De}$  dataset as introduced in Section 5.1. The data is a collection of TED talks, where each talk consists of several sequences. We can extract the adjacent sentences for training, validation and test sets. The training strategy, hyperparameter selection and evaluation metric are the same for sentence-level translation.
+
+Baselines We use two baselines here. (1) To demonstrate how BERT works in our model, we replace BERT by a Transformer with configuration transformer-iwslt-de_en, which is randomly initialized and jointly trained. (2) Another baseline is proposed by Miculicich et al. (2018), where multiple preceding sentences in a document are leveraged using a hierarchical attention network.
+
+Table 4: BLEU of document-level translation.  
+
+<table><tr><td></td><td>En→De</td><td>De→En</td></tr><tr><td>Sentence-level</td><td>28.57</td><td>34.64</td></tr><tr><td>Our Document-level</td><td>28.90</td><td>34.95</td></tr><tr><td>Miculicich et al. (2018)</td><td>27.94</td><td>33.97</td></tr><tr><td>Sentence-level + BERT</td><td>30.45</td><td>36.11</td></tr><tr><td>Document-level + BERT</td><td>31.02</td><td>36.69</td></tr></table>
+
+Results The results are shown in Table 4. We can see that introducing contextual information from an additional encoder can boost the sentence-level baselines, but the improvement is limited (0.33 for  $\mathrm{En}\rightarrow \mathrm{De}$  and 0.31 for  $\mathrm{De}\rightarrow \mathrm{En}$ ). For Miculicich et al. (2018), the best results we obtain are 27.94 and 33.97 respectively, which are worse than the sentence-level baselines. Combining BERT-fused model and document-level information, we can eventually achieve 31.02 for  $\mathrm{En}\rightarrow \mathrm{De}$  and 36.69 for  $\mathrm{De}\rightarrow \mathrm{En}$ . We perform significant test $^1$  between sentence-level and document-level translation. Our document-level BERT-fused model significantly outperforms sentence-level baseline with  $p$ -value less than 0.01. This shows that our approach not only works for sentence-level translation, but can also be generalized to document-level translation.
+
+# 5.4 APPLICATION TO SEMI-SUPERVISED NMT
+
+We work on WMT'16 Romanian  $\rightarrow$  English (Ro  $\rightarrow$  En) translation to verify whether our approach can still make improvement over back translation (Sennrich et al., 2016b), the standard and powerful semi-supervised way to leverage monolingual data in NMT.
+
+The number of bilingual sentence pairs for  $\mathrm{Ro}\rightarrow \mathrm{En}$  is  $0.6M$ . Sennrich et al. (2016a) provided  $2M$  back translated data<sup>2</sup>. We use newsdev2016 as validation set and newstest2016 as test set. Sentences were encoded using BPE with a shared source-target vocabulary of about  $32k$  tokens. We use transformer big configuration. Considering there is no Romanian BERT, we use the cased multilingual BERT (please refer to Appendix D) to encode inputs. The drop-net rate  $p_{\mathrm{net}}$  is set as 1.0. The translation quality is evaluated by multi-bleu.perl.
+
+The results are shown in Table 5. The Transformer baseline achieves 33.12 BLEU score. With back-translation, the performance is boosted to 37.73. We use the model obtained with back-translation to initialize BERT-fused model, and eventually reach 39.10 BLEU. Such a score surpasses the previous best result 38.5 achieved by XLM (Lample & Conneau, 2019) and sets a new record. This demonstrates that
+
+<table><tr><td colspan="2">Table 5: BLEU scores of WMT&#x27;16 Ro→En.</td></tr><tr><td>Methods</td><td>BLEU</td></tr><tr><td>Sennrich et al. (2016a)</td><td>33.9</td></tr><tr><td>XLM (Lample &amp; Conneau, 2019)</td><td>38.5</td></tr><tr><td>Standard Transformer</td><td>33.12</td></tr><tr><td>+ back translation</td><td>37.73</td></tr><tr><td>+ BERT-fused model</td><td>39.10</td></tr></table>
+
+our proposed approach is effective and can still achieve improvement over strong baselines.
+
+# 6 ABLATION STUDY
+
+We conduct two groups of ablation studies on IWSLT'14 En→De translation to better understand our model.
+
+Table 6: Ablation study on IWSLT'14 En→De.  
+
+<table><tr><td>Standard Transformer</td><td>28.57</td></tr><tr><td>BERT-fused model</td><td>30.45</td></tr><tr><td>Randomly initialize encoder/decoder of BERT-fused model</td><td>27.03</td></tr><tr><td>Jointly tune BERT and encoder/decoder of BERT-fused model</td><td>28.87</td></tr><tr><td>Feed BERT feature into all layers without attention</td><td>29.61</td></tr><tr><td>Replace BERT output with random vectors</td><td>28.91</td></tr><tr><td>Replace BERT with the encoder of another Transformer model</td><td>28.99</td></tr><tr><td>Remove BERT-encoder attention</td><td>29.87</td></tr><tr><td>Remove BERT-decoder attention</td><td>29.90</td></tr></table>
+
+# Study for training strategy and network architecture
+
+We conduct ablation study to investigate the performance of each component of our model and training strategy. Results are reported in Table 6:
+
+(1) We randomly initialize the NMT module (i.e., encoder and decoder) of BERT-fused model instead of using a warm-start one as introduced in the training strategy of Section 5.1. In this way, we can only achieve 27.03 BLEU score, which cannot catch up with the baseline. We also jointly train BERT model with the NMT module. Although it can also boost the baseline from 28.57 to 28.87, it is not as good as fixing the BERT part, whose BLEU is 30.45.  
+(2) We feed the output of BERT into all layers of the encoder without attention models. That is, the Eqn.(1) is revised to  $\tilde{h}_i^l = \frac{1}{2}\big(\mathsf{att}_{S}(h_i^{l - 1},H_E^{l - 1},H_E^{l - 1}) + W_B^l h_i^{l - 1})\big)$ , where  $W_{B}^{l}$  is learnable. In this case, the encoder and BERT have to share the same vocabulary. The BLEU score is 29.61, which is better than the standard Transformer but slightly worse than leveraging the output of BERT
+
+as embedding. This shows that the output of BERT should not be fused into each layer directly, and using the attention model to bridge the relation is better than using simple transformation. More results on different languages are included in Appendix B.3. To illustrate the effectiveness of our method, we choose another two kinds of ways to encode the input sequence rather than using BERT: (1) Using a fixed and randomly initialized embedding; (2) Using the encoder from another NMT model. Their BLEU scores are 28.91 and 28.99 respectively, indicating that the BERT pre-trained on large amount of unlabeled data can provide more helpful features to NMT.
+
+(3) To verify where the output of BERT should be connected to, we remove the BERT-encoder attention (i.e.,  $\text{att}_B$  in Eqn.(1)) and the BERT-decoder attention (i.e.,  $\text{att}_B$  in Eqn.(2)) respectively. Correspondingly, the BLEU score drops from 30.45 to 29.87 and 29.90. This indicates that the output of BERT should be leveraged by both encoder and decoder to achieve better performances. At last, considering that there are two stacked encoders in our model, we also choose ensemble models and deeper NMT models as baselines. Our approach outperforms the above baselines. The results are left in Appendix B.2 due to space limitation.
+
+# Study on drop-net
+
+To investigate the effect of drop-net, we conduct experiments on IWSLT'14 En→De dataset with different drop-net probability,  $p_{\mathrm{net}} \in \{0, 0.2, 0.4, 0.6, 0.8, 1.0\}$ . The results are shown in Figure 2. As can be seen, although larger  $p_{\mathrm{net}}$  leads to larger training loss, it leads to smaller validation loss and so better BLUE scores. This shows that the drop-net trick can indeed improve the generalization ability of our model. We fix  $p_{\mathrm{net}} = 1.0$  in other experiments unless specially specified.
+
+![](images/fd5b12687d0b6025a98ba4be369a1f7a8e2408c054abc1c44b9ca5620657bd7a.jpg)  
+(a) Training loss.
+
+![](images/5a93d48d53bfec5b3e5616b384f404c7d00a293cf951a98383eb6fa860d60d47.jpg)  
+(b) Validation loss.
+
+![](images/6da151e8e486a4a5ab3340d6a17579e25804ec804926972f7f4a55a4a6464be3.jpg)  
+(c) Validation BLEU.  
+Figure 2: Training/validation curves with different  $p_{\mathrm{net}}$ 's.
+
+# 7 APPLICATION TO UNSUPERVISED NMT
+
+We work on unsupervised  $\mathrm{En} \leftrightarrow \mathrm{Fr}$  and  $\mathrm{En} \leftrightarrow \mathrm{Ro}$  translation. The data processing, architecture selection and training strategy is the same as Lample & Conneau (2019).
+
+Settings For  $\mathrm{En} \leftrightarrow \mathrm{Fr}$ , we use  $190M$  monolingual English sentences and  $62M$  monolingual French sentences from WMT News Crawl datasets, which is the same as that used in (Song et al., 2019). For unsupervised  $\mathrm{En} \leftrightarrow \mathrm{Ro}$  translation, we use  $50M$  English sentences from News Crawl (sampled from the data for  $\mathrm{En} \rightarrow \mathrm{Fr}$ ) and collect  $2.9M$  sentences for Romanian by concatenating News Crawl data sets and WMT'16 Romanian monolingual data following Lample et al. (2018). The data is preprocessed in the same way as Lample & Conneau (2019).
+
+We use the same model configuration as Lample & Conneau (2019), with details in Appendix A.3. The BERT is the pre-trained XLM model (see Appendix D). We first train an unsupervised NMT model following Lample & Conneau (2019) until convergence. Then we initialize our BERT-fused model with the obtained model and continue training. We train models on 8 M40 GPUs, and the batchsize is 2000 tokens per GPU. We use the same optimization hyper-parameters as that described in Lample & Conneau (2019).
+
+Table 7: BLEU scores of unsupervised NMT.  
+
+<table><tr><td></td><td>En→Fr</td><td>Fr→En</td><td>En→Ro</td><td>Ro→En</td></tr><tr><td>Lample et al. (2018)</td><td>27.6</td><td>27.7</td><td>25.1</td><td>23.9</td></tr><tr><td>XLM (Lample &amp; Conneau, 2019)</td><td>33.4</td><td>33.3</td><td>33.3</td><td>31.8</td></tr><tr><td>MASS (Song et al., 2019)</td><td>37.50</td><td>34.90</td><td>35.20</td><td>33.10</td></tr><tr><td>Our BERT-fused model</td><td>38.27</td><td>35.62</td><td>36.02</td><td>33.20</td></tr></table>
+
+Results The results of unsupervised NMT are shown in Table 7. With our proposed BERT-fused model, we can achieve 38.27, 35.62, 36.02 and 33.20 BLEU scores on the four tasks, setting state-of-the-art results on these tasks. Therefore, our BERT-fused model also benefits unsupervised NMT.
+
+# 8 CONCLUSION AND FUTURE WORK
+
+In this work, we propose an effective approach, BERT-fused model, to combine BERT and NMT, where the BERT is leveraged by the encoder and decoder through attention models. Experiments on supervised NMT (including sentence-level and document-level translations), semi-supervised NMT and unsupervised NMT demonstrate the effectiveness of our method.
+
+For future work, there are many interesting directions. First, we will study how to speed up the inference process. Second, we can apply such an algorithm to more applications, like questioning and answering. Third, how to compress BERT-fused model into a light version is another topic. There are some contemporary works leveraging knowledge distillation to combine pre-trained models with NMT (Yang et al., 2019a; Chen et al., 2019), which is a direction to explore.
+
+# REFERENCES
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In 6th International Conference on Learning Representations, 2015. URL https://arxiv.org/pdf/1409.0473v7.pdf.  
+Loic Barrault, Ondrej Bojar, Marta R. Costa-jussá, Christian Federmann, Mark Fishel, Yvette Graham, Barry Haddow, Matthias Huck, Philipp Koehn, Shervin Malmasi, Christof Monz, Mathias Müller, Santanu Pal, Matt Post, and Marcos Zampieri. Findings of the 2019 conference on machine translation (wmt19). In Proceedings of the Fourth Conference on Machine Translation (Volume 2: Shared Task Papers, Day 1), pp. 1-61, Florence, Italy, August 2019. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/W19-5301.  
+Mauro Cettolo, Jan Niehues, Sebastian Stüker, Luisa Bentivogli, and Marcello Federico. Report on the 11th iwslt evaluation campaign, iwslt 2014. In Proceedings of the International Workshop on Spoken Language Translation, Hanoi, Vietnam, pp. 57, 2014.  
+Yen-Chun Chen, Zhe Gan, Yu Cheng, Jingzhou Liu, and Jingjing Liu. Distilling the knowledge of bert for text generation. arXiv preprint arXiv:1911.03829, 2019.  
+Andrew M Dai and Quoc V Le. Semi-supervised sequence learning. In Advances in neural information processing systems, pp. 3079-3087, 2015.  
+Yuntian Deng, Yoon Kim, Justin Chiu, Demi Guo, and Alexander Rush. Latent alignment and variational attention. In Advances in Neural Information Processing Systems, pp. 9712-9724, 2018.  
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. *NAACL*, 2019. URL https://arxiv.org/pdf/1810.04805.pdf.  
+Sergey Edunov, Myle Ott, Michael Auli, David Grangier, and Marcaurelio Ranzato. Classical structured prediction losses for sequence to sequence learning. *NAACL*, 2018.
+
+Dumitru Erhan, Pierre-Antoine Manzagol, Yoshua Bengio, Samy Bengio, and Pascal Vincent. The difficulty of training deep architectures and the effect of unsupervised pre-training. In Artificial Intelligence and Statistics, pp. 153-160, 2009.  
+Dumitru Erhan, Yoshua Bengio, Aaron Courville, Pierre-Antoine Manzagol, Pascal Vincent, and Samy Bengio. Why does unsupervised pre-training help deep learning? Journal of Machine Learning Research, 11(Feb):625-660, 2010.  
+Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann N Dauphin. Convolutional sequence to sequence learning. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1243-1252. JMLR.org, 2017.  
+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.  
+Marcin Junczys-Dowmunt and Roman Grundkiewicz. Ms-uedin submission to the wmt2018 ape shared task: Dual-source transformer for automatic post-editing. EMNLP 2018 THIRD CONFERENCE ON MACHINE TRANSLATION (WMT18), 2018.  
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.  
+Guillaume Lample and Alexis Conneau. Cross-lingual language model pretraining. NeurIPS, 2019.  
+Guillaume Lample, Myle Ott, Alexis Conneau, Ludovic Denoyer, and Marc'Aurelio Ranzato. Phrase-based & neural unsupervised machine translation. arXiv preprint arXiv:1804.07755, 2018.  
+Gustav Larsson, Michael Maire, and Gregory Shakhnarovich. Fractalnet: Ultra-deep neural networks without residuals. *ICLR*, 2017. URL https://arxiv.org/pdf/1605.07648.pdf.  
+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.  
+Lesly Miculicich, Dhananjay Ram, Nikolaos Pappas, and James Henderson. Document-level neural machine translation with hierarchical attention networks. arXiv preprint arXiv:1809.01576, 2018.  
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems, pp. 3111-3119, 2013.  
+Myle Ott, Sergey Edunov, David Grangier, and Michael Auli. Scaling neural machine translation. EMNLP 2018 third conference on machine translation (WMT18), 2018.  
+Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting on association for computational linguistics, pp. 311-318. Association for Computational Linguistics, 2002.  
+Jeffrey Pennington, Richard Socher, and Christopher Manning. Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pp. 1532-1543, 2014.  
+Matthew E Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. arXiv preprint arXiv:1802.05365, 2018.  
+Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. URL https://s3-us-west-2. amazonaws. com/openai-assetss/research-covers/languageunsupervised/language understanding paper. pdf, 2018.  
+Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. OpenAI Blog, 1(8), 2019.
+
+Rico Sennrich, Barry Haddow, and Alexandra Birch. Edinburgh neural machine translation systems for wmt 16. In Proceedings of the First Conference on Machine Translation, volume 2, pp. 371-376, 2016a. URL http://www.statmt.org/wmt16/pdf/W16-2323.pdf.  
+Rico Sennrich, Barry Haddow, and Alexandra Birch. Improving neural machine translation models with monolingual data. ACL, 2016b. URL https://aclweb.org/anthology/P16-1009.  
+Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. ACL, 2016c.  
+David So, Quoc Le, and Chen Liang. The evolved transformer. 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. 5877-5886, Long Beach, California, USA, 09-15 Jun 2019. PMLR. URL http://proceedings.mlr.press/v97/so19a.html.  
+Kaitao Song, Xu Tan, Tao Qin, Jianfeng Lu, and Tie-Yan Liu. MASS: Masked sequence to sequence pre-training for language generation. 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. 5926-5936, Long Beach, California, USA, 09-15 Jun 2019. PMLR. URL http://proceedings.mlr.press/v97/song19d.html.  
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The journal of machine learning research, 15(1):1929-1958, 2014.  
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104-3112, 2014.  
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pp. 5998-6008, 2017.  
+Yiren Wang, Yingce Xia, Tianyu He, Fei Tian, Tao Qin, ChengXiang Zhai, and Tie-Yan Liu. Multiagent dual learning. ICLR, 2019.  
+Dirk Weissenborn, Douwe Kiela, Jason Weston, and Kyunghyun Cho. Contextualized role interaction for neural machine translation, 2019. URL https://openreview.net/forum?id=ryx3_iAcY7.  
+Felix Wu, Angela Fan, Alexei Baevski, Yann Dauphin, and Michael Auli. Pay less attention with lightweight and dynamic convolutions. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id=SkVhlh09tX.  
+Lijun Wu, Fei Tian, Yingce Xia, Yang Fan, Tao Qin, Lai Jian-Huang, and Tie-Yan Liu. Learning to teach with dynamic loss functions. In Advances in Neural Information Processing Systems, pp. 6466-6477, 2018.  
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google's neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016.  
+Yingce Xia, Tianyu He, Xu Tan, Fei Tian, Di He, and Tao Qin. Tied transformers: Neural machine translation with shared encoder and decoder. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 5466-5473, 2019.  
+Jiacheng Yang, Mingxuan Wang, Hao Zhou, Chengqi Zhao, Yong Yu, Weinan Zhang, and Lei Li. Towards making the most of bert in neural machine translation. arXiv preprint arXiv:1908.05672, 2019a. URL https://arxiv.org/pdf/1908.05672.pdf.  
+Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. arXiv preprint arXiv:1906.08237, 2019b.
+
+# A EXPERIMENT SETUP
+
+# A.1 IWSLT'14 & WMT'14 SETTINGS
+
+We mainly follow the scripts below to preprocess the data: https://github.com/pytorch/fairseq/tree/master/examples/translation.
+
+Dataset For the low-resource scenario, we choose IWSLT'14 English  $\leftrightarrow$  German (En  $\leftrightarrow$  De), English  $\rightarrow$  Spanish (En  $\rightarrow$  Es), IWSLT'17 English  $\rightarrow$  French (En  $\rightarrow$  Fr) and English  $\rightarrow$  Chinese (En  $\rightarrow$  Zh) translation. There are  $160k$ ,  $183k$ ,  $236k$ ,  $235k$  bilingual sentence pairs for En  $\leftrightarrow$  De, En  $\rightarrow$  Es, En  $\rightarrow$  Fr and En  $\rightarrow$  Zh tasks. Following the common practice (Edunov et al., 2018), for En  $\leftrightarrow$  De, we lowercase all words, split  $7k$  sentence pairs from the training dataset for validation and concatenate dev2010, dev2012, tst2010, tst2011, tst2012 as the test set. For other tasks, we do not lowercase the words and use the official validation/test sets of the corresponding years.
+
+For rich-resource scenario, we work on WMT'14  $\mathrm{En}\rightarrow \mathrm{De}$  and  $\mathrm{En}\rightarrow \mathrm{Fr}$ , whose corpus sizes are  $4.5M$  and  $36M$  respectively. We concatenate newstest2012 and newstest2013 as the validation set and use newstest2014 as the test set.
+
+We apply BPE (Sennrich et al., 2016c) to split words into sub-units. The numbers of BPE merge operation for IWSLT tasks, WMT'14  $\mathrm{En}\rightarrow \mathrm{De}$  and  $\mathrm{En}\rightarrow \mathrm{Fr}$  are  $10k$ ,  $32k$  and  $40k$  respectively. We merge the source and target language sentences for all tasks to build the vocabulary except  $\mathrm{En}\rightarrow \mathrm{Zh}$ .
+
+Model Configuration For IWSLT tasks, we use the transformer_iwslt_de_en setting with dropout ratio 0.3. In this setting, the embedding dimension, FFN layer dimension and number of layers are 512, 1024 and 6. For WMT'14 En→De and En→Fr, we use transformer/big setting (short for transformer_vaswani_wmt_en_de/big) with dropout 0.3 and 0.1 respectively. In this setting, the aforementioned three parameters are 1024, 4096 and 6 respectively.
+
+Evaluation We use multi-bleu.perl<sup>4</sup> to evaluate IWSLT'14 En←De and WMT translation tasks for fair comparison with previous work. For the remaining tasks, we use a more advance implementation of BLEU score, detokenized sacreBLEU for evaluation<sup>5</sup>.
+
+# A.2 DETAILED EXPERIMENT SETTING IN SECTION 3
+
+The IWSLT'14 English-to-German data and model configuration is introduced in Section A.1.
+
+For the training strategy, we use Adam (Kingma & Ba, 2014) to optimize the network with  $\beta_{1} = 0.9$ ,  $\beta_{2} = 0.98$  and weight-decay  $= 0.0001$ . The learning rate scheduler is inverse_sqrt, where warmup-init-1r  $= 10^{-7}$ , warmup-updates  $= 4000$  and max-1r  $= 0.0005$ .
+
+# A.3 DETAILED MODEL CONFIGURATION IN UNSUPERVISED NMT
+
+We leverage one Transformer model with GELU activation function to work on translations of two directions, where each language is associated with a language tag. The embedding dimension, FFN layer dimension and number of layer are 1024, 4096 and 6. The BERT is initialized by the pretrained XLM model provided by (Lample & Conneau, 2019).
+
+# B MORE EXPERIMENT RESULTS
+
+# B.1 MORE RESULTS ON PRELIMINARY EXPLORATION OF LEVERAGING BERT
+
+We use XLM to initialize the model for WMT'14 English  $\rightarrow$  German translation task, whose training corpus is relative large. We eventually obtain 28.09 after 90 epochs, which is still underperform the baseline, 29.12 as we got. Similar problem is also reported in https://github.com/facebookresearch/XLM/issues/32. We leave the improvement of supervised NMT with XLM as future work.
+
+# B.2 MORE ABLATION STUDY
+
+# Part I: A different way to deal with multiple attention models
+
+Junczys-Dowmunt & Grundkiewicz (2018) proposed a new way to handle multiple attention models. Instead of using Eqn.(2), the input is processed by self-attention, encoder-decoder attention and BERT-decoder attention sequentially. Formally,
+
+$$
+\begin{array}{l} \hat {s} _ {t} ^ {l} = \operatorname {a t t n} _ {S} \left(s _ {t} ^ {l - 1}, S _ {<   t + 1} ^ {l - 1}, S _ {<   t + 1} ^ {l - 1}\right); \\ \bar {s} _ {t} ^ {l} = \operatorname {a t t n} _ {E} \left(\hat {s} _ {t} ^ {l}, H _ {E} ^ {L}, H _ {E} ^ {L}\right); \\ \tilde {s} _ {t} ^ {l} = \operatorname {a t t n} _ {B} \left(\bar {s} _ {t} ^ {l}, H _ {B}, H _ {B}\right); \tag {5} \\ s _ {t} ^ {l} = \operatorname {F F N} \left(\tilde {s} _ {t} ^ {l}\right). \\ \end{array}
+$$
+
+The BLEU score is 29.35 for this setting, not as good as our proposed method.
+
+# Part II: More results on IWSLT'14 En→De translation
+
+Since our BERT-fused model contains two stacked encoders, we carry out two groups of additional baselines:
+
+(1) Considering that stacking the BERT and encoder can be seen as a deeper model, we also train another two NMT models with deeper encoders, one with 18 layers (since  $\mathrm{BERT}_{\mathrm{base}}$  consists of 12 layers) and the other with 12 layers (which achieved best validation performance ranging from 6 to 18 layers).  
+(2) We also compare the results of our approach with ensemble methods. To get an  $M$ -model ensemble, we independently train  $M$  models with different random seeds  $(M \in \mathbb{Z}_{+})$ . We ensemble both standard Transformers and our BERT-fused models, which are denoted as  $M$ -model ensemble (standard) and  $M$ -model ensemble (BERT-fused) respectively. Please note that when we aggregate multiple BERT-fused models, we only need to store one replica of the BERT model because the BERT part is not optimized.
+
+Table 8: More ablation study on IWSLT'14 En→De.  
+
+<table><tr><td>Algorithm</td><td>BLEU</td></tr><tr><td>Standard Transformer</td><td>28.57</td></tr><tr><td>BERT-fused model</td><td>30.45</td></tr><tr><td>12-layer encoder</td><td>29.27</td></tr><tr><td>18-layer encoder</td><td>28.92</td></tr><tr><td>2-model ensemble (standard)</td><td>29.71</td></tr><tr><td>3-model ensemble (standard)</td><td>30.08</td></tr><tr><td>4-model ensemble (standard)</td><td>30.18</td></tr><tr><td>2-model ensemble (BERT-fused)</td><td>31.09</td></tr><tr><td>3-model ensemble (BERT-fused)</td><td>31.45</td></tr><tr><td>4-model ensemble (BERT-fused)</td><td>31.85</td></tr></table>
+
+The results are shown in Table 8. We have the following observations:
+
+1. Adding more layers can indeed boost the baseline, but still not as good as BERT-fused model. According to our experiments, when increasing the number of layers to 12, we achieve the best BLEU score, 29.27.  
+2. We also compare our results to ensemble methods. Indeed, ensemble significantly boosts the baseline by more than one point. However, even if using ensemble of four models, the BLEU score is still lower than our BERT-fused model (30.18 v.s. 30.45), which shows the effectiveness of our method.
+
+We want to point out that our method is intrinsically different from ensemble. Ensemble approaches usually refer to "independently" train several different models for the same task, and then aggregate
+
+the output of each model to get the eventually task. In BERT-fused model, although we include a pre-trained BERT into our model, there is still only one model serving for the translation task.
+
+In this sense, we can also combine our BERT-fused model with ensemble. Our approach benefits from ensemble too. When ensembling two models, we can achieve 31.09 BLEU score. When adding the number of models to four, we eventually achieve 31.85 BLEU score, which is 1.67 point improvement over the ensemble of standard Transformer.
+
+# Part III: More results on IWSLT'14 De→En translation
+
+We report the ensemble results on IWSLT'14 De  $\rightarrow$  En translation in Table 9. We can get similar conclusion compared to that of IWSLT'14 En  $\rightarrow$  De.
+
+Table 9: More ablation study on IWSLT'14 De→En.  
+
+<table><tr><td>Algorithm</td><td>BLEU</td></tr><tr><td>Standard Transformer</td><td>34.67</td></tr><tr><td>BERT-fused model</td><td>36.11</td></tr><tr><td>2-model ensemble (standard)</td><td>35.92</td></tr><tr><td>3-model ensemble (standard)</td><td>36.40</td></tr><tr><td>4-model ensemble (standard)</td><td>36.54</td></tr><tr><td>2-model ensemble (BERT-fused)</td><td>37.42</td></tr><tr><td>3-model ensemble (BERT-fused)</td><td>37.70</td></tr><tr><td>4-model ensemble (BERT-fused)</td><td>37.71</td></tr></table>
+
+# B.3 MORE RESULTS ON FEEDING BERT OUTPUT TO NMT MODULE
+
+The ablation study on more languages is shown in Table 10. Our method achieves the best results compared to all baselines.
+
+Table 10: BLEU scores of IWSLT translation tasks.  
+
+<table><tr><td>Algorithm</td><td>En→De</td><td>De→En</td><td>En→Es</td><td>En→Zh</td><td>En→Fr</td></tr><tr><td>Standard Transformer</td><td>28.57</td><td>34.64</td><td>39.0</td><td>26.3</td><td>35.9</td></tr><tr><td>Feed BERT feature into embedding</td><td>29.67</td><td>34.90</td><td>39.5</td><td>28.1</td><td>37.3</td></tr><tr><td>Feed BERT feature into all layers of encoder</td><td>29.61</td><td>34.84</td><td>39.9</td><td>28.1</td><td>37.4</td></tr><tr><td>Our BERT-fused model</td><td>30.45</td><td>36.11</td><td>41.4</td><td>28.2</td><td>38.7</td></tr></table>
+
+# B.4 MORE BASELINES OF IWSLT'14 GERMAN-TO-ENGLISH TRANSLATION
+
+We summarize the BLEU scores on IWSLT'14 De→En of existed works and our BERT-fused model approach in Table 11.
+
+Table 11: Previous results of IWSLT'14 De→En.  
+
+<table><tr><td>Approach</td><td>BLEU</td></tr><tr><td>Multi-agent dual learning (Wang et al., 2019)</td><td>35.56</td></tr><tr><td>Tied-Transformer (Xia et al., 2019)</td><td>35.52</td></tr><tr><td>Loss to teach (Wu et al., 2018)</td><td>34.80</td></tr><tr><td>Role-interactive layer (Weissenborn et al., 2019)</td><td>34.74</td></tr><tr><td>Variational attention (Deng et al., 2018)</td><td>33.68</td></tr><tr><td>Our BERT-fused model</td><td>36.11</td></tr></table>
+
+# B.5 COMPARISON WITH BACK TRANSLATION
+
+When using unlabeled data to boost machine learning systems, one of the most notable approaches is back translation (briefly, BT) (Sennrich et al., 2016b): We first train a reversed translation model, use the obtained model to translate the unlabeled data in the target domain back to source domain, obtain a synthetic dataset where the source data is back-translated and finally train the forward model on the augmented dataset.
+
+Our method has two main differences with BT method.
+
+1. In BT, the monolingual data from the target side is leveraged. In our proposed approach, we use a BERT of the source language, which indirectly leverages the monolingual data from the source side. In this way, our approach and BT are complementary to each other. In Section 5.4, we have already verified that our method can further improve the results of standard BT on Romanian-to-English translation.  
+2. To use BT, we have to train a reversed translation model and then back translate the monolingual data, which is time-cost due to the decoding process. In BERT-fused model, we only need to download a pre-trained BERT model, incorporate it into our model and continue training. Besides, the BERT module is fixed during training.
+
+On IWSLT'14, we also implement BT on wikipedia data, which is a subset of the corpus of training BERT. The model used for back translation are standard Transformer baselines introduced in Section 5, whose BLEU scores are 28.57 and 34.64 respectively. We back translate 1M, 2M, 5M, 15M and 25M randomly selected German sentences.
+
+The results are reported in Table 12. The rows started with  $\mathrm{BT}(\cdot)$  represent the results of BT, and the numbers in the brackets are the number of sentences for back translation.
+
+Table 12: BLEU scores IWSLT'14 En←De by BT.  
+
+<table><tr><td>Algorithm</td><td>En→De</td></tr><tr><td>Standard Transformer</td><td>28.57</td></tr><tr><td>BERT-fused model</td><td>30.45</td></tr><tr><td>BT (1M)</td><td>29.42</td></tr><tr><td>BT (2M)</td><td>29.76</td></tr><tr><td>BT (5M)</td><td>29.10</td></tr><tr><td>BT (15M)</td><td>28.26</td></tr><tr><td>BT (25M)</td><td>27.34</td></tr></table>
+
+IWSLT dataset is a collection of spoken language, and the bilingual training corpus is small  $(160k)$ . In Wikipedia, the sentences are relatively formal compared to the spoken language, which is out-of-domain of spoken languages. We can see that when using 1M or 2M monolingual data for BT, the BLEU scores can indeed improve from 28.57 to 29.42/29.76. However, simply adding more wikipedia data for BT does not result in more improvement. There is even a slight drop when adding more than 15M monolingual sentences. However, our BERT-fused model can achieve better performances than BT with wikipedia data.
+
+# C COMPARISON OF INFERENCE TIME
+
+Table 13: Comparisons on inference time (seconds),  ${}^{ + }$  ’ is the increased ratio of inference time.  
+
+<table><tr><td>Dataset</td><td>Transformer</td><td>Ours</td><td>(+)</td></tr><tr><td>IWSLT&#x27;14 En→De</td><td>70</td><td>97</td><td>38.6%</td></tr><tr><td>IWSLT&#x27;14 De→En</td><td>69</td><td>103</td><td>49.3%</td></tr><tr><td>WMT&#x27;14 En→De</td><td>67</td><td>99</td><td>47.8%</td></tr><tr><td>WMT&#x27;14 En→Fr</td><td>89</td><td>128</td><td>43.8%</td></tr></table>
+
+We compare the inference time of our approach to the baselines. The results are shown in Table 13, where from the second column to the last column, the numbers are the inference time of standard Transformer, BERT-fused model, and the increase of inference time.
+
+Indeed, introducing BERT to encode the input brings additional inference time, resulting in about  $40\%$  to  $49\%$  increase. But considering the significant improvement of BLEU score, it is acceptable of such extra cost. We will study how to reduce inference time in the future.
+
+# D DOWNLOAD LINK OF PRE-TRAINED BERT MODELS
+
+We leverage the pre-trained models provided by PyTorch-Transformers<sup>6</sup>.
+
+For IWSLT'14 tasks, we choose  $\mathrm{BERT}_{\mathrm{base}}$  model with 12 layers and hidden dimension 768.
+
+1. IWSLT14  $\mathrm{En}\rightarrow \{\mathrm{De},\mathrm{Es},\mathrm{Fr},\mathrm{Zh}\}$  , we choose bert-base-uncased.  
+2. IWSLT14 De→En, we choose bert-base-german-cased.
+
+For WMT14  $\mathrm{En} \rightarrow \{\mathrm{Fr}, \mathrm{De}\}$ , we choose bert-large-uncased, which is a  $\mathrm{BERT}_{\mathrm{large}}$  model with 24 layers and hidden dimension 1024.
+
+For WMT16 Ro→En, we choose bert-base-multilingual-cased, because there is no BERT specially trained for the Romanian.
+
+For unsupervised  $\mathrm{En} \leftrightarrow \mathrm{Fr}$  and unsupervised  $\mathrm{En} \leftrightarrow \mathrm{Ro}$ , we choose xlm-mlm-enfr1024 and xlm-mlm-enro1024 respectively.
+
+The download links are summarized as follows:
+
+- bert-base-uncased: https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-uncased.tar.gz.  
+- bert-large-uncased: https://s3.amazon.com/models.huggingface.co/bert/bert-large-uncased.tar.gz.  
+- bert-base-multilingual-cased: https://s3.amazon.com/models.huggingface.co/bert/bert-base-multilingual-cased.tar.gz.  
+- bert-base-german-cased: https://int-deepset-models-bert.s3.eu-central-1.amazon.com/pytorch/bert-base-german-cased.tar.gz.  
+- xlm-mlx-enfr1024: https://s3.amazon.com/models.huggingface.co/bert/xlm-mlx-enfr-1024-pytorch_model.bin.  
+- xlm-mlx-enro1024: https://s3.amazon.com/models.huggingface.co/bert/xlm-mlx-enro-1024-pytorch_model.bin.
+
+# E DETAILS OF THE NOTATIONS
+
+Let  $\operatorname{att}(q, K, V)$  denote the attention layer, where  $q$ ,  $K$  and  $V$  indicate query, key and value respectively. Here  $q$  is a  $d_q$ -dimensional vector ( $d \in \mathbb{Z}$ ),  $K$  and  $V$  are two sets with  $|K| = |V|$ . Each  $k_i \in K$  and  $v_i \in V$  are also  $d_k / d_v$ -dimensional ( $d_q$ ,  $d_k$  and  $d_v$  can be different) vectors,  $i \in [|K|]$ . The attention model works as follows:
+
+$$
+\operatorname {a t t n} (q, K, V) = \sum_ {i = 1} ^ {| V |} \alpha_ {i} W _ {v} v _ {i}, \alpha_ {i} = \frac {\exp \left(\left(W _ {q} q\right) ^ {T} \left(W _ {k} k _ {i}\right)\right)}{Z}, Z = \sum_ {i = 1} ^ {| K |} \exp \left(\left(W _ {q} q\right) ^ {T} \left(W _ {k} k _ {i}\right)\right), \tag {6}
+$$
+
+where  $W_{q}$ ,  $W_{k}$  and  $W_{v}$  are the parameters to be learned. In Vaswani et al. (2017), attn is implemented as a multi-head attention model and we omit the details here to increase readability. Following Vaswani et al. (2017), we define the non-linear transformation layer as
+
+$$
+\operatorname {F F N} (x) = W _ {2} \max  \left(W _ {1} x + b _ {1}, 0\right) + b _ {2}, \tag {7}
+$$
+
+where  $x$  is the input;  $W_{1}, W_{2}, b_{1}, b_{2}$  are the parameters to be learned; max is an element-wise operator. Layer normalization is also applied following Transformer (Vaswani et al., 2017).

2002.06xxx/2002.06823/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18fb30201a0962798077f210d205e02e95c6b88cd6bfb94d60205491d5328b93
+size 578703

2002.06xxx/2002.06838/b5f48312-e0e5-4d14-b736-57b539ada670_content_list.json

@@ -0,0 +1,1590 @@
+[
+    {
+        "type": "text",
+        "text": "Stratified Rule-Aware Network for Abstract Visual Reasoning",
+        "text_level": 1,
+        "bbox": [
+            186,
+            119,
+            810,
+            142
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sheng Hu, $^{1,*}$  Yuqing Ma, $^{1,*}$  Xianglong Liu, $^{1,2,\\dagger}$  Yanlu Wei, $^{1}$  Shihao Bai $^{1}$",
+        "bbox": [
+            197,
+            171,
+            795,
+            190
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "$^{1}$  State Key Laboratory of Software Development Environment, Beihang University, Beijing, China  \n $^{2}$  Beijing Advanced Innovation Center for Big Data-Based Precision Medicine, Beihang University, Beijing, China  \nhusheng_7@163.com, {mayuqing,xliiu} @nlsde.buaa.edu.cn, {weiyanlu,16061167} @buaa.edu.cn",
+        "bbox": [
+            122,
+            191,
+            875,
+            234
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract",
+        "text_level": 1,
+        "bbox": [
+            248,
+            273,
+            313,
+            286
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract reasoning refers to the ability to analyze information, discover rules at an intangible level, and solve problems in innovative ways. Raven's Progressive Matrices (RPM) test is typically used to examine the capability of abstract reasoning. The subject is asked to identify the correct choice from the answer set to fill the missing panel at the bottom right of RPM (e.g., a  $3 \\times 3$  matrix), following the underlying rules inside the matrix. Recent studies, taking advantage of Convolutional Neural Networks (CNNs), have achieved encouraging progress to accomplish the RPM test. However, they partly ignore necessary inductive biases of RPM solver, such as order sensitivity within each row/column and incremental rule induction. To address this problem, in this paper we propose a Stratified Rule-Aware Network (SRAN) to generate the rule embeddings for two input sequences. Our SRAN learns multiple granularity rule embeddings at different levels, and incrementally integrates the stratified embedding flows through a gated fusion module. With the help of embeddings, a rule similarity metric is applied to guarantee that SRAN can not only be trained using a tuplet loss but also infer the best answer efficiently. We further point out the severe defects existing in the popular RAVEN dataset for RPM test, which prevent from the fair evaluation of the abstract reasoning ability. To fix the defects, we propose an answer set generation algorithm called Attribute Bisection Tree (ABT), forming an improved dataset named Impartial-RAVEN (I-RAVEN for short). Extensive experiments are conducted on both PGM and I-RAVEN datasets, showing that our SRAN outperforms the state-of-the-art models by a considerable margin.",
+        "bbox": [
+            98,
+            296,
+            464,
+            662
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Introduction",
+        "text_level": 1,
+        "bbox": [
+            225,
+            681,
+            336,
+            698
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract reasoning, also known as inductive reasoning, refers to the ability to analyze information, discover rules at an intangible level, and solve problems in innovative ways. This type of reasoning, as the foundation for human intelligence, helps human understand the world. It has been generally regarded and pursued as a critical component to the development of artificial intelligence during the past decades, and has attracted increasing attention in recent years. Raven's Progressive Matrices (RPM) test (Raven",
+        "bbox": [
+            81,
+            702,
+            478,
+            828
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/ae408d6ef1f8c8019f9d5be524ddfcb43caacd4d75ea7c4619761711e6f2e526.jpg",
+        "image_caption": [
+            "Figure 1: An example of RPM question and the human strategy to solve it. The underlying rule on the number of circles could be Progression (2-1=3-2) or Arithmetic (1+2=3) along row 1, and Arithmetic (2+3=5) along row 2. Therefore the dominant rule is Arithmetic. Apply it to the third row to figure out the answer  $(2+2=4)$ . Besides, no viable rule can be found along the columns"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            517,
+            271,
+            913,
+            460
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1938; Carpenter, Just, and Shell 1990; Raven 2000; Kunda, McGregor, and Goel 2013; Strannegård, Cirillo, and Ström 2013) is one of the highly accepted and well-studied tools to examine the ability of abstract reasoning, which is believed as a good estimate of the real intelligence (Carpenter, Just, and Shell 1990). An illustration of RPM is shown in Figure 1, where usually the test-taker is presented with a  $3 \\times 3$  matrix with the bottom right panel left blank. The goal is to choose one image from an answer set of eight candidates to complete the matrix correctly, namely satisfying the underlying rules in the matrix. Subjects accomplish this by looking into the first two rows/columns and inducing the dominant rules which govern the attributes in those panels. The obtained rules can then be applied to the last row/column to figure out which answer belongs to the blank panel.",
+        "bbox": [
+            514,
+            595,
+            911,
+            804
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Computational models for RPM in the cognitive science community access symbolic representations of the images (Carpenter, Just, and Shell 1990; Lovett and Forbus 2017; Lovett, Forbus, and Usher 2010; Lovett et al. 2010). Recently there has been some success with end-to-end learning methods trying to accomplish abstract reasoning on",
+        "bbox": [
+            514,
+            805,
+            913,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_footnote",
+        "text": "*Equal contribution  \n†Corresponding author  \nCopyright © 2021, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.",
+        "bbox": [
+            80,
+            837,
+            478,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "aside_text",
+        "text": "arXiv:2002.06838v3 [cs.CV] 7 Jun 2022",
+        "bbox": [
+            22,
+            272,
+            58,
+            700
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "RPM test (Hoshen and Werman 2017; Barrett et al. 2018; Steenbrugge et al. 2018; Zhang et al. 2019a,b; Zheng, Zha, and Wei 2019; van Steenkiste et al. 2019; Wang, Jamnik, and Lio 2020), inspired by the progress of computer vision tasks (Krizhevsky, Sutskever, and Hinton 2012; Simonyan and Zisserman 2015; Szegedy et al. 2015; He et al. 2016) and boosted by the large-scale PGM (Barrett et al. 2018) and RAVEN (Zhang et al. 2019a) datasets. Typical works including CoPINet (Zhang et al. 2019a), LEN (Zheng, Zha, and Wei 2019), and MXGNet (Wang, Jamnik, and Lio 2020) followed the paradigm that predicts a classification score for each multiple-choice panel based on the relations inside each row/column, showing great potential to solve RPM test. However, these models partly ignore the important characteristics for RPM, such as the permutation invariance (Zhang et al. 2019b), the order sensitivity of panels inside a row/column, etc. Previous work (Wang, Jamnik, and Lio 2020) specially mentions that they do not choose a permutation-invariant structure because it leads to severe 'overfitting' on the RAVEN dataset. We will discuss this phenomenon in later sections. What is even worse, directly extracting the relations, without considering the incremental rule induction mechanism widely adopted in human cognitive systems (Carpenter, Just, and Shell 1990), inevitably leads to inferior performance.",
+        "bbox": [
+            86,
+            68,
+            477,
+            414
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To achieve reliable and efficient abstract reasoning, in this paper we develop a powerful architecture called Stratified Rule-Aware Network (SRAN) that naturally integrates the indispensable inductive biases, including order sensitivity, permutation invariance, and incremental rule induction. SRAN takes two rows/columns as input and learns stratified rule embeddings at different levels, namely cell-wise, individual-wise, and ecological hierarchy. These multiple granularity embeddings are incrementally integrated via a gate fusion module, which naturally preserves the order sensitivity of panels and maps the inputs to a rule embedding space. With the help of the embeddings, we further introduce a rule similarity metric, based on which SRAN can not only be well trained using a tuplet loss but also infer the best answer efficiently. This framework resembles the human strategy for RPM shown in Figure 1.",
+        "bbox": [
+            86,
+            415,
+            477,
+            637
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To fairly evaluate the abstract reasoning ability, we also design a general algorithm named Attribute Bisection Tree (ABT) to generate an impartial answer set for any attribute-based RPM question. We point out and further fix the underlying defects of the commonly-used RAVEN (Zhang et al. 2019a) dataset, where the correct answer could be inferred even without the presence of the context matrix. Therefore, we introduce an improved dataset named Impartial-RAVEN (I-RAVEN) to fairly evaluate the abstract reasoning capability of RPM solvers.",
+        "bbox": [
+            86,
+            638,
+            477,
+            776
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To the best of our knowledge, the proposed SRAN is the first RPM solver to induce rule embeddings which are discriminative and measurable. We are also the first to point out and fix the defects of the misleading benchmark RAVEN, and generate an impartial dataset I-RAVEN based on our ABT algorithm. Extensive experiments conducted on widely used dataset PGM and our improved I-RAVEN show that SRAN outperforms state-of-the-art methods by a consider-",
+        "bbox": [
+            86,
+            777,
+            477,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "able margin, e.g.  $60.8\\%$  accuracy compared to the second best  $46.1\\%$  on I-RAVEN.",
+        "bbox": [
+            519,
+            69,
+            911,
+            95
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our Approach",
+        "text_level": 1,
+        "bbox": [
+            653,
+            109,
+            776,
+            126
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first give a formal definition of the abstract reasoning task on the RPM test. Then we introduce the inductive-biased framework, and present our Stratified Rule-Aware Network (SRAN). Finally, we demonstrate the learning and inference process of the proposed model.",
+        "bbox": [
+            519,
+            128,
+            911,
+            198
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Preliminary",
+        "text_level": 1,
+        "bbox": [
+            519,
+            210,
+            612,
+            226
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For a common RPM question, usually a  $3 \\times 3$  matrix  $\\mathbf{M}^{-}$  is given, with bottom right context panel left blank.  $\\Omega$  denotes the answer set with  $N$  multiple-choice panels, where typically  $N = 8$ . The dominant rules governing the features inside the matrix could be induced from the first two intact rows/columns. The goal is to select a multiple-choice panel  $\\omega \\in \\Omega$  to complete the context matrix  $\\mathbf{M}^{-}$ , maintaining the dominant rule inside of the context matrix.",
+        "bbox": [
+            519,
+            227,
+            911,
+            338
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We define the completed matrix with a multiple-choice panel  $\\omega$  filled as  $\\mathbf{M}$ , where  $\\mathbf{M}_i$  is denoted as the  $i$ -th row, and  $\\mathbf{m}_{ij}$  indicates the panel in  $i$ -th row and  $j$ -th column. Intuitively,  $\\mathbf{M}$  is almost the same as  $\\mathbf{M}^{-}$ , except for  $\\mathbf{m}_{33} = \\omega$  while the corresponding element missing in  $\\mathbf{M}^{-}$ . In fact, whether rules exist in rows or columns is uncertain. Therefore, our framework induces both the row-wise rule representation and the column-wise representation in the same way. In order to simplify the notation, we only take the induction of the row-wise rule representation as example.",
+        "bbox": [
+            519,
+            339,
+            911,
+            478
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The Reasoning Framework",
+        "text_level": 1,
+        "bbox": [
+            519,
+            489,
+            728,
+            503
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Based on the necessary inductive biases for RPM, we develop a novel abstract reasoning architecture named Stratified Rule-Aware Network (SRAN). Given two input rows  $\\mathbf{M}_i,\\mathbf{M}_j$ , the proposed framework embeds the input into multiple granularity embeddings using a stratified rule embedding module  $\\mathbb{E}$ . Named after biological organizations (Parent 1996),  $\\mathbb{E}$  consists of three hierarchies including cell-wise network  $\\mathbb{E}_{\\mathrm{cell}}$ , individual-wise network  $\\mathbb{E}_{\\mathrm{ind}}$ , and ecological network  $\\mathbb{E}_{\\mathrm{eco}}$ . With the multiple granularity rule embeddings, the gated embedding fusion module  $\\mathbb{G}$  will incrementally integrate these stratified embedding flows and map the two input sequences  $\\mathbf{M}_i$  and  $\\mathbf{M}_j$  to a discriminative rule embedding  $\\mathbf{r}_{ij}^{(3)}$ , while maintaining the order sensitivity and permutation invariance. We further introduce a rule similarity metric  $\\mathcal{D}$  to estimate the similarity between the rule representations. The correct answer can be predicted by choosing the multiple-choice panel within the shortest distance to the dominant rule generated by the first two rows in the matrix.",
+        "bbox": [
+            519,
+            507,
+            911,
+            773
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Stratified Rule Embedding",
+        "text_level": 1,
+        "bbox": [
+            519,
+            787,
+            725,
+            801
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As we all know, organization of behaviour into a nested hierarchy of tasks is characteristic of purposive cognition in humans. The prevalent Convolution Neural Network inspired by the human visual system, is a stratified model itself, with the projection from each layer showing the hierarchical nature of features. The bottom layers extract low-level features,",
+        "bbox": [
+            519,
+            805,
+            911,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "such as texture, edge, etc, while the top layers abstract high-level semantic information from the low-level information transmitted from the bottom layers.",
+        "bbox": [
+            81,
+            68,
+            478,
+            109
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, without specifying information from different levels, it is hard for CNN to figure out different hierarchies, and thus fail to obtain robust and discriminative representations. Therefore, it would be better to feed the input of different hierarchies explicitly and extract rule representations from different granularity with artificial guidance. Motivated by that, we deploy a stratified rule embedding module, consisting of cell-wise hierarchy, individual-wise hierarchy, and ecological hierarchy.",
+        "bbox": [
+            81,
+            109,
+            478,
+            236
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Cell-wise Hierarchy The network of the cell-wise hierarchy  $\\mathbb{E}_{\\mathrm{cell}}$  takes each panel as input and recognize the attributes of inside graphical elements. It handles each panel independently without considering the difference or correlations among panels inside the matrix. Therefore, it observes the information from the most detailed perspective. We obtain the cell-wise rule representation for each input panel:",
+        "bbox": [
+            81,
+            241,
+            480,
+            339
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {x} _ {i j} = \\mathbb {E} _ {\\text {c e l l}} (\\mathbf {m} _ {i j}). \\tag {1}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            218,
+            345,
+            478,
+            362
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Individual-wise Hierarchy Moreover, the network of individual hierarchy takes each row as input. It begins to take the correlations among panels of the same row into consideration, and encode the entire row with a compact embedding, rather than simply combining each panel. In this way, the rule embedding process for each panel is coupled and interacts with each other. Intuitively, each row may contain multiple plausible rules. In this hierarchy, the framework extracts intermediate rule embedding for each row individually, which still ignores the comprehensive information from the matrix perspective, especially the correlations across rows. The individual-wise rule embedding  $\\mathbf{y}_i$  is denoted as:",
+        "bbox": [
+            81,
+            366,
+            480,
+            545
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {y} _ {i} = \\mathbb {E} _ {\\text {i n d}} \\left(\\mathbf {M} _ {i}\\right). \\tag {2}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            225,
+            546,
+            478,
+            561
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Ecological Hierarchy Furthermore, the network of the ecological hierarchy takes the two rows together as input and jointly learns the rule patterns underlying the two rows. As we mentioned before, in the individual hierarchy, the framework extracts intermediate rule embedding for each row, without considering the interaction between two rows. The rule that exists in one row may not lie in another. Therefore, to obtain the shared rule patterns between the two rows, it is essential to put these two rows together and jointly learn the features from an ecological level. Thus the shared rule embedding is obtained as follows:",
+        "bbox": [
+            81,
+            566,
+            480,
+            720
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {z} _ {i j} = \\mathbb {E} _ {\\mathrm {e c o}} ([ \\mathbf {M} _ {i}, \\mathbf {M} _ {j} ]), \\tag {3}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            726,
+            478,
+            743
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where  $[\\cdot ,\\cdot ]$  denotes the concatenating operation.",
+        "bbox": [
+            83,
+            747,
+            398,
+            763
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Gated Embedding Fusion",
+        "text_level": 1,
+        "bbox": [
+            83,
+            772,
+            284,
+            787
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since the rule embeddings at different levels focus on different attributes or patterns, to generate one discriminative representation for the rule, we should aggregate the multiple granularity embeddings. Due to the requirement that the aggregation should preserve the order of cell-wise rule embeddings and be permutation-invariant to the individual-wise ones, we propose a stratified rule embedding learning",
+        "bbox": [
+            81,
+            790,
+            480,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/358d2cf7a476f3699d453f0e12c56f09476f3faec58c0bf8e04017f8c67dd619.jpg",
+        "image_caption": [
+            "Figure 2: The architecture of SRAN, consisting of a hierarchical rule embedding module and a gated embedding fusion module. Given two row sequences as input, it outputs the rule embedding"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            524,
+            69,
+            893,
+            224
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "method named gated embedding fusion module, which is responsible for gradually aggregating the multiple granularity embeddings.",
+        "bbox": [
+            514,
+            320,
+            911,
+            362
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we define a gate function  $\\varphi$  to fuse the rule embeddings from different hierarchies. It concatenates all the inputs and encodes into a single embedding using fully connected layers. The gate function is similar to the attention mechanism, which detects and concentrates on the useful features according to the task. Even for the same attribute, they may focus on different facets. Based on the gate function, our gated embedding fusion module could regulate the flow of rule embeddings into the framework and make the utmost of their complementary information.",
+        "bbox": [
+            514,
+            363,
+            913,
+            501
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "At the cell level, after obtaining cell-wise rule embeddings for panels in  $i$ -th row  $\\mathbf{M}_i$ , the module aggregates them to infer a row-wise rule embedding  $\\mathbf{r}_i^{(1)}$ :",
+        "bbox": [
+            514,
+            501,
+            911,
+            547
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {r} _ {i} ^ {(1)} = \\varphi_ {1} \\left(\\mathbf {x} _ {i 1}, \\mathbf {x} _ {i 2}, \\mathbf {x} _ {i 3}\\right), \\tag {4}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            630,
+            556,
+            911,
+            575
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Similarly, we obtain  $\\mathbf{r}_j^{(1)}$  for the  $j$ -th row  $\\mathbf{M}_j$ . The fused embedding integrates different types of attributes in the panels.",
+        "bbox": [
+            514,
+            585,
+            911,
+            614
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "At the individual level, intuitively both  $\\mathbf{r}_i^{(1)}$  and  $\\mathbf{y}_i$  are the row-wise embeddings corresponding to the  $i$ -th row, but convey the different granularity rule information. We further fuse them, and jointly mine the shared rules contained in the  $i$ -th and  $j$ -th row:",
+        "bbox": [
+            514,
+            617,
+            913,
+            688
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {r} _ {i j} ^ {(2)} = \\varphi_ {2} \\left(\\mathbf {r} _ {i} ^ {(1)}, \\mathbf {y} _ {i}, \\mathbf {r} _ {j} ^ {(1)}, \\mathbf {y} _ {j}\\right). \\tag {5}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            617,
+            696,
+            911,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "At the ecological level, similarly we can further combine fused embedding  $\\mathbf{r}_{ij}^{(2)}$  and  $\\mathbf{z}_{ij}$  using the gate fusion function, abstracting the final rule embedding:",
+        "bbox": [
+            514,
+            723,
+            913,
+            768
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {r} _ {i j} ^ {(3)} = \\varphi_ {3} \\left(\\mathbf {r} _ {i j} ^ {(2)}, \\mathbf {z} _ {i j}\\right). \\tag {6}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            643,
+            776,
+            911,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To make sure the framework is permutation-invariant to the input rows, we exchange the concatenation order of the two input rows and average the output rule embeddings. This invariance ensures that, the rule embedding respects the characteristic of RPM and thus distills the representative information of the relations existing in the inputs.",
+        "bbox": [
+            514,
+            805,
+            913,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "On the whole, the SRAN can be formulated in its simplest form as follows:",
+        "bbox": [
+            83,
+            68,
+            478,
+            95
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\begin{array}{l} \\mathbf {r} _ {i j} ^ {(3)} = \\operatorname {S R A N} \\left(\\mathbf {M} _ {i}, \\mathbf {M} _ {j}\\right) \\tag {7} \\\\ = \\mathbb {G} \\left(\\mathbf {x} _ {i}, \\mathbf {x} _ {j}, \\mathbf {y} _ {i}, \\mathbf {y} _ {j}, \\mathbf {z} _ {i j}\\right), \\\\ \\end{array}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            184,
+            95,
+            478,
+            136
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where  $\\mathbf{r}_{ij}^{(3)}$  is the shared rule embedding of the  $\\mathbf{M}_i$  and  $\\mathbf{M}_j$ . An illustration of SRAN is shown in Figure 2.",
+        "bbox": [
+            83,
+            138,
+            477,
+            170
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Learning and Inference",
+        "text_level": 1,
+        "bbox": [
+            83,
+            179,
+            269,
+            195
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With SRAN framework, the question turns to how we train the network, and apply it to infer the correct answer to RPM test. The key to address the question lies in the similarity measure between two rule embeddings, based on which we can define the loss function for SRAN training, and meanwhile determine the best choice during inference.",
+        "bbox": [
+            81,
+            196,
+            478,
+            281
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Similarity function We introduce similarity function  $\\mathcal{D}$  to measure the closeness between two rules in the embedding space. In this paper, we adopt inner product similarity for good experimental results:",
+        "bbox": [
+            81,
+            285,
+            478,
+            340
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathcal {D} \\left(\\mathbf {r}, \\mathbf {r} ^ {\\prime}\\right) = \\mathbf {r} ^ {\\mathrm {T}} \\mathbf {r} ^ {\\prime}. \\tag {8}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            342,
+            478,
+            359
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Training For a given RPM question, the first two rows  $\\mathbf{M}_1, \\mathbf{M}_2$  are fed into our proposed SRAN and produce the shared rule embedding  $\\mathbf{g}$ :",
+        "bbox": [
+            83,
+            361,
+            478,
+            402
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {g} = \\mathbf {r} _ {1 2} ^ {(3)} = \\operatorname {S R A N} \\left(\\mathbf {M} _ {1}, \\mathbf {M} _ {2}\\right), \\tag {9}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            406,
+            478,
+            424
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which represents the dominant pattern of the matrix.",
+        "bbox": [
+            83,
+            425,
+            429,
+            439
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, the rule extracted from the first two rows can be treated as the reference rule, and we name it the dominant rule in the matrix. Subsequently, the correct answer can be found by checking whether its corresponding rule embedding is similar to the dominant rule. Specifically, given a multiple-choice panel  $\\omega_{k}\\in \\Omega$ , where  $k\\in \\{1,\\dots,N\\}$ , we denote  $\\overline{\\mathbf{r}}_k$  as the new rule embedding inside  $\\mathbf{M}$  caused by the  $k$ -th multiple-choice panel:",
+        "bbox": [
+            81,
+            439,
+            478,
+            550
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\bar {\\mathbf {r}} _ {k} = \\frac {1}{2} \\left(\\mathbf {r} _ {1 3} ^ {(3)} + \\mathbf {r} _ {2 3} ^ {(3)}\\right). \\tag {10}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            551,
+            478,
+            580
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This procedure is illustrated in Figure 3. In practice, we generate the column-wise rule representation just as the row-wise one, and concatenate the two representations together as the final representation.",
+        "bbox": [
+            81,
+            580,
+            478,
+            636
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For the rule embedding  $\\overline{\\mathbf{r}}^*$  generated by rows/columns filled with correct answer, the desirable SRAN should enforce it to be more similar to the dominant rule  $\\mathbf{g}$ , compared to the other rules  $\\overline{\\mathbf{r}}_k$  corresponding to the wrong answers, where  $\\overline{\\mathbf{r}}_k \\neq \\overline{\\mathbf{r}}^*$ . Subsequently, the generated rules of  $N$  candidates, alongside with the dominant rule, form a tuple containing  $N + 1$  elements. Based on the similarity function, the  $(N + 1)$ -tuple loss (Sohn 2016) can be defined for SRAN training:",
+        "bbox": [
+            81,
+            637,
+            480,
+            762
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathcal {L} = \\log \\left(1 + \\sum_ {k = 1, \\overline {{\\mathbf {r}}} _ {k} \\neq \\overline {{\\mathbf {r}}} ^ {*}} ^ {N} \\exp \\left(\\mathcal {D} \\left(\\mathbf {g}, \\overline {{\\mathbf {r}}} _ {k}\\right) - \\mathcal {D} \\left(\\mathbf {g}, \\overline {{\\mathbf {r}}} ^ {*}\\right)\\right)\\right), \\tag {11}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            94,
+            773,
+            478,
+            816
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which means the SRAN can be trained in a fully end-to-end manner. The architecture of the SRAN (Figure 2) is well matched to the problem of abstract reasoning, because it leverages human strategies and explicitly generates the rules governing the matrix.",
+        "bbox": [
+            81,
+            818,
+            480,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/51f667bc379d0bf01a71ae92dd30950171448c3f72f94ce2eecaf80a0451403e.jpg",
+        "image_caption": [
+            "Figure 3: The similarity score for a candidate answer. A multiple-choice panel from the answer set is inflated in the blank panel (row 3), generating a rule embedding  $\\overline{\\mathbf{r}}_k$  through SRAN. The similarity score for the candidate answer can be estimated based on  $\\overline{\\mathbf{r}}_k$  and the dominant rule embedding  $\\mathbf{g}$  extracted from row 1 and 2"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            524,
+            71,
+            906,
+            169
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Inference Once the training of SRAN is finished, we could make the inference of the newly given RPM question. Initially, the intact rows/columns of the RPM are fed into the framework to get the dominant rule  $\\mathbf{g}$ . After that, each multiple-choice panel is filled to the blank position to complete the matrix, and the framework will generate the rule embeddings  $\\overline{\\mathbf{r}}_k$  for all candidate answers, given the current completed matrix. We can accomplish the abstract reasoning by choosing the correct multiple-choice as follows:",
+        "bbox": [
+            514,
+            297,
+            911,
+            422
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nk ^ {*} = \\underset {k} {\\arg \\max } \\mathcal {D} (\\mathbf {g}, \\overline {{\\mathbf {r}}} _ {k}). \\tag {12}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            630,
+            430,
+            911,
+            454
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that since we investigate each panel independently, the above inference process promises that our model's output stays invariant if the answer set is shuffled.",
+        "bbox": [
+            514,
+            460,
+            913,
+            503
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Attribute Bisection Tree for Impartial Dataset",
+        "text_level": 1,
+        "bbox": [
+            519,
+            518,
+            908,
+            535
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "RAVEN (Zhang et al. 2019a) is a popular RPM-style dataset adopted by all recent studies (Zhang et al. 2019b; Zheng, Zha, and Wei 2019; Wang, Jamnik, and Lio 2020). However, we find severe defects in its answer sets, making RAVEN incompetence as a measurement of abstract reasoning. In this section, we first give a brief review of RAVEN, and then explain the defects with analysis and experiments. Finally we introduce a general algorithm to generate an impartial answer set for any attribute-based RPM question. Thus we fix the defects of RAVEN and propose an improved dataset.",
+        "bbox": [
+            514,
+            537,
+            913,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Defects of RAVEN",
+        "text_level": 1,
+        "bbox": [
+            516,
+            688,
+            663,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "RAVEN dataset consists of 70,000 RPM questions distributed in 7 different figure configurations. Panels are constructed with 5 attributes (Number, Position, Type, Size, Color). Each attribute is governed by one of 4 rules and takes a value from a predefined set. Rules are applied only row-wise in RAVEN.",
+        "bbox": [
+            514,
+            707,
+            911,
+            790
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After carefully examining the data in RAVEN, we find unexpected pattern among the eight multiple-choice panels. Each distractor in the answer set is generated by randomly modifying one attribute of the correct answer (see Figure 4(a)). As a consequence, the panel with the most common values for each attribute will be the correct answer. This means the correct answer can be found by simply scanning",
+        "bbox": [
+            514,
+            791,
+            913,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/e1e302cb5394cea707cf87afa2c29a036f13bea8fdbf4630e1fd6e1e291d8740.jpg",
+        "image_caption": [
+            "Figure 4: Comparison between RAVEN and I-RAVEN"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            86,
+            66,
+            472,
+            217
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/6bdd9b1b076d7f7893dc3808e82e8af5ed2443b50ba125ef10d1e82e17609cac.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>RAVEN</td><td>I-RAVEN</td></tr><tr><td>ResNet (Zhang et al. 2019a)</td><td>53.4</td><td>40.3</td></tr><tr><td>CoPINet (Zhang et al. 2019b)</td><td>91.4</td><td>46.1</td></tr><tr><td>Context-blind ResNet</td><td>71.9</td><td>12.2</td></tr><tr><td>Context-blind CoPINet</td><td>94.2</td><td>14.2</td></tr></table>",
+        "bbox": [
+            89,
+            268,
+            473,
+            345
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Test on RAVEN and I-RAVEN",
+        "bbox": [
+            148,
+            353,
+            413,
+            367
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "the answer set without considering the context images. An example is also shown on the right of Figure 4(a). Among the answer set, the most common Color and Type are black (1, 3, 4, 5, and 7) and pentagon (1, 2, 3, 4, 6, and 8). Besides, multiple-choice panel 1, 2, 5, 6, 7, and 8 are in the same Size. Therefore, multiple-choice panel 1, which is the panel with the most common attribute values, is inferred as (and indeed is) the correct answer, even without considering the context matrix.",
+        "bbox": [
+            81,
+            406,
+            478,
+            532
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that understanding of the context matrix is the cornerstone of RPM test. The RAVEN dataset, where the correct answer can be found without the context, is obviously against the essence of abstract reasoning, and thus is incapable of evaluating abstract reasoning ability.",
+        "bbox": [
+            81,
+            536,
+            478,
+            607
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "More severely, such underlying patterns can also be captured by neural networks, especially for models which combine features of eight multiple-choice panels. We train two models with context-blind (Barrett et al. 2018) setting, including a simple ResNet-based classifier (Zhang et al. 2019a) and the competitive CoPINet (Zhang et al. 2019b). These context-blind models are trained with only eight multiple-choice panels as input, and should have predicted the answer randomly, if the dataset is logical. However, as shown in Table 1, the context-blind models can achieve even better performance to the normal models, which proves that RAVEN contains illogical patterns where the correct answer can be found when only presented with the answer set. This type of back-door solutions is quite hidden and has also been discussed in other relational reasoning benchmarks, such as Visual Question Answering (VQA) (Johnson et al. 2017) and symbolic analogy (Hill et al. 2019). We can conclude that the 'overfitting' phenomenon on RAVEN reported by (Wang, Jamnik, and Lio 2020) is not caused by a permutation-invariant structure but by the dataset itself.",
+        "bbox": [
+            81,
+            611,
+            480,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Attribute Bisection Tree",
+        "text_level": 1,
+        "bbox": [
+            517,
+            68,
+            769,
+            82
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Input: the correct answer  $\\omega^{*}$",
+        "text_level": 1,
+        "bbox": [
+            517,
+            87,
+            715,
+            101
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize the answer set  $\\Omega = \\{\\omega^{*}\\}$",
+        "bbox": [
+            527,
+            101,
+            774,
+            116
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2: Sample 3 attributes  $a_1, a_2, a_3$  according to  $\\omega^*$",
+        "bbox": [
+            527,
+            116,
+            846,
+            128
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3: Sample new value  $v_{i}$  for each  $a_{i}$",
+        "bbox": [
+            527,
+            130,
+            759,
+            143
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4: for  $i = 1$  to 3 do",
+        "bbox": [
+            527,
+            143,
+            660,
+            156
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5: Initialize  $\\Gamma = \\{\\}$",
+        "bbox": [
+            527,
+            156,
+            674,
+            171
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "6: for each  $w_{k}$  in the current answer set  $\\Omega$  do",
+        "bbox": [
+            527,
+            171,
+            844,
+            184
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "7:  $\\gamma \\gets$  modifying attribute  $a_{i}$  of  $\\omega_{k}$  with  $v_{i}$",
+        "bbox": [
+            527,
+            185,
+            849,
+            198
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "8:  $\\Gamma \\leftarrow \\Gamma \\bigcup \\{\\gamma \\}$",
+        "bbox": [
+            527,
+            199,
+            668,
+            213
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "9: end for",
+        "bbox": [
+            519,
+            213,
+            616,
+            224
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "10:  $\\Omega \\gets \\Omega \\bigcup \\Gamma$",
+        "bbox": [
+            519,
+            224,
+            643,
+            241
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "11: end for",
+        "bbox": [
+            519,
+            241,
+            599,
+            252
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Output: the answer set  $\\Omega (|\\Omega | = 2^3 = 8)$",
+        "bbox": [
+            519,
+            253,
+            795,
+            268
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Attribute Bisection Tree",
+        "text_level": 1,
+        "bbox": [
+            517,
+            299,
+            705,
+            313
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We design a general algorithm named Attribute Bisection Tree (ABT) to generate an impartial answer set for any attribute-based RPM question. The ABT ensures attribute modifications among the answer set are well balanced. Thus, no clue can be found to guess the correct answer only depending on the answer set, and no distractor can be eliminated without reasoning from the context matrix as well.",
+        "bbox": [
+            514,
+            316,
+            911,
+            415
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 4(b) demonstrates the generation process using a tree structure. Each node indicates a multiple-choice panel, and the root of the tree structure is the correct answer. Different levels indicate different iterations, where nodes of this level are the candidate answers of current answer set. The generation process flows in a top-down manner. For each iteration, only one attribute will be modified. At each level, a node has two children nodes, where one node remains the same with the father node, the other changes the value of the attribute sampled for this iteration of the father node. Finally, at the bottom level, we could obtain the whole answer set. Algorithm 1 summarizes the key steps of the answer generation process.",
+        "bbox": [
+            514,
+            415,
+            913,
+            595
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "I-RAVEN",
+        "text_level": 1,
+        "bbox": [
+            517,
+            606,
+            596,
+            619
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With ABT, we generate an alternative answer set for each RPM question in the RAVEN dataset, forming an improved dataset named Impartial-RAVEN (I-RAVEN). Next, we will show that compared with RAVEN, I-RAVEN is more rigorous and fair for evaluating abstract reasoning capability.",
+        "bbox": [
+            514,
+            625,
+            911,
+            695
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Taking Figure 4(b) for example, each attribute has two different values which distribute evenly in the answer set. The attribute Color of half answer candidates (1, 2, 4, and 7) are black, while the other half (3, 5, 6, and 8) are light grey. Similarly, the attribute Type of half answer candidates (1, 2, 6, and 8) are pentagon, while the other half (3, 4, 5, and 7) are circle. Half of the answer set (1, 3, 4, and 6) are in the same size, which are different from the other same-sized half (2, 5, 7, and 8). As a result, there is no candidate with the most common values for each attribute. In other words, the back-door solution on RAVEN can no longer be applied to the new answer set.",
+        "bbox": [
+            514,
+            694,
+            913,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To better explain the superiority of I-RAVEN over RAVEN, as shown in Figure 5, we use undirected graphs",
+        "bbox": [
+            516,
+            859,
+            911,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/9af8277fca47a81e971efa150142e1aa7a623016f5439490362f5fd35603c7dc.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Acc</td><td>Center</td><td>2×2G</td><td>3×3G</td><td>O-IC</td><td>O-IG</td><td>L-R</td><td>U-D</td></tr><tr><td>LSTM (Zhang et al. 2019a)</td><td>18.9</td><td>26.2</td><td>16.7</td><td>15.1</td><td>21.9</td><td>21.1</td><td>14.6</td><td>16.5</td></tr><tr><td>WReN (Barrett et al. 2018)</td><td>23.8</td><td>29.4</td><td>26.8</td><td>23.5</td><td>22.5</td><td>21.5</td><td>21.9</td><td>21.4</td></tr><tr><td>ResNet (Zhang et al. 2019a)</td><td>40.3</td><td>44.7</td><td>29.3</td><td>27.9</td><td>46.2</td><td>35.8</td><td>51.2</td><td>47.4</td></tr><tr><td>ResNet+DRT (Zhang et al. 2019a)</td><td>40.4</td><td>46.5</td><td>28.8</td><td>27.3</td><td>46.0</td><td>34.2</td><td>50.1</td><td>49.8</td></tr><tr><td>LEN (Zheng, Zha, and Wei 2019)</td><td>41.4</td><td>56.4</td><td>31.7</td><td>29.7</td><td>52.1</td><td>31.7</td><td>44.2</td><td>44.2</td></tr><tr><td>Wild ResNet (Barrett et al. 2018)</td><td>44.3</td><td>50.9</td><td>33.1</td><td>30.8</td><td>50.9</td><td>38.7</td><td>53.1</td><td>52.6</td></tr><tr><td>CoPINet (Zhang et al. 2019b)</td><td>46.1</td><td>54.4</td><td>36.8</td><td>31.9</td><td>52.2</td><td>42.8</td><td>51.9</td><td>52.5</td></tr><tr><td>SRAN (Ours)</td><td>60.8</td><td>78.2</td><td>50.1</td><td>42.4</td><td>68.2</td><td>46.3</td><td>70.1</td><td>70.3</td></tr></table>",
+        "bbox": [
+            143,
+            64,
+            854,
+            195
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/cc9fb222bbf5e4a7863318487b86085b9fe0703eafb688ed8aa83d83c1fedff0.jpg",
+        "table_caption": [
+            "Table 2: Test accuracy of different models on I-RAVEN. Acc denotes the mean accuracy, while other columns show accuracy across seven figure configurations.  $2 \\times 2\\mathrm{G}$ ,  $3 \\times 3\\mathrm{G}$ , O-IC, O-IG, L-R, and U-D denote  $2 \\times 2\\mathrm{Grid}$ ,  $3 \\times 3\\mathrm{Grid}$ , Out-InCenter, Out-InGrid, Left-Right, and Up-Down, respectively"
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>LSTM</td><td>ResNet</td><td>Wild ResNet</td><td>CoPINet</td><td>WReN</td><td>MXGNet</td><td>LEN</td><td>SRAN</td></tr><tr><td>Acc</td><td>35.8</td><td>42.0</td><td>48.0</td><td>56.4</td><td>62.6</td><td>66.7</td><td>68.1</td><td>71.3</td></tr></table>",
+        "bbox": [
+            163,
+            266,
+            834,
+            299
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Test accuracy of different models on PGM",
+        "bbox": [
+            328,
+            309,
+            666,
+            323
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "$\\bigcirc$  Correct answer",
+            "$\\bigcirc$  Distractor",
+            "Differ in one attribute"
+        ],
+        "bbox": [
+            84,
+            391,
+            250,
+            431
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/ec49ec108e761339e6e4bd0e03cc69e747e1bf3cbac66cb615de59d2229d3dfb.jpg",
+        "image_caption": [
+            "(a) RAVEN"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            398,
+            352,
+            477
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/4c808eede0a60e80ed450a8a103ba09f045db01e3ac1637cd1476cebd5ea1ce6.jpg",
+        "image_caption": [
+            "(b) I-RAVEN",
+            "Figure 5: Characterizing answer sets of RAVEN and I-RAVEN using graphs"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            364,
+            393,
+            478,
+            479
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "to characterize typical answer sets of the two datasets respectively, where each candidate answer is represented by a node with its degree inflated. An edge between two nodes represents that the corresponding candidates differ in one attribute. In Figure 5(a), there is always a central node with a degree of 7 and the other nodes with less degrees. The back-door solution is to find the central node, which is indeed the correct answer. By contrast, in Figure 5(b), due to balanced modifications of attributes, each node always has the same degree of 3, which is indistinguishable from each other without the context matrix. Moreover, inspired by (Hill et al. 2019), we make the noise attribute Uniformity of each distractor stay consistent with the correct answer, so that each distractor is perceptually plausible and cannot be eliminated simply by attribute mismatching. This setting encourages models to reason from the context.",
+        "bbox": [
+            81,
+            568,
+            478,
+            789
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also train ResNet and CoPINet on I-RAVEN alongside with their context-blind versions to verify the fairness of the proposed dataset. The right column in Table 1 lists the results which are in stark contrast with those on the original RAVEN dataset. The performance of context-blind models is almost at a random guess level (12.5%), while the normal models relying on the context can perform much better.",
+        "bbox": [
+            81,
+            790,
+            478,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Experiments",
+        "text_level": 1,
+        "bbox": [
+            658,
+            354,
+            769,
+            373
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Experimental Setup",
+        "text_level": 1,
+        "bbox": [
+            516,
+            376,
+            674,
+            393
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With I-RAVEN, we first compare our method with several state-of-the-art models using public implementations, including LSTM (Hochreiter and Schmidhuber 1997), ResNet-based (He et al. 2016) image classifier (ResNet), ResNet with DRT (Zhang et al. 2019a), Wild ResNet (Barrett et al. 2018), WReN (Barrett et al. 2018), CoPINet (Zhang et al. 2019b), and LEN (Zheng, Zha, and Wei 2019). We adopt the public implementations of LSTM, ResNet, and DRT in (Zhang et al. 2019a). Other variants of LEN are not included in this section because they require additional training labels.",
+        "bbox": [
+            514,
+            396,
+            913,
+            549
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "PGM (Barrett et al. 2018) is another RPM dataset consisting of 1.42M questions. Rules in a matrix are composed with 1 to 4 relation-object-attribute tuples and can be applied along the rows or columns. SRAN is compared with results on PGM reported in (Barrett et al. 2018; Zhang et al. 2019b; Zheng, Zha, and Wei 2019; Wang, Jamnik, and Lio 2020).",
+        "bbox": [
+            514,
+            549,
+            911,
+            633
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For our SRAN, we adopt three ResNet-18 (He et al. 2016) as the embedding networks for the three hierarchies, by modifying the input channels. The gate fusion  $\\varphi_{1}$  and  $\\varphi_{2}$  are 2-layer fully connected networks, while  $\\varphi_{3}$  is a 4-layer fully connected network with dropout (Srivastava et al. 2014) of 0.5 applied on the last layer. We adopt stochastic gradient descent using ADAM (Kingma and Ba 2014) optimizer. The exponential decay rate parameters are  $\\beta_{1} = 0.9$ ,  $\\beta_{2} = 0.999$ ,  $\\epsilon = 10^{-8}$ . Each reported accuracy is averaged over 5 runs.",
+        "bbox": [
+            514,
+            633,
+            911,
+            771
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Comparisons with State-of-the-art Methods",
+        "text_level": 1,
+        "bbox": [
+            516,
+            785,
+            854,
+            800
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2 and Table 3 list the test accuracy of different models trained on I-RAVEN and PGM, respectively. From the table, it is obvious that our proposed SRAN outperforms other methods by a considerable margin. Besides, we observe that models benefit from inductive biases, such as the competitive CoPINet, LEN, Wild ResNet, and our SRAN. Such in-",
+        "bbox": [
+            514,
+            804,
+            911,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "ductive biases (even partly) can encourage models to explore the underlying rules. For more detailed comparison, Table 2 also reports the accuracy on seven figure configurations of I-RAVEN. We can observe that accuracy on different configurations is not uniform, possibly due to the difficulty of configurations. But compared with other models, our SRAN consistently achieves the best performance on all the configurations, which proves that our model can work stably, even facing diverse conditions and complex rules.",
+        "bbox": [
+            81,
+            68,
+            478,
+            193
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We observe that the accuracy of SRAN on I-RAVEN is very close to that on the original RAVEN dataset (60.8% vs. 60.7%). This phenomenon is as expected since our method mainly focuses on rules in the context, and thus is robust to the answer set.",
+        "bbox": [
+            81,
+            193,
+            480,
+            262
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Ablation Study",
+        "text_level": 1,
+        "bbox": [
+            83,
+            273,
+            204,
+            287
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As aforementioned, our method mainly gains from the inductive-biased architecture. To validate this point, we study the effects of different components in our SRAN. Table 4 lists the results.",
+        "bbox": [
+            81,
+            289,
+            478,
+            345
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We analyze the stratified strategy to incrementally induce rules, using the performance of different choices of hierarchies. Specifically, we set the rule embedding of certain hierarchy as a zero vector before gate function  $\\varphi$ . Thus, the gate function regulates the flow of features into the gated embedding fusion module. We observe that combing more hierarchies always leads to better performance on I-RAVEN, which shows all hierarchies contribute to our framework. We make  $\\mathbb{E}_{\\mathrm{cell}}$  orderless by summing all cell-wise embeddings and observe a major drop in performance. These observations prove the effectiveness of the proposed inductive biases of order sensitivity and incremental rule induction.",
+        "bbox": [
+            81,
+            345,
+            478,
+            511
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We further discover that the effectiveness of our model can be put down to its attention to different attributes. We conduct experiments only utilizing single-hierarchy rule embeddings from  $\\mathbb{E}_{\\mathrm{cell}}$ ,  $\\mathbb{E}_{\\mathrm{ind}}$ ,  $\\mathbb{E}_{\\mathrm{eco}}$ , with respect to three attributes (Type, Size, and Color) of I-RAVEN. As shown in Figure 6,  $\\mathbb{E}_{\\mathrm{cell}}$  has strong capacity to infer attributes Type and Size, but struggles to distinguish attribute Color. By contrast,  $\\mathbb{E}_{\\mathrm{ind}}$  and  $\\mathbb{E}_{\\mathrm{eco}}$  have modest ability to infer attributes Type and Size, and are efficient for attribute Color.",
+        "bbox": [
+            81,
+            511,
+            478,
+            637
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The Advantage of Rule Embeddings",
+        "text_level": 1,
+        "bbox": [
+            83,
+            646,
+            364,
+            662
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the real RPM test, it is not clear whether the rule exists in rows or columns. Therefore, it is important to check whether the proposed model can discover the knowledge without any guidance. Rule induction for columns is normally left out when trained on I-RAVEN, given the prior knowledge that rules are applied only row-wise. In order to test the ability of distinguishing whether the rules are applied along rows or columns, we train a SRAN model on I-RAVEN which the induction for column rules is reintegrated into. As a result, there is only a bit drop in accuracy (from  $60.8\\%$  to  $59.6\\%$ ). This indicates that our model can neglect the distraction brought by columns on its own.",
+        "bbox": [
+            81,
+            662,
+            480,
+            830
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Conclusion",
+        "text_level": 1,
+        "bbox": [
+            230,
+            843,
+            330,
+            857
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduced necessary inductive biases for abstract visual reasoning task, such as order sensitivity and",
+        "bbox": [
+            81,
+            859,
+            480,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c576f584862ce3ef4d4adba012257d68f0d3e45e05d147b258ced4846368a7b9.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>I-RAVEN</td></tr><tr><td>Ecell (orderless)</td><td>23.5</td></tr><tr><td>Ecell</td><td>36.7</td></tr><tr><td>Eind</td><td>48.7</td></tr><tr><td>Eeco</td><td>51.6</td></tr><tr><td>Ecell + Eeco</td><td>52.9</td></tr><tr><td>Eind + Eeco</td><td>57.0</td></tr><tr><td>Ecell + Eind</td><td>57.8</td></tr><tr><td>Ecell + Eind + Eeco</td><td>60.8</td></tr></table>",
+        "bbox": [
+            601,
+            64,
+            828,
+            195
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 4: SRAN  $(\\mathbb{E}_{\\mathrm{cell}} + \\mathbb{E}_{\\mathrm{ind}} + \\mathbb{E}_{\\mathrm{eco}})$  and the results of eliminating different components",
+        "bbox": [
+            514,
+            203,
+            913,
+            233
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/42360998645bd612c7a49a954b4d329119c39b0fb26179fcd135a8cb81817d6a.jpg",
+        "image_caption": [
+            "Figure 6: Accuracy of single hierarchy with respect to the different attributes"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            527,
+            253,
+            874,
+            434
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "incremental rule induction. We further proposed a novel Stratified Rule-Aware Network, which could extract multiple granularity rule embeddings at different level and integrate them through a gated embedding fusion module. A rule similarity metric was further introduced based on the embeddings, so that SRAN can not only be trained using a tuple loss but also infer the best answer according to the similarity score. We also designed an algorithm named Attribute Bisection Tree to fix the defects of the popular dataset RAVEN, and generated a more rigorous dataset based on the algorithm. Extensive experiments conducted on PGM dataset and our improved dataset I-RAVEN proved that, our proposed framework could significantly outperform other state-of-the-art approaches. Moreover, we studied the effects of each component of our proposed model and evaluated the advantage of our induced rule embeddings.",
+        "bbox": [
+            514,
+            516,
+            913,
+            739
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments",
+        "text_level": 1,
+        "bbox": [
+            635,
+            762,
+            795,
+            779
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by National Natural Science Foundation of China (62022009, 61872021), Beijing Nova Program of Science and Technology (Z191100001119050), State Key Lab of Software Development Environment (SKLSDE-2020ZX-06), Fundamental Research Funds for Central Universities (YWF-20-BJ-J-646), and the Academic Excellence Foundation of BUAA for PhD Students.",
+        "bbox": [
+            514,
+            790,
+            913,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "References",
+        "text_level": 1,
+        "bbox": [
+            233,
+            66,
+            330,
+            82
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Barrett, D.; Hill, F.; Santoro, A.; Morcos, A.; and Lillicrap, T. 2018. Measuring abstract reasoning in neural networks. In Proceedings of International Conference on Machine Learning (ICML), 511-520.",
+            "Carpenter, P. A.; Just, M. A.; and Shell, P. 1990. What One Intelligence Test Measures: A Theoretical Account of the Processing in the Raven Progressive Matrices Test. Psychological Review 97(3): 404-431.",
+            "He, K.; Zhang, X.; Ren, S.; and Sun, J. 2016. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 770-778.",
+            "Hill, F.; Santoro, A.; Barrett, D.; Morcos, A.; and Lillicrap, T. 2019. Learning to Make Analogies by Contrasting Abstract Relational Structure. In International Conference on Learning Representations (ICLR).",
+            "Hochreiter, S.; and Schmidhuber, J. 1997. Long short-term memory. Neural computation 9(8): 1735-1780.",
+            "Hoshen, D.; and Werman, M. 2017. Iq of neural networks. arXiv preprint arXiv:1710.01692.",
+            "Johnson, J.; Hariharan, B.; van der Maaten, L.; Fei-Fei, L.; Lawrence Zitnick, C.; and Girshick, R. 2017. Clevr: A diagnostic dataset for compositional language and elementary visual reasoning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2901–2910.",
+            "Kingma, D. P.; and Ba, J. 2014. Adam: A method for stochastic optimization. International Conference on Learning Representations (ICLR).",
+            "Krizhevsky, A.; Sutskever, I.; and Hinton, G. E. 2012. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems (NeurIPS), 1097-1105.",
+            "Kunda, M.; McGregor, K.; and Goel, A. K. 2013. A computational model for solving problems from the Raven's Progressive Matrices intelligence test using iconic visual representations. Cognitive Systems Research 22: 47-66.",
+            "Lovett, A.; and Forbus, K. 2017. Modeling visual problem solving as analogical reasoning. *Psychological Review* 124(1): 60-90.",
+            "Lovett, A.; Forbus, K.; and Usher, J. 2010. A structure-mapping model of Raven's Progressive Matrices. In Proceedings of the Annual Meeting of the Cognitive Science Society, volume 32.",
+            "Lovett, A.; Tomai, E.; Forbus, K.; and Usher, J. 2010. Solving Geometric Analogy Problems Through Two-Stage Analogical Mapping. Cognitive Science 33(7): 1192-1231.",
+            "Parent, E. 1996. The living systems theory of James Grier Miller. Retrieved November 29: 2007.",
+            "Raven, J. 2000. The Raven's progressive matrices: change and stability over culture and time. Cognitive psychology 41(1): 1-48."
+        ],
+        "bbox": [
+            84,
+            87,
+            478,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Raven, J. C. 1938. Raven's progressive matrices. Western Psychological Services.",
+            "Simonyan, K.; and Zisserman, A. 2015. Very deep convolutional networks for large-scale image recognition. In International Conference on Learning Representations (ICLR).",
+            "Sohn, K. 2016. Improved deep metric learning with multiclass n-pair loss objective. In Advances in Neural Information Processing Systems (NeurIPS), 1857-1865.",
+            "Srivastava, N.; Hinton, G.; Krizhevsky, A.; Sutskever, I.; and Salakhutdinov, R. 2014. Dropout: a simple way to prevent neural networks from overfitting. The journal of machine learning research 15(1): 1929-1958.",
+            "Steenbrugge, X.; Leroux, S.; Verbelen, T.; and Dhoedt, B. 2018. Improving generalization for abstract reasoning tasks using disentangled feature representations. arXiv preprint arXiv:1811.04784.",
+            "Strannegård, C.; Cirillo, S.; and Ström, V. 2013. An anthropomorphic method for progressive matrix problems. Cognitive Systems Research 22: 35-46.",
+            "Szegedy, C.; Liu, W.; Jia, Y.; Sermanet, P.; Reed, S.; Anguelov, D.; Erhan, D.; Vanhoucke, V.; and Rabinovich, A. 2015. Going deeper with convolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 1-9.",
+            "van Steenkiste, S.; Locatello, F.; Schmidhuber, J.; and Bachem, O. 2019. Are Disentangled Representations Helpful for Abstract Visual Reasoning? In Advances in Neural Information Processing Systems (NeurIPS), 14222-14235.",
+            "Wang, D.; Jamnik, M.; and Lio, P. 2020. Abstract diagrammatic reasoning with multiplex graph networks. In International Conference on Learning Representations (ICLR).",
+            "Zhang, C.; Gao, F.; Jia, B.; Zhu, Y.; and Zhu, S.-C. 2019a. RAVEN: A dataset for relational and analogical visual reasoning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 5317-5327.",
+            "Zhang, C.; Jia, B.; Gao, F.; Zhu, Y.; Lu, H.; and Zhu, S.-C. 2019b. Learning perceptual inference by contrasting. In Advances in Neural Information Processing Systems (NeurIPS), 1073-1085.",
+            "Zheng, K.; Zha, Z.-J.; and Wei, W. 2019. Abstract Reasoning with Distracting Features. In Advances in Neural Information Processing Systems (NeurIPS), 5834-5845."
+        ],
+        "bbox": [
+            517,
+            68,
+            911,
+            705
+        ],
+        "page_idx": 7
+    }
+]

2002.06xxx/2002.06838/b5f48312-e0e5-4d14-b736-57b539ada670_model.json

@@ -0,0 +1,1921 @@
+[
+    [
+        {
+            "type": "title",
+            "bbox": [
+                0.187,
+                0.121,
+                0.812,
+                0.143
+            ],
+            "angle": 0,
+            "content": "Stratified Rule-Aware Network for Abstract Visual Reasoning"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.199,
+                0.172,
+                0.796,
+                0.191
+            ],
+            "angle": 0,
+            "content": "Sheng Hu,\\(^{1,*}\\) Yuqing Ma,\\(^{1,*}\\) Xianglong Liu,\\(^{1,2,\\dagger}\\) Yanlu Wei,\\(^{1}\\) Shihao Bai\\(^{1}\\)"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.123,
+                0.192,
+                0.877,
+                0.236
+            ],
+            "angle": 0,
+            "content": "\\(^{1}\\) State Key Laboratory of Software Development Environment, Beihang University, Beijing, China  \n\\(^{2}\\) Beijing Advanced Innovation Center for Big Data-Based Precision Medicine, Beihang University, Beijing, China  \nhusheng_7@163.com, {mayuqing,xliiu} @nlsde.buaa.edu.cn, {weiyanlu,16061167} @buaa.edu.cn"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.249,
+                0.274,
+                0.315,
+                0.287
+            ],
+            "angle": 0,
+            "content": "Abstract"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.099,
+                0.297,
+                0.465,
+                0.664
+            ],
+            "angle": 0,
+            "content": "Abstract reasoning refers to the ability to analyze information, discover rules at an intangible level, and solve problems in innovative ways. Raven's Progressive Matrices (RPM) test is typically used to examine the capability of abstract reasoning. The subject is asked to identify the correct choice from the answer set to fill the missing panel at the bottom right of RPM (e.g., a \\(3 \\times 3\\) matrix), following the underlying rules inside the matrix. Recent studies, taking advantage of Convolutional Neural Networks (CNNs), have achieved encouraging progress to accomplish the RPM test. However, they partly ignore necessary inductive biases of RPM solver, such as order sensitivity within each row/column and incremental rule induction. To address this problem, in this paper we propose a Stratified Rule-Aware Network (SRAN) to generate the rule embeddings for two input sequences. Our SRAN learns multiple granularity rule embeddings at different levels, and incrementally integrates the stratified embedding flows through a gated fusion module. With the help of embeddings, a rule similarity metric is applied to guarantee that SRAN can not only be trained using a tuplet loss but also infer the best answer efficiently. We further point out the severe defects existing in the popular RAVEN dataset for RPM test, which prevent from the fair evaluation of the abstract reasoning ability. To fix the defects, we propose an answer set generation algorithm called Attribute Bisection Tree (ABT), forming an improved dataset named Impartial-RAVEN (I-RAVEN for short). Extensive experiments are conducted on both PGM and I-RAVEN datasets, showing that our SRAN outperforms the state-of-the-art models by a considerable margin."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.226,
+                0.683,
+                0.338,
+                0.699
+            ],
+            "angle": 0,
+            "content": "Introduction"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.703,
+                0.48,
+                0.829
+            ],
+            "angle": 0,
+            "content": "Abstract reasoning, also known as inductive reasoning, refers to the ability to analyze information, discover rules at an intangible level, and solve problems in innovative ways. This type of reasoning, as the foundation for human intelligence, helps human understand the world. It has been generally regarded and pursued as a critical component to the development of artificial intelligence during the past decades, and has attracted increasing attention in recent years. Raven's Progressive Matrices (RPM) test (Raven"
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.518,
+                0.272,
+                0.915,
+                0.462
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.516,
+                0.471,
+                0.915,
+                0.57
+            ],
+            "angle": 0,
+            "content": "Figure 1: An example of RPM question and the human strategy to solve it. The underlying rule on the number of circles could be Progression (2-1=3-2) or Arithmetic (1+2=3) along row 1, and Arithmetic (2+3=5) along row 2. Therefore the dominant rule is Arithmetic. Apply it to the third row to figure out the answer \\((2+2=4)\\). Besides, no viable rule can be found along the columns"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.597,
+                0.913,
+                0.805
+            ],
+            "angle": 0,
+            "content": "1938; Carpenter, Just, and Shell 1990; Raven 2000; Kunda, McGregor, and Goel 2013; Strannegård, Cirillo, and Ström 2013) is one of the highly accepted and well-studied tools to examine the ability of abstract reasoning, which is believed as a good estimate of the real intelligence (Carpenter, Just, and Shell 1990). An illustration of RPM is shown in Figure 1, where usually the test-taker is presented with a \\(3 \\times 3\\) matrix with the bottom right panel left blank. The goal is to choose one image from an answer set of eight candidates to complete the matrix correctly, namely satisfying the underlying rules in the matrix. Subjects accomplish this by looking into the first two rows/columns and inducing the dominant rules which govern the attributes in those panels. The obtained rules can then be applied to the last row/column to figure out which answer belongs to the blank panel."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.806,
+                0.914,
+                0.89
+            ],
+            "angle": 0,
+            "content": "Computational models for RPM in the cognitive science community access symbolic representations of the images (Carpenter, Just, and Shell 1990; Lovett and Forbus 2017; Lovett, Forbus, and Usher 2010; Lovett et al. 2010). Recently there has been some success with end-to-end learning methods trying to accomplish abstract reasoning on"
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.081,
+                0.838,
+                0.48,
+                0.89
+            ],
+            "angle": 0,
+            "content": "*Equal contribution  \n†Corresponding author  \nCopyright © 2021, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved."
+        },
+        {
+            "type": "aside_text",
+            "bbox": [
+                0.023,
+                0.273,
+                0.059,
+                0.701
+            ],
+            "angle": 270,
+            "content": "arXiv:2002.06838v3 [cs.CV] 7 Jun 2022"
+        }
+    ],
+    [
+        {
+            "type": "text",
+            "bbox": [
+                0.087,
+                0.069,
+                0.478,
+                0.415
+            ],
+            "angle": 0,
+            "content": "RPM test (Hoshen and Werman 2017; Barrett et al. 2018; Steenbrugge et al. 2018; Zhang et al. 2019a,b; Zheng, Zha, and Wei 2019; van Steenkiste et al. 2019; Wang, Jamnik, and Lio 2020), inspired by the progress of computer vision tasks (Krizhevsky, Sutskever, and Hinton 2012; Simonyan and Zisserman 2015; Szegedy et al. 2015; He et al. 2016) and boosted by the large-scale PGM (Barrett et al. 2018) and RAVEN (Zhang et al. 2019a) datasets. Typical works including CoPINet (Zhang et al. 2019a), LEN (Zheng, Zha, and Wei 2019), and MXGNet (Wang, Jamnik, and Lio 2020) followed the paradigm that predicts a classification score for each multiple-choice panel based on the relations inside each row/column, showing great potential to solve RPM test. However, these models partly ignore the important characteristics for RPM, such as the permutation invariance (Zhang et al. 2019b), the order sensitivity of panels inside a row/column, etc. Previous work (Wang, Jamnik, and Lio 2020) specially mentions that they do not choose a permutation-invariant structure because it leads to severe 'overfitting' on the RAVEN dataset. We will discuss this phenomenon in later sections. What is even worse, directly extracting the relations, without considering the incremental rule induction mechanism widely adopted in human cognitive systems (Carpenter, Just, and Shell 1990), inevitably leads to inferior performance."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.087,
+                0.416,
+                0.478,
+                0.638
+            ],
+            "angle": 0,
+            "content": "To achieve reliable and efficient abstract reasoning, in this paper we develop a powerful architecture called Stratified Rule-Aware Network (SRAN) that naturally integrates the indispensable inductive biases, including order sensitivity, permutation invariance, and incremental rule induction. SRAN takes two rows/columns as input and learns stratified rule embeddings at different levels, namely cell-wise, individual-wise, and ecological hierarchy. These multiple granularity embeddings are incrementally integrated via a gate fusion module, which naturally preserves the order sensitivity of panels and maps the inputs to a rule embedding space. With the help of the embeddings, we further introduce a rule similarity metric, based on which SRAN can not only be well trained using a tuplet loss but also infer the best answer efficiently. This framework resembles the human strategy for RPM shown in Figure 1."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.087,
+                0.639,
+                0.478,
+                0.777
+            ],
+            "angle": 0,
+            "content": "To fairly evaluate the abstract reasoning ability, we also design a general algorithm named Attribute Bisection Tree (ABT) to generate an impartial answer set for any attribute-based RPM question. We point out and further fix the underlying defects of the commonly-used RAVEN (Zhang et al. 2019a) dataset, where the correct answer could be inferred even without the presence of the context matrix. Therefore, we introduce an improved dataset named Impartial-RAVEN (I-RAVEN) to fairly evaluate the abstract reasoning capability of RPM solvers."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.087,
+                0.778,
+                0.478,
+                0.889
+            ],
+            "angle": 0,
+            "content": "To the best of our knowledge, the proposed SRAN is the first RPM solver to induce rule embeddings which are discriminative and measurable. We are also the first to point out and fix the defects of the misleading benchmark RAVEN, and generate an impartial dataset I-RAVEN based on our ABT algorithm. Extensive experiments conducted on widely used dataset PGM and our improved I-RAVEN show that SRAN outperforms state-of-the-art methods by a consider-"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.52,
+                0.07,
+                0.912,
+                0.096
+            ],
+            "angle": 0,
+            "content": "able margin, e.g. \\(60.8\\%\\) accuracy compared to the second best \\(46.1\\%\\) on I-RAVEN."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.654,
+                0.11,
+                0.777,
+                0.127
+            ],
+            "angle": 0,
+            "content": "Our Approach"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.52,
+                0.13,
+                0.912,
+                0.199
+            ],
+            "angle": 0,
+            "content": "In this section, we first give a formal definition of the abstract reasoning task on the RPM test. Then we introduce the inductive-biased framework, and present our Stratified Rule-Aware Network (SRAN). Finally, we demonstrate the learning and inference process of the proposed model."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.52,
+                0.211,
+                0.614,
+                0.227
+            ],
+            "angle": 0,
+            "content": "Preliminary"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.52,
+                0.228,
+                0.912,
+                0.339
+            ],
+            "angle": 0,
+            "content": "For a common RPM question, usually a \\(3 \\times 3\\) matrix \\(\\mathbf{M}^{-}\\) is given, with bottom right context panel left blank. \\(\\Omega\\) denotes the answer set with \\(N\\) multiple-choice panels, where typically \\(N = 8\\). The dominant rules governing the features inside the matrix could be induced from the first two intact rows/columns. The goal is to select a multiple-choice panel \\(\\omega \\in \\Omega\\) to complete the context matrix \\(\\mathbf{M}^{-}\\), maintaining the dominant rule inside of the context matrix."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.52,
+                0.34,
+                0.912,
+                0.479
+            ],
+            "angle": 0,
+            "content": "We define the completed matrix with a multiple-choice panel \\(\\omega\\) filled as \\(\\mathbf{M}\\), where \\(\\mathbf{M}_i\\) is denoted as the \\(i\\)-th row, and \\(\\mathbf{m}_{ij}\\) indicates the panel in \\(i\\)-th row and \\(j\\)-th column. Intuitively, \\(\\mathbf{M}\\) is almost the same as \\(\\mathbf{M}^{-}\\), except for \\(\\mathbf{m}_{33} = \\omega\\) while the corresponding element missing in \\(\\mathbf{M}^{-}\\). In fact, whether rules exist in rows or columns is uncertain. Therefore, our framework induces both the row-wise rule representation and the column-wise representation in the same way. In order to simplify the notation, we only take the induction of the row-wise rule representation as example."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.52,
+                0.49,
+                0.73,
+                0.505
+            ],
+            "angle": 0,
+            "content": "The Reasoning Framework"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.52,
+                0.508,
+                0.912,
+                0.774
+            ],
+            "angle": 0,
+            "content": "Based on the necessary inductive biases for RPM, we develop a novel abstract reasoning architecture named Stratified Rule-Aware Network (SRAN). Given two input rows \\(\\mathbf{M}_i,\\mathbf{M}_j\\), the proposed framework embeds the input into multiple granularity embeddings using a stratified rule embedding module \\(\\mathbb{E}\\). Named after biological organizations (Parent 1996), \\(\\mathbb{E}\\) consists of three hierarchies including cell-wise network \\(\\mathbb{E}_{\\mathrm{cell}}\\), individual-wise network \\(\\mathbb{E}_{\\mathrm{ind}}\\), and ecological network \\(\\mathbb{E}_{\\mathrm{eco}}\\). With the multiple granularity rule embeddings, the gated embedding fusion module \\(\\mathbb{G}\\) will incrementally integrate these stratified embedding flows and map the two input sequences \\(\\mathbf{M}_i\\) and \\(\\mathbf{M}_j\\) to a discriminative rule embedding \\(\\mathbf{r}_{ij}^{(3)}\\), while maintaining the order sensitivity and permutation invariance. We further introduce a rule similarity metric \\(\\mathcal{D}\\) to estimate the similarity between the rule representations. The correct answer can be predicted by choosing the multiple-choice panel within the shortest distance to the dominant rule generated by the first two rows in the matrix."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.52,
+                0.788,
+                0.727,
+                0.803
+            ],
+            "angle": 0,
+            "content": "Stratified Rule Embedding"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.52,
+                0.806,
+                0.912,
+                0.889
+            ],
+            "angle": 0,
+            "content": "As we all know, organization of behaviour into a nested hierarchy of tasks is characteristic of purposive cognition in humans. The prevalent Convolution Neural Network inspired by the human visual system, is a stratified model itself, with the projection from each layer showing the hierarchical nature of features. The bottom layers extract low-level features,"
+        }
+    ],
+    [
+        {
+            "type": "text",
+            "bbox": [
+                0.083,
+                0.069,
+                0.48,
+                0.111
+            ],
+            "angle": 0,
+            "content": "such as texture, edge, etc, while the top layers abstract high-level semantic information from the low-level information transmitted from the bottom layers."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.111,
+                0.48,
+                0.237
+            ],
+            "angle": 0,
+            "content": "However, without specifying information from different levels, it is hard for CNN to figure out different hierarchies, and thus fail to obtain robust and discriminative representations. Therefore, it would be better to feed the input of different hierarchies explicitly and extract rule representations from different granularity with artificial guidance. Motivated by that, we deploy a stratified rule embedding module, consisting of cell-wise hierarchy, individual-wise hierarchy, and ecological hierarchy."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.242,
+                0.481,
+                0.34
+            ],
+            "angle": 0,
+            "content": "Cell-wise Hierarchy The network of the cell-wise hierarchy \\(\\mathbb{E}_{\\mathrm{cell}}\\) takes each panel as input and recognize the attributes of inside graphical elements. It handles each panel independently without considering the difference or correlations among panels inside the matrix. Therefore, it observes the information from the most detailed perspective. We obtain the cell-wise rule representation for each input panel:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.22,
+                0.346,
+                0.48,
+                0.363
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathbf {x} _ {i j} = \\mathbb {E} _ {\\text {c e l l}} (\\mathbf {m} _ {i j}). \\tag {1}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.367,
+                0.481,
+                0.546
+            ],
+            "angle": 0,
+            "content": "Individual-wise Hierarchy Moreover, the network of individual hierarchy takes each row as input. It begins to take the correlations among panels of the same row into consideration, and encode the entire row with a compact embedding, rather than simply combining each panel. In this way, the rule embedding process for each panel is coupled and interacts with each other. Intuitively, each row may contain multiple plausible rules. In this hierarchy, the framework extracts intermediate rule embedding for each row individually, which still ignores the comprehensive information from the matrix perspective, especially the correlations across rows. The individual-wise rule embedding \\(\\mathbf{y}_i\\) is denoted as:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.227,
+                0.547,
+                0.479,
+                0.563
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathbf {y} _ {i} = \\mathbb {E} _ {\\text {i n d}} \\left(\\mathbf {M} _ {i}\\right). \\tag {2}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.568,
+                0.481,
+                0.721
+            ],
+            "angle": 0,
+            "content": "Ecological Hierarchy Furthermore, the network of the ecological hierarchy takes the two rows together as input and jointly learns the rule patterns underlying the two rows. As we mentioned before, in the individual hierarchy, the framework extracts intermediate rule embedding for each row, without considering the interaction between two rows. The rule that exists in one row may not lie in another. Therefore, to obtain the shared rule patterns between the two rows, it is essential to put these two rows together and jointly learn the features from an ecological level. Thus the shared rule embedding is obtained as follows:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.202,
+                0.727,
+                0.48,
+                0.744
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathbf {z} _ {i j} = \\mathbb {E} _ {\\mathrm {e c o}} ([ \\mathbf {M} _ {i}, \\mathbf {M} _ {j} ]), \\tag {3}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.084,
+                0.748,
+                0.4,
+                0.765
+            ],
+            "angle": 0,
+            "content": "where \\([\\cdot ,\\cdot ]\\) denotes the concatenating operation."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.084,
+                0.773,
+                0.285,
+                0.789
+            ],
+            "angle": 0,
+            "content": "Gated Embedding Fusion"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.791,
+                0.481,
+                0.89
+            ],
+            "angle": 0,
+            "content": "Since the rule embeddings at different levels focus on different attributes or patterns, to generate one discriminative representation for the rule, we should aggregate the multiple granularity embeddings. Due to the requirement that the aggregation should preserve the order of cell-wise rule embeddings and be permutation-invariant to the individual-wise ones, we propose a stratified rule embedding learning"
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.526,
+                0.07,
+                0.895,
+                0.226
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.516,
+                0.237,
+                0.915,
+                0.294
+            ],
+            "angle": 0,
+            "content": "Figure 2: The architecture of SRAN, consisting of a hierarchical rule embedding module and a gated embedding fusion module. Given two row sequences as input, it outputs the rule embedding"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.321,
+                0.913,
+                0.363
+            ],
+            "angle": 0,
+            "content": "method named gated embedding fusion module, which is responsible for gradually aggregating the multiple granularity embeddings."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.364,
+                0.914,
+                0.502
+            ],
+            "angle": 0,
+            "content": "Specifically, we define a gate function \\(\\varphi\\) to fuse the rule embeddings from different hierarchies. It concatenates all the inputs and encodes into a single embedding using fully connected layers. The gate function is similar to the attention mechanism, which detects and concentrates on the useful features according to the task. Even for the same attribute, they may focus on different facets. Based on the gate function, our gated embedding fusion module could regulate the flow of rule embeddings into the framework and make the utmost of their complementary information."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.502,
+                0.913,
+                0.549
+            ],
+            "angle": 0,
+            "content": "At the cell level, after obtaining cell-wise rule embeddings for panels in \\(i\\)-th row \\(\\mathbf{M}_i\\), the module aggregates them to infer a row-wise rule embedding \\(\\mathbf{r}_i^{(1)}\\):"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.631,
+                0.557,
+                0.913,
+                0.577
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathbf {r} _ {i} ^ {(1)} = \\varphi_ {1} \\left(\\mathbf {x} _ {i 1}, \\mathbf {x} _ {i 2}, \\mathbf {x} _ {i 3}\\right), \\tag {4}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.587,
+                0.913,
+                0.616
+            ],
+            "angle": 0,
+            "content": "Similarly, we obtain \\(\\mathbf{r}_j^{(1)}\\) for the \\(j\\)-th row \\(\\mathbf{M}_j\\). The fused embedding integrates different types of attributes in the panels."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.618,
+                0.914,
+                0.689
+            ],
+            "angle": 0,
+            "content": "At the individual level, intuitively both \\(\\mathbf{r}_i^{(1)}\\) and \\(\\mathbf{y}_i\\) are the row-wise embeddings corresponding to the \\(i\\)-th row, but convey the different granularity rule information. We further fuse them, and jointly mine the shared rules contained in the \\(i\\)-th and \\(j\\)-th row:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.618,
+                0.697,
+                0.913,
+                0.719
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathbf {r} _ {i j} ^ {(2)} = \\varphi_ {2} \\left(\\mathbf {r} _ {i} ^ {(1)}, \\mathbf {y} _ {i}, \\mathbf {r} _ {j} ^ {(1)}, \\mathbf {y} _ {j}\\right). \\tag {5}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.724,
+                0.914,
+                0.77
+            ],
+            "angle": 0,
+            "content": "At the ecological level, similarly we can further combine fused embedding \\(\\mathbf{r}_{ij}^{(2)}\\) and \\(\\mathbf{z}_{ij}\\) using the gate fusion function, abstracting the final rule embedding:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.644,
+                0.777,
+                0.913,
+                0.8
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathbf {r} _ {i j} ^ {(3)} = \\varphi_ {3} \\left(\\mathbf {r} _ {i j} ^ {(2)}, \\mathbf {z} _ {i j}\\right). \\tag {6}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.806,
+                0.914,
+                0.89
+            ],
+            "angle": 0,
+            "content": "To make sure the framework is permutation-invariant to the input rows, we exchange the concatenation order of the two input rows and average the output rule embeddings. This invariance ensures that, the rule embedding respects the characteristic of RPM and thus distills the representative information of the relations existing in the inputs."
+        }
+    ],
+    [
+        {
+            "type": "text",
+            "bbox": [
+                0.084,
+                0.069,
+                0.48,
+                0.096
+            ],
+            "angle": 0,
+            "content": "On the whole, the SRAN can be formulated in its simplest form as follows:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.185,
+                0.097,
+                0.48,
+                0.137
+            ],
+            "angle": 0,
+            "content": "\\[\n\\begin{array}{l} \\mathbf {r} _ {i j} ^ {(3)} = \\operatorname {S R A N} \\left(\\mathbf {M} _ {i}, \\mathbf {M} _ {j}\\right) \\tag {7} \\\\ = \\mathbb {G} \\left(\\mathbf {x} _ {i}, \\mathbf {x} _ {j}, \\mathbf {y} _ {i}, \\mathbf {y} _ {j}, \\mathbf {z} _ {i j}\\right), \\\\ \\end{array}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.084,
+                0.139,
+                0.478,
+                0.171
+            ],
+            "angle": 0,
+            "content": "where \\(\\mathbf{r}_{ij}^{(3)}\\) is the shared rule embedding of the \\(\\mathbf{M}_i\\) and \\(\\mathbf{M}_j\\). An illustration of SRAN is shown in Figure 2."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.084,
+                0.18,
+                0.27,
+                0.196
+            ],
+            "angle": 0,
+            "content": "Learning and Inference"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.197,
+                0.48,
+                0.282
+            ],
+            "angle": 0,
+            "content": "With SRAN framework, the question turns to how we train the network, and apply it to infer the correct answer to RPM test. The key to address the question lies in the similarity measure between two rule embeddings, based on which we can define the loss function for SRAN training, and meanwhile determine the best choice during inference."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.286,
+                0.48,
+                0.342
+            ],
+            "angle": 0,
+            "content": "Similarity function We introduce similarity function \\(\\mathcal{D}\\) to measure the closeness between two rules in the embedding space. In this paper, we adopt inner product similarity for good experimental results:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.225,
+                0.343,
+                0.48,
+                0.36
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathcal {D} \\left(\\mathbf {r}, \\mathbf {r} ^ {\\prime}\\right) = \\mathbf {r} ^ {\\mathrm {T}} \\mathbf {r} ^ {\\prime}. \\tag {8}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.084,
+                0.362,
+                0.48,
+                0.404
+            ],
+            "angle": 0,
+            "content": "Training For a given RPM question, the first two rows \\(\\mathbf{M}_1, \\mathbf{M}_2\\) are fed into our proposed SRAN and produce the shared rule embedding \\(\\mathbf{g}\\):"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.18,
+                0.407,
+                0.48,
+                0.425
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathbf {g} = \\mathbf {r} _ {1 2} ^ {(3)} = \\operatorname {S R A N} \\left(\\mathbf {M} _ {1}, \\mathbf {M} _ {2}\\right), \\tag {9}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.084,
+                0.426,
+                0.43,
+                0.44
+            ],
+            "angle": 0,
+            "content": "which represents the dominant pattern of the matrix."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.44,
+                0.48,
+                0.551
+            ],
+            "angle": 0,
+            "content": "Intuitively, the rule extracted from the first two rows can be treated as the reference rule, and we name it the dominant rule in the matrix. Subsequently, the correct answer can be found by checking whether its corresponding rule embedding is similar to the dominant rule. Specifically, given a multiple-choice panel \\(\\omega_{k}\\in \\Omega\\), where \\(k\\in \\{1,\\dots,N\\}\\), we denote \\(\\overline{\\mathbf{r}}_k\\) as the new rule embedding inside \\(\\mathbf{M}\\) caused by the \\(k\\)-th multiple-choice panel:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.202,
+                0.553,
+                0.48,
+                0.581
+            ],
+            "angle": 0,
+            "content": "\\[\n\\bar {\\mathbf {r}} _ {k} = \\frac {1}{2} \\left(\\mathbf {r} _ {1 3} ^ {(3)} + \\mathbf {r} _ {2 3} ^ {(3)}\\right). \\tag {10}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.582,
+                0.48,
+                0.637
+            ],
+            "angle": 0,
+            "content": "This procedure is illustrated in Figure 3. In practice, we generate the column-wise rule representation just as the row-wise one, and concatenate the two representations together as the final representation."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.638,
+                0.481,
+                0.763
+            ],
+            "angle": 0,
+            "content": "For the rule embedding \\(\\overline{\\mathbf{r}}^*\\) generated by rows/columns filled with correct answer, the desirable SRAN should enforce it to be more similar to the dominant rule \\(\\mathbf{g}\\), compared to the other rules \\(\\overline{\\mathbf{r}}_k\\) corresponding to the wrong answers, where \\(\\overline{\\mathbf{r}}_k \\neq \\overline{\\mathbf{r}}^*\\). Subsequently, the generated rules of \\(N\\) candidates, alongside with the dominant rule, form a tuple containing \\(N + 1\\) elements. Based on the similarity function, the \\((N + 1)\\)-tuple loss (Sohn 2016) can be defined for SRAN training:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.096,
+                0.775,
+                0.48,
+                0.817
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathcal {L} = \\log \\left(1 + \\sum_ {k = 1, \\overline {{\\mathbf {r}}} _ {k} \\neq \\overline {{\\mathbf {r}}} ^ {*}} ^ {N} \\exp \\left(\\mathcal {D} \\left(\\mathbf {g}, \\overline {{\\mathbf {r}}} _ {k}\\right) - \\mathcal {D} \\left(\\mathbf {g}, \\overline {{\\mathbf {r}}} ^ {*}\\right)\\right)\\right), \\tag {11}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.819,
+                0.481,
+                0.89
+            ],
+            "angle": 0,
+            "content": "which means the SRAN can be trained in a fully end-to-end manner. The architecture of the SRAN (Figure 2) is well matched to the problem of abstract reasoning, because it leverages human strategies and explicitly generates the rules governing the matrix."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.525,
+                0.072,
+                0.907,
+                0.17
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.516,
+                0.186,
+                0.915,
+                0.27
+            ],
+            "angle": 0,
+            "content": "Figure 3: The similarity score for a candidate answer. A multiple-choice panel from the answer set is inflated in the blank panel (row 3), generating a rule embedding \\(\\overline{\\mathbf{r}}_k\\) through SRAN. The similarity score for the candidate answer can be estimated based on \\(\\overline{\\mathbf{r}}_k\\) and the dominant rule embedding \\(\\mathbf{g}\\) extracted from row 1 and 2"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.298,
+                0.913,
+                0.424
+            ],
+            "angle": 0,
+            "content": "Inference Once the training of SRAN is finished, we could make the inference of the newly given RPM question. Initially, the intact rows/columns of the RPM are fed into the framework to get the dominant rule \\(\\mathbf{g}\\). After that, each multiple-choice panel is filled to the blank position to complete the matrix, and the framework will generate the rule embeddings \\(\\overline{\\mathbf{r}}_k\\) for all candidate answers, given the current completed matrix. We can accomplish the abstract reasoning by choosing the correct multiple-choice as follows:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.632,
+                0.431,
+                0.913,
+                0.455
+            ],
+            "angle": 0,
+            "content": "\\[\nk ^ {*} = \\underset {k} {\\arg \\max } \\mathcal {D} (\\mathbf {g}, \\overline {{\\mathbf {r}}} _ {k}). \\tag {12}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.462,
+                0.914,
+                0.505
+            ],
+            "angle": 0,
+            "content": "Note that since we investigate each panel independently, the above inference process promises that our model's output stays invariant if the answer set is shuffled."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.52,
+                0.519,
+                0.91,
+                0.536
+            ],
+            "angle": 0,
+            "content": "Attribute Bisection Tree for Impartial Dataset"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.538,
+                0.914,
+                0.678
+            ],
+            "angle": 0,
+            "content": "RAVEN (Zhang et al. 2019a) is a popular RPM-style dataset adopted by all recent studies (Zhang et al. 2019b; Zheng, Zha, and Wei 2019; Wang, Jamnik, and Lio 2020). However, we find severe defects in its answer sets, making RAVEN incompetence as a measurement of abstract reasoning. In this section, we first give a brief review of RAVEN, and then explain the defects with analysis and experiments. Finally we introduce a general algorithm to generate an impartial answer set for any attribute-based RPM question. Thus we fix the defects of RAVEN and propose an improved dataset."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.517,
+                0.689,
+                0.664,
+                0.704
+            ],
+            "angle": 0,
+            "content": "Defects of RAVEN"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.708,
+                0.913,
+                0.791
+            ],
+            "angle": 0,
+            "content": "RAVEN dataset consists of 70,000 RPM questions distributed in 7 different figure configurations. Panels are constructed with 5 attributes (Number, Position, Type, Size, Color). Each attribute is governed by one of 4 rules and takes a value from a predefined set. Rules are applied only row-wise in RAVEN."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.792,
+                0.914,
+                0.89
+            ],
+            "angle": 0,
+            "content": "After carefully examining the data in RAVEN, we find unexpected pattern among the eight multiple-choice panels. Each distractor in the answer set is generated by randomly modifying one attribute of the correct answer (see Figure 4(a)). As a consequence, the panel with the most common values for each attribute will be the correct answer. This means the correct answer can be found by simply scanning"
+        }
+    ],
+    [
+        {
+            "type": "image",
+            "bbox": [
+                0.088,
+                0.068,
+                0.473,
+                0.218
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.101,
+                0.23,
+                0.462,
+                0.246
+            ],
+            "angle": 0,
+            "content": "Figure 4: Comparison between RAVEN and I-RAVEN"
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.09,
+                0.269,
+                0.474,
+                0.346
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Model</td><td>RAVEN</td><td>I-RAVEN</td></tr><tr><td>ResNet (Zhang et al. 2019a)</td><td>53.4</td><td>40.3</td></tr><tr><td>CoPINet (Zhang et al. 2019b)</td><td>91.4</td><td>46.1</td></tr><tr><td>Context-blind ResNet</td><td>71.9</td><td>12.2</td></tr><tr><td>Context-blind CoPINet</td><td>94.2</td><td>14.2</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.15,
+                0.354,
+                0.414,
+                0.368
+            ],
+            "angle": 0,
+            "content": "Table 1: Test on RAVEN and I-RAVEN"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.407,
+                0.48,
+                0.533
+            ],
+            "angle": 0,
+            "content": "the answer set without considering the context images. An example is also shown on the right of Figure 4(a). Among the answer set, the most common Color and Type are black (1, 3, 4, 5, and 7) and pentagon (1, 2, 3, 4, 6, and 8). Besides, multiple-choice panel 1, 2, 5, 6, 7, and 8 are in the same Size. Therefore, multiple-choice panel 1, which is the panel with the most common attribute values, is inferred as (and indeed is) the correct answer, even without considering the context matrix."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.537,
+                0.48,
+                0.608
+            ],
+            "angle": 0,
+            "content": "Note that understanding of the context matrix is the cornerstone of RPM test. The RAVEN dataset, where the correct answer can be found without the context, is obviously against the essence of abstract reasoning, and thus is incapable of evaluating abstract reasoning ability."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.612,
+                0.481,
+                0.89
+            ],
+            "angle": 0,
+            "content": "More severely, such underlying patterns can also be captured by neural networks, especially for models which combine features of eight multiple-choice panels. We train two models with context-blind (Barrett et al. 2018) setting, including a simple ResNet-based classifier (Zhang et al. 2019a) and the competitive CoPINet (Zhang et al. 2019b). These context-blind models are trained with only eight multiple-choice panels as input, and should have predicted the answer randomly, if the dataset is logical. However, as shown in Table 1, the context-blind models can achieve even better performance to the normal models, which proves that RAVEN contains illogical patterns where the correct answer can be found when only presented with the answer set. This type of back-door solutions is quite hidden and has also been discussed in other relational reasoning benchmarks, such as Visual Question Answering (VQA) (Johnson et al. 2017) and symbolic analogy (Hill et al. 2019). We can conclude that the 'overfitting' phenomenon on RAVEN reported by (Wang, Jamnik, and Lio 2020) is not caused by a permutation-invariant structure but by the dataset itself."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.518,
+                0.069,
+                0.77,
+                0.083
+            ],
+            "angle": 0,
+            "content": "Algorithm 1 Attribute Bisection Tree"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.518,
+                0.088,
+                0.717,
+                0.102
+            ],
+            "angle": 0,
+            "content": "Input: the correct answer \\(\\omega^{*}\\)"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.528,
+                0.102,
+                0.776,
+                0.117
+            ],
+            "angle": 0,
+            "content": "1: Initialize the answer set \\(\\Omega = \\{\\omega^{*}\\}\\)"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.528,
+                0.117,
+                0.847,
+                0.13
+            ],
+            "angle": 0,
+            "content": "2: Sample 3 attributes \\(a_1, a_2, a_3\\) according to \\(\\omega^*\\)"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.528,
+                0.131,
+                0.76,
+                0.144
+            ],
+            "angle": 0,
+            "content": "3: Sample new value \\( v_{i} \\) for each \\( a_{i} \\)"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.528,
+                0.145,
+                0.661,
+                0.157
+            ],
+            "angle": 0,
+            "content": "4: for \\( i = 1 \\) to 3 do"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.528,
+                0.157,
+                0.675,
+                0.172
+            ],
+            "angle": 0,
+            "content": "5: Initialize \\(\\Gamma = \\{\\}\\)"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.528,
+                0.172,
+                0.845,
+                0.185
+            ],
+            "angle": 0,
+            "content": "6: for each \\(w_{k}\\) in the current answer set \\(\\Omega\\) do"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.528,
+                0.186,
+                0.85,
+                0.199
+            ],
+            "angle": 0,
+            "content": "7: \\(\\gamma \\gets\\) modifying attribute \\(a_{i}\\) of \\(\\omega_{k}\\) with \\(v_{i}\\)"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.528,
+                0.2,
+                0.669,
+                0.214
+            ],
+            "angle": 0,
+            "content": "8: \\(\\Gamma \\leftarrow \\Gamma \\bigcup \\{\\gamma \\}\\)"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.521,
+                0.214,
+                0.617,
+                0.226
+            ],
+            "angle": 0,
+            "content": "9: end for"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.521,
+                0.226,
+                0.644,
+                0.242
+            ],
+            "angle": 0,
+            "content": "10: \\(\\Omega \\gets \\Omega \\bigcup \\Gamma\\)"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.521,
+                0.242,
+                0.6,
+                0.253
+            ],
+            "angle": 0,
+            "content": "11: end for"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.521,
+                0.254,
+                0.797,
+                0.27
+            ],
+            "angle": 0,
+            "content": "Output: the answer set \\(\\Omega (|\\Omega | = 2^3 = 8)\\)"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.518,
+                0.3,
+                0.706,
+                0.314
+            ],
+            "angle": 0,
+            "content": "Attribute Bisection Tree"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.318,
+                0.913,
+                0.416
+            ],
+            "angle": 0,
+            "content": "We design a general algorithm named Attribute Bisection Tree (ABT) to generate an impartial answer set for any attribute-based RPM question. The ABT ensures attribute modifications among the answer set are well balanced. Thus, no clue can be found to guess the correct answer only depending on the answer set, and no distractor can be eliminated without reasoning from the context matrix as well."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.416,
+                0.914,
+                0.596
+            ],
+            "angle": 0,
+            "content": "Figure 4(b) demonstrates the generation process using a tree structure. Each node indicates a multiple-choice panel, and the root of the tree structure is the correct answer. Different levels indicate different iterations, where nodes of this level are the candidate answers of current answer set. The generation process flows in a top-down manner. For each iteration, only one attribute will be modified. At each level, a node has two children nodes, where one node remains the same with the father node, the other changes the value of the attribute sampled for this iteration of the father node. Finally, at the bottom level, we could obtain the whole answer set. Algorithm 1 summarizes the key steps of the answer generation process."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.518,
+                0.607,
+                0.597,
+                0.621
+            ],
+            "angle": 0,
+            "content": "I-RAVEN"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.626,
+                0.913,
+                0.696
+            ],
+            "angle": 0,
+            "content": "With ABT, we generate an alternative answer set for each RPM question in the RAVEN dataset, forming an improved dataset named Impartial-RAVEN (I-RAVEN). Next, we will show that compared with RAVEN, I-RAVEN is more rigorous and fair for evaluating abstract reasoning capability."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.695,
+                0.914,
+                0.861
+            ],
+            "angle": 0,
+            "content": "Taking Figure 4(b) for example, each attribute has two different values which distribute evenly in the answer set. The attribute Color of half answer candidates (1, 2, 4, and 7) are black, while the other half (3, 5, 6, and 8) are light grey. Similarly, the attribute Type of half answer candidates (1, 2, 6, and 8) are pentagon, while the other half (3, 4, 5, and 7) are circle. Half of the answer set (1, 3, 4, and 6) are in the same size, which are different from the other same-sized half (2, 5, 7, and 8). As a result, there is no candidate with the most common values for each attribute. In other words, the back-door solution on RAVEN can no longer be applied to the new answer set."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.517,
+                0.861,
+                0.913,
+                0.89
+            ],
+            "angle": 0,
+            "content": "To better explain the superiority of I-RAVEN over RAVEN, as shown in Figure 5, we use undirected graphs"
+        }
+    ],
+    [
+        {
+            "type": "table",
+            "bbox": [
+                0.144,
+                0.065,
+                0.855,
+                0.196
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Model</td><td>Acc</td><td>Center</td><td>2×2G</td><td>3×3G</td><td>O-IC</td><td>O-IG</td><td>L-R</td><td>U-D</td></tr><tr><td>LSTM (Zhang et al. 2019a)</td><td>18.9</td><td>26.2</td><td>16.7</td><td>15.1</td><td>21.9</td><td>21.1</td><td>14.6</td><td>16.5</td></tr><tr><td>WReN (Barrett et al. 2018)</td><td>23.8</td><td>29.4</td><td>26.8</td><td>23.5</td><td>22.5</td><td>21.5</td><td>21.9</td><td>21.4</td></tr><tr><td>ResNet (Zhang et al. 2019a)</td><td>40.3</td><td>44.7</td><td>29.3</td><td>27.9</td><td>46.2</td><td>35.8</td><td>51.2</td><td>47.4</td></tr><tr><td>ResNet+DRT (Zhang et al. 2019a)</td><td>40.4</td><td>46.5</td><td>28.8</td><td>27.3</td><td>46.0</td><td>34.2</td><td>50.1</td><td>49.8</td></tr><tr><td>LEN (Zheng, Zha, and Wei 2019)</td><td>41.4</td><td>56.4</td><td>31.7</td><td>29.7</td><td>52.1</td><td>31.7</td><td>44.2</td><td>44.2</td></tr><tr><td>Wild ResNet (Barrett et al. 2018)</td><td>44.3</td><td>50.9</td><td>33.1</td><td>30.8</td><td>50.9</td><td>38.7</td><td>53.1</td><td>52.6</td></tr><tr><td>CoPINet (Zhang et al. 2019b)</td><td>46.1</td><td>54.4</td><td>36.8</td><td>31.9</td><td>52.2</td><td>42.8</td><td>51.9</td><td>52.5</td></tr><tr><td>SRAN (Ours)</td><td>60.8</td><td>78.2</td><td>50.1</td><td>42.4</td><td>68.2</td><td>46.3</td><td>70.1</td><td>70.3</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.082,
+                0.205,
+                0.916,
+                0.248
+            ],
+            "angle": 0,
+            "content": "Table 2: Test accuracy of different models on I-RAVEN. Acc denotes the mean accuracy, while other columns show accuracy across seven figure configurations. \\(2 \\times 2\\mathrm{G}\\), \\(3 \\times 3\\mathrm{G}\\), O-IC, O-IG, L-R, and U-D denote \\(2 \\times 2\\mathrm{Grid}\\), \\(3 \\times 3\\mathrm{Grid}\\), Out-InCenter, Out-InGrid, Left-Right, and Up-Down, respectively"
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.165,
+                0.267,
+                0.835,
+                0.3
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Model</td><td>LSTM</td><td>ResNet</td><td>Wild ResNet</td><td>CoPINet</td><td>WReN</td><td>MXGNet</td><td>LEN</td><td>SRAN</td></tr><tr><td>Acc</td><td>35.8</td><td>42.0</td><td>48.0</td><td>56.4</td><td>62.6</td><td>66.7</td><td>68.1</td><td>71.3</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.329,
+                0.31,
+                0.668,
+                0.324
+            ],
+            "angle": 0,
+            "content": "Table 3: Test accuracy of different models on PGM"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.086,
+                0.392,
+                0.207,
+                0.406
+            ],
+            "angle": 0,
+            "content": "\\(\\bigcirc\\) Correct answer"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.086,
+                0.406,
+                0.174,
+                0.419
+            ],
+            "angle": 0,
+            "content": "\\(\\bigcirc\\) Distractor"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.086,
+                0.419,
+                0.25,
+                0.432
+            ],
+            "angle": 0,
+            "content": "Differ in one attribute"
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.086,
+                0.392,
+                0.25,
+                0.432
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.223,
+                0.399,
+                0.354,
+                0.478
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.244,
+                0.484,
+                0.327,
+                0.497
+            ],
+            "angle": 0,
+            "content": "(a) RAVEN"
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.366,
+                0.394,
+                0.48,
+                0.481
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.374,
+                0.484,
+                0.468,
+                0.497
+            ],
+            "angle": 0,
+            "content": "(b) I-RAVEN"
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.083,
+                0.509,
+                0.48,
+                0.539
+            ],
+            "angle": 0,
+            "content": "Figure 5: Characterizing answer sets of RAVEN and I-RAVEN using graphs"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.569,
+                0.48,
+                0.79
+            ],
+            "angle": 0,
+            "content": "to characterize typical answer sets of the two datasets respectively, where each candidate answer is represented by a node with its degree inflated. An edge between two nodes represents that the corresponding candidates differ in one attribute. In Figure 5(a), there is always a central node with a degree of 7 and the other nodes with less degrees. The back-door solution is to find the central node, which is indeed the correct answer. By contrast, in Figure 5(b), due to balanced modifications of attributes, each node always has the same degree of 3, which is indistinguishable from each other without the context matrix. Moreover, inspired by (Hill et al. 2019), we make the noise attribute Uniformity of each distractor stay consistent with the correct answer, so that each distractor is perceptually plausible and cannot be eliminated simply by attribute mismatching. This setting encourages models to reason from the context."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.791,
+                0.48,
+                0.89
+            ],
+            "angle": 0,
+            "content": "We also train ResNet and CoPINet on I-RAVEN alongside with their context-blind versions to verify the fairness of the proposed dataset. The right column in Table 1 lists the results which are in stark contrast with those on the original RAVEN dataset. The performance of context-blind models is almost at a random guess level (12.5%), while the normal models relying on the context can perform much better."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.66,
+                0.356,
+                0.771,
+                0.374
+            ],
+            "angle": 0,
+            "content": "Experiments"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.517,
+                0.377,
+                0.676,
+                0.394
+            ],
+            "angle": 0,
+            "content": "Experimental Setup"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.397,
+                0.915,
+                0.55
+            ],
+            "angle": 0,
+            "content": "With I-RAVEN, we first compare our method with several state-of-the-art models using public implementations, including LSTM (Hochreiter and Schmidhuber 1997), ResNet-based (He et al. 2016) image classifier (ResNet), ResNet with DRT (Zhang et al. 2019a), Wild ResNet (Barrett et al. 2018), WReN (Barrett et al. 2018), CoPINet (Zhang et al. 2019b), and LEN (Zheng, Zha, and Wei 2019). We adopt the public implementations of LSTM, ResNet, and DRT in (Zhang et al. 2019a). Other variants of LEN are not included in this section because they require additional training labels."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.55,
+                0.913,
+                0.634
+            ],
+            "angle": 0,
+            "content": "PGM (Barrett et al. 2018) is another RPM dataset consisting of 1.42M questions. Rules in a matrix are composed with 1 to 4 relation-object-attribute tuples and can be applied along the rows or columns. SRAN is compared with results on PGM reported in (Barrett et al. 2018; Zhang et al. 2019b; Zheng, Zha, and Wei 2019; Wang, Jamnik, and Lio 2020)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.634,
+                0.913,
+                0.772
+            ],
+            "angle": 0,
+            "content": "For our SRAN, we adopt three ResNet-18 (He et al. 2016) as the embedding networks for the three hierarchies, by modifying the input channels. The gate fusion \\(\\varphi_{1}\\) and \\(\\varphi_{2}\\) are 2-layer fully connected networks, while \\(\\varphi_{3}\\) is a 4-layer fully connected network with dropout (Srivastava et al. 2014) of 0.5 applied on the last layer. We adopt stochastic gradient descent using ADAM (Kingma and Ba 2014) optimizer. The exponential decay rate parameters are \\(\\beta_{1} = 0.9\\), \\(\\beta_{2} = 0.999\\), \\(\\epsilon = 10^{-8}\\). Each reported accuracy is averaged over 5 runs."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.517,
+                0.786,
+                0.856,
+                0.801
+            ],
+            "angle": 0,
+            "content": "Comparisons with State-of-the-art Methods"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.805,
+                0.913,
+                0.889
+            ],
+            "angle": 0,
+            "content": "Table 2 and Table 3 list the test accuracy of different models trained on I-RAVEN and PGM, respectively. From the table, it is obvious that our proposed SRAN outperforms other methods by a considerable margin. Besides, we observe that models benefit from inductive biases, such as the competitive CoPINet, LEN, Wild ResNet, and our SRAN. Such in-"
+        }
+    ],
+    [
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.069,
+                0.48,
+                0.194
+            ],
+            "angle": 0,
+            "content": "ductive biases (even partly) can encourage models to explore the underlying rules. For more detailed comparison, Table 2 also reports the accuracy on seven figure configurations of I-RAVEN. We can observe that accuracy on different configurations is not uniform, possibly due to the difficulty of configurations. But compared with other models, our SRAN consistently achieves the best performance on all the configurations, which proves that our model can work stably, even facing diverse conditions and complex rules."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.194,
+                0.481,
+                0.263
+            ],
+            "angle": 0,
+            "content": "We observe that the accuracy of SRAN on I-RAVEN is very close to that on the original RAVEN dataset (60.8% vs. 60.7%). This phenomenon is as expected since our method mainly focuses on rules in the context, and thus is robust to the answer set."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.084,
+                0.274,
+                0.205,
+                0.289
+            ],
+            "angle": 0,
+            "content": "Ablation Study"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.29,
+                0.48,
+                0.346
+            ],
+            "angle": 0,
+            "content": "As aforementioned, our method mainly gains from the inductive-biased architecture. To validate this point, we study the effects of different components in our SRAN. Table 4 lists the results."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.346,
+                0.48,
+                0.512
+            ],
+            "angle": 0,
+            "content": "We analyze the stratified strategy to incrementally induce rules, using the performance of different choices of hierarchies. Specifically, we set the rule embedding of certain hierarchy as a zero vector before gate function \\(\\varphi\\). Thus, the gate function regulates the flow of features into the gated embedding fusion module. We observe that combing more hierarchies always leads to better performance on I-RAVEN, which shows all hierarchies contribute to our framework. We make \\(\\mathbb{E}_{\\mathrm{cell}}\\) orderless by summing all cell-wise embeddings and observe a major drop in performance. These observations prove the effectiveness of the proposed inductive biases of order sensitivity and incremental rule induction."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.512,
+                0.48,
+                0.638
+            ],
+            "angle": 0,
+            "content": "We further discover that the effectiveness of our model can be put down to its attention to different attributes. We conduct experiments only utilizing single-hierarchy rule embeddings from \\(\\mathbb{E}_{\\mathrm{cell}}\\), \\(\\mathbb{E}_{\\mathrm{ind}}\\), \\(\\mathbb{E}_{\\mathrm{eco}}\\), with respect to three attributes (Type, Size, and Color) of I-RAVEN. As shown in Figure 6, \\(\\mathbb{E}_{\\mathrm{cell}}\\) has strong capacity to infer attributes Type and Size, but struggles to distinguish attribute Color. By contrast, \\(\\mathbb{E}_{\\mathrm{ind}}\\) and \\(\\mathbb{E}_{\\mathrm{eco}}\\) have modest ability to infer attributes Type and Size, and are efficient for attribute Color."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.084,
+                0.647,
+                0.365,
+                0.663
+            ],
+            "angle": 0,
+            "content": "The Advantage of Rule Embeddings"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.664,
+                0.481,
+                0.831
+            ],
+            "angle": 0,
+            "content": "In the real RPM test, it is not clear whether the rule exists in rows or columns. Therefore, it is important to check whether the proposed model can discover the knowledge without any guidance. Rule induction for columns is normally left out when trained on I-RAVEN, given the prior knowledge that rules are applied only row-wise. In order to test the ability of distinguishing whether the rules are applied along rows or columns, we train a SRAN model on I-RAVEN which the induction for column rules is reintegrated into. As a result, there is only a bit drop in accuracy (from \\(60.8\\%\\) to \\(59.6\\%\\)). This indicates that our model can neglect the distraction brought by columns on its own."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.232,
+                0.844,
+                0.331,
+                0.858
+            ],
+            "angle": 0,
+            "content": "Conclusion"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.082,
+                0.861,
+                0.481,
+                0.89
+            ],
+            "angle": 0,
+            "content": "In this paper, we introduced necessary inductive biases for abstract visual reasoning task, such as order sensitivity and"
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.602,
+                0.065,
+                0.83,
+                0.196
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Model</td><td>I-RAVEN</td></tr><tr><td>Ecell (orderless)</td><td>23.5</td></tr><tr><td>Ecell</td><td>36.7</td></tr><tr><td>Eind</td><td>48.7</td></tr><tr><td>Eeco</td><td>51.6</td></tr><tr><td>Ecell + Eeco</td><td>52.9</td></tr><tr><td>Eind + Eeco</td><td>57.0</td></tr><tr><td>Ecell + Eind</td><td>57.8</td></tr><tr><td>Ecell + Eind + Eeco</td><td>60.8</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.516,
+                0.204,
+                0.914,
+                0.234
+            ],
+            "angle": 0,
+            "content": "Table 4: SRAN \\((\\mathbb{E}_{\\mathrm{cell}} + \\mathbb{E}_{\\mathrm{ind}} + \\mathbb{E}_{\\mathrm{eco}})\\) and the results of eliminating different components"
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.529,
+                0.254,
+                0.875,
+                0.435
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.516,
+                0.456,
+                0.913,
+                0.484
+            ],
+            "angle": 0,
+            "content": "Figure 6: Accuracy of single hierarchy with respect to the different attributes"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.515,
+                0.517,
+                0.914,
+                0.741
+            ],
+            "angle": 0,
+            "content": "incremental rule induction. We further proposed a novel Stratified Rule-Aware Network, which could extract multiple granularity rule embeddings at different level and integrate them through a gated embedding fusion module. A rule similarity metric was further introduced based on the embeddings, so that SRAN can not only be trained using a tuple loss but also infer the best answer according to the similarity score. We also designed an algorithm named Attribute Bisection Tree to fix the defects of the popular dataset RAVEN, and generated a more rigorous dataset based on the algorithm. Extensive experiments conducted on PGM dataset and our improved dataset I-RAVEN proved that, our proposed framework could significantly outperform other state-of-the-art approaches. Moreover, we studied the effects of each component of our proposed model and evaluated the advantage of our induced rule embeddings."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.637,
+                0.763,
+                0.796,
+                0.78
+            ],
+            "angle": 0,
+            "content": "Acknowledgments"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.516,
+                0.791,
+                0.914,
+                0.889
+            ],
+            "angle": 0,
+            "content": "This work was supported by National Natural Science Foundation of China (62022009, 61872021), Beijing Nova Program of Science and Technology (Z191100001119050), State Key Lab of Software Development Environment (SKLSDE-2020ZX-06), Fundamental Research Funds for Central Universities (YWF-20-BJ-J-646), and the Academic Excellence Foundation of BUAA for PhD Students."
+        }
+    ],
+    [
+        {
+            "type": "title",
+            "bbox": [
+                0.235,
+                0.068,
+                0.331,
+                0.083
+            ],
+            "angle": 0,
+            "content": "References"
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.088,
+                0.48,
+                0.144
+            ],
+            "angle": 0,
+            "content": "Barrett, D.; Hill, F.; Santoro, A.; Morcos, A.; and Lillicrap, T. 2018. Measuring abstract reasoning in neural networks. In Proceedings of International Conference on Machine Learning (ICML), 511-520."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.149,
+                0.48,
+                0.205
+            ],
+            "angle": 0,
+            "content": "Carpenter, P. A.; Just, M. A.; and Shell, P. 1990. What One Intelligence Test Measures: A Theoretical Account of the Processing in the Raven Progressive Matrices Test. Psychological Review 97(3): 404-431."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.21,
+                0.48,
+                0.267
+            ],
+            "angle": 0,
+            "content": "He, K.; Zhang, X.; Ren, S.; and Sun, J. 2016. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 770-778."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.271,
+                0.48,
+                0.327
+            ],
+            "angle": 0,
+            "content": "Hill, F.; Santoro, A.; Barrett, D.; Morcos, A.; and Lillicrap, T. 2019. Learning to Make Analogies by Contrasting Abstract Relational Structure. In International Conference on Learning Representations (ICLR)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.332,
+                0.48,
+                0.362
+            ],
+            "angle": 0,
+            "content": "Hochreiter, S.; and Schmidhuber, J. 1997. Long short-term memory. Neural computation 9(8): 1735-1780."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.366,
+                0.48,
+                0.395
+            ],
+            "angle": 0,
+            "content": "Hoshen, D.; and Werman, M. 2017. Iq of neural networks. arXiv preprint arXiv:1710.01692."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.4,
+                0.48,
+                0.482
+            ],
+            "angle": 0,
+            "content": "Johnson, J.; Hariharan, B.; van der Maaten, L.; Fei-Fei, L.; Lawrence Zitnick, C.; and Girshick, R. 2017. Clevr: A diagnostic dataset for compositional language and elementary visual reasoning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2901–2910."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.488,
+                0.48,
+                0.531
+            ],
+            "angle": 0,
+            "content": "Kingma, D. P.; and Ba, J. 2014. Adam: A method for stochastic optimization. International Conference on Learning Representations (ICLR)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.535,
+                0.48,
+                0.592
+            ],
+            "angle": 0,
+            "content": "Krizhevsky, A.; Sutskever, I.; and Hinton, G. E. 2012. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems (NeurIPS), 1097-1105."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.597,
+                0.48,
+                0.653
+            ],
+            "angle": 0,
+            "content": "Kunda, M.; McGregor, K.; and Goel, A. K. 2013. A computational model for solving problems from the Raven's Progressive Matrices intelligence test using iconic visual representations. Cognitive Systems Research 22: 47-66."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.658,
+                0.48,
+                0.7
+            ],
+            "angle": 0,
+            "content": "Lovett, A.; and Forbus, K. 2017. Modeling visual problem solving as analogical reasoning. *Psychological Review* 124(1): 60-90."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.705,
+                0.48,
+                0.761
+            ],
+            "angle": 0,
+            "content": "Lovett, A.; Forbus, K.; and Usher, J. 2010. A structure-mapping model of Raven's Progressive Matrices. In Proceedings of the Annual Meeting of the Cognitive Science Society, volume 32."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.766,
+                0.48,
+                0.809
+            ],
+            "angle": 0,
+            "content": "Lovett, A.; Tomai, E.; Forbus, K.; and Usher, J. 2010. Solving Geometric Analogy Problems Through Two-Stage Analogical Mapping. Cognitive Science 33(7): 1192-1231."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.814,
+                0.48,
+                0.842
+            ],
+            "angle": 0,
+            "content": "Parent, E. 1996. The living systems theory of James Grier Miller. Retrieved November 29: 2007."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.085,
+                0.847,
+                0.48,
+                0.889
+            ],
+            "angle": 0,
+            "content": "Raven, J. 2000. The Raven's progressive matrices: change and stability over culture and time. Cognitive psychology 41(1): 1-48."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.085,
+                0.088,
+                0.48,
+                0.889
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.518,
+                0.069,
+                0.912,
+                0.098
+            ],
+            "angle": 0,
+            "content": "Raven, J. C. 1938. Raven's progressive matrices. Western Psychological Services."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.518,
+                0.102,
+                0.912,
+                0.145
+            ],
+            "angle": 0,
+            "content": "Simonyan, K.; and Zisserman, A. 2015. Very deep convolutional networks for large-scale image recognition. In International Conference on Learning Representations (ICLR)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.518,
+                0.149,
+                0.912,
+                0.191
+            ],
+            "angle": 0,
+            "content": "Sohn, K. 2016. Improved deep metric learning with multiclass n-pair loss objective. In Advances in Neural Information Processing Systems (NeurIPS), 1857-1865."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.518,
+                0.195,
+                0.913,
+                0.251
+            ],
+            "angle": 0,
+            "content": "Srivastava, N.; Hinton, G.; Krizhevsky, A.; Sutskever, I.; and Salakhutdinov, R. 2014. Dropout: a simple way to prevent neural networks from overfitting. The journal of machine learning research 15(1): 1929-1958."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.518,
+                0.255,
+                0.913,
+                0.311
+            ],
+            "angle": 0,
+            "content": "Steenbrugge, X.; Leroux, S.; Verbelen, T.; and Dhoedt, B. 2018. Improving generalization for abstract reasoning tasks using disentangled feature representations. arXiv preprint arXiv:1811.04784."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.518,
+                0.316,
+                0.913,
+                0.358
+            ],
+            "angle": 0,
+            "content": "Strannegård, C.; Cirillo, S.; and Ström, V. 2013. An anthropomorphic method for progressive matrix problems. Cognitive Systems Research 22: 35-46."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.518,
+                0.362,
+                0.913,
+                0.432
+            ],
+            "angle": 0,
+            "content": "Szegedy, C.; Liu, W.; Jia, Y.; Sermanet, P.; Reed, S.; Anguelov, D.; Erhan, D.; Vanhoucke, V.; and Rabinovich, A. 2015. Going deeper with convolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 1-9."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.518,
+                0.436,
+                0.913,
+                0.493
+            ],
+            "angle": 0,
+            "content": "van Steenkiste, S.; Locatello, F.; Schmidhuber, J.; and Bachem, O. 2019. Are Disentangled Representations Helpful for Abstract Visual Reasoning? In Advances in Neural Information Processing Systems (NeurIPS), 14222-14235."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.518,
+                0.497,
+                0.913,
+                0.54
+            ],
+            "angle": 0,
+            "content": "Wang, D.; Jamnik, M.; and Lio, P. 2020. Abstract diagrammatic reasoning with multiplex graph networks. In International Conference on Learning Representations (ICLR)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.518,
+                0.543,
+                0.913,
+                0.6
+            ],
+            "angle": 0,
+            "content": "Zhang, C.; Gao, F.; Jia, B.; Zhu, Y.; and Zhu, S.-C. 2019a. RAVEN: A dataset for relational and analogical visual reasoning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 5317-5327."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.518,
+                0.604,
+                0.913,
+                0.659
+            ],
+            "angle": 0,
+            "content": "Zhang, C.; Jia, B.; Gao, F.; Zhu, Y.; Lu, H.; and Zhu, S.-C. 2019b. Learning perceptual inference by contrasting. In Advances in Neural Information Processing Systems (NeurIPS), 1073-1085."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.518,
+                0.664,
+                0.913,
+                0.707
+            ],
+            "angle": 0,
+            "content": "Zheng, K.; Zha, Z.-J.; and Wei, W. 2019. Abstract Reasoning with Distracting Features. In Advances in Neural Information Processing Systems (NeurIPS), 5834-5845."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.518,
+                0.069,
+                0.913,
+                0.707
+            ],
+            "angle": 0,
+            "content": null
+        }
+    ]
+]

2002.06xxx/2002.06838/b5f48312-e0e5-4d14-b736-57b539ada670_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41cc911cc0d4c761836519b1bccb65a2d158333809f6d0e27e5285fea2514b3c
+size 705829

2002.06xxx/2002.06838/full.md

@@ -0,0 +1,326 @@
+# Stratified Rule-Aware Network for Abstract Visual Reasoning
+
+Sheng Hu, $^{1,*}$  Yuqing Ma, $^{1,*}$  Xianglong Liu, $^{1,2,\dagger}$  Yanlu Wei, $^{1}$  Shihao Bai $^{1}$
+
+$^{1}$  State Key Laboratory of Software Development Environment, Beihang University, Beijing, China  
+ $^{2}$  Beijing Advanced Innovation Center for Big Data-Based Precision Medicine, Beihang University, Beijing, China  
+husheng_7@163.com, {mayuqing,xliiu} @nlsde.buaa.edu.cn, {weiyanlu,16061167} @buaa.edu.cn
+
+# Abstract
+
+Abstract reasoning refers to the ability to analyze information, discover rules at an intangible level, and solve problems in innovative ways. Raven's Progressive Matrices (RPM) test is typically used to examine the capability of abstract reasoning. The subject is asked to identify the correct choice from the answer set to fill the missing panel at the bottom right of RPM (e.g., a  $3 \times 3$  matrix), following the underlying rules inside the matrix. Recent studies, taking advantage of Convolutional Neural Networks (CNNs), have achieved encouraging progress to accomplish the RPM test. However, they partly ignore necessary inductive biases of RPM solver, such as order sensitivity within each row/column and incremental rule induction. To address this problem, in this paper we propose a Stratified Rule-Aware Network (SRAN) to generate the rule embeddings for two input sequences. Our SRAN learns multiple granularity rule embeddings at different levels, and incrementally integrates the stratified embedding flows through a gated fusion module. With the help of embeddings, a rule similarity metric is applied to guarantee that SRAN can not only be trained using a tuplet loss but also infer the best answer efficiently. We further point out the severe defects existing in the popular RAVEN dataset for RPM test, which prevent from the fair evaluation of the abstract reasoning ability. To fix the defects, we propose an answer set generation algorithm called Attribute Bisection Tree (ABT), forming an improved dataset named Impartial-RAVEN (I-RAVEN for short). Extensive experiments are conducted on both PGM and I-RAVEN datasets, showing that our SRAN outperforms the state-of-the-art models by a considerable margin.
+
+# Introduction
+
+Abstract reasoning, also known as inductive reasoning, refers to the ability to analyze information, discover rules at an intangible level, and solve problems in innovative ways. This type of reasoning, as the foundation for human intelligence, helps human understand the world. It has been generally regarded and pursued as a critical component to the development of artificial intelligence during the past decades, and has attracted increasing attention in recent years. Raven's Progressive Matrices (RPM) test (Raven
+
+![](images/ae408d6ef1f8c8019f9d5be524ddfcb43caacd4d75ea7c4619761711e6f2e526.jpg)  
+Figure 1: An example of RPM question and the human strategy to solve it. The underlying rule on the number of circles could be Progression (2-1=3-2) or Arithmetic (1+2=3) along row 1, and Arithmetic (2+3=5) along row 2. Therefore the dominant rule is Arithmetic. Apply it to the third row to figure out the answer  $(2+2=4)$ . Besides, no viable rule can be found along the columns
+
+1938; Carpenter, Just, and Shell 1990; Raven 2000; Kunda, McGregor, and Goel 2013; Strannegård, Cirillo, and Ström 2013) is one of the highly accepted and well-studied tools to examine the ability of abstract reasoning, which is believed as a good estimate of the real intelligence (Carpenter, Just, and Shell 1990). An illustration of RPM is shown in Figure 1, where usually the test-taker is presented with a  $3 \times 3$  matrix with the bottom right panel left blank. The goal is to choose one image from an answer set of eight candidates to complete the matrix correctly, namely satisfying the underlying rules in the matrix. Subjects accomplish this by looking into the first two rows/columns and inducing the dominant rules which govern the attributes in those panels. The obtained rules can then be applied to the last row/column to figure out which answer belongs to the blank panel.
+
+Computational models for RPM in the cognitive science community access symbolic representations of the images (Carpenter, Just, and Shell 1990; Lovett and Forbus 2017; Lovett, Forbus, and Usher 2010; Lovett et al. 2010). Recently there has been some success with end-to-end learning methods trying to accomplish abstract reasoning on
+
+RPM test (Hoshen and Werman 2017; Barrett et al. 2018; Steenbrugge et al. 2018; Zhang et al. 2019a,b; Zheng, Zha, and Wei 2019; van Steenkiste et al. 2019; Wang, Jamnik, and Lio 2020), inspired by the progress of computer vision tasks (Krizhevsky, Sutskever, and Hinton 2012; Simonyan and Zisserman 2015; Szegedy et al. 2015; He et al. 2016) and boosted by the large-scale PGM (Barrett et al. 2018) and RAVEN (Zhang et al. 2019a) datasets. Typical works including CoPINet (Zhang et al. 2019a), LEN (Zheng, Zha, and Wei 2019), and MXGNet (Wang, Jamnik, and Lio 2020) followed the paradigm that predicts a classification score for each multiple-choice panel based on the relations inside each row/column, showing great potential to solve RPM test. However, these models partly ignore the important characteristics for RPM, such as the permutation invariance (Zhang et al. 2019b), the order sensitivity of panels inside a row/column, etc. Previous work (Wang, Jamnik, and Lio 2020) specially mentions that they do not choose a permutation-invariant structure because it leads to severe 'overfitting' on the RAVEN dataset. We will discuss this phenomenon in later sections. What is even worse, directly extracting the relations, without considering the incremental rule induction mechanism widely adopted in human cognitive systems (Carpenter, Just, and Shell 1990), inevitably leads to inferior performance.
+
+To achieve reliable and efficient abstract reasoning, in this paper we develop a powerful architecture called Stratified Rule-Aware Network (SRAN) that naturally integrates the indispensable inductive biases, including order sensitivity, permutation invariance, and incremental rule induction. SRAN takes two rows/columns as input and learns stratified rule embeddings at different levels, namely cell-wise, individual-wise, and ecological hierarchy. These multiple granularity embeddings are incrementally integrated via a gate fusion module, which naturally preserves the order sensitivity of panels and maps the inputs to a rule embedding space. With the help of the embeddings, we further introduce a rule similarity metric, based on which SRAN can not only be well trained using a tuplet loss but also infer the best answer efficiently. This framework resembles the human strategy for RPM shown in Figure 1.
+
+To fairly evaluate the abstract reasoning ability, we also design a general algorithm named Attribute Bisection Tree (ABT) to generate an impartial answer set for any attribute-based RPM question. We point out and further fix the underlying defects of the commonly-used RAVEN (Zhang et al. 2019a) dataset, where the correct answer could be inferred even without the presence of the context matrix. Therefore, we introduce an improved dataset named Impartial-RAVEN (I-RAVEN) to fairly evaluate the abstract reasoning capability of RPM solvers.
+
+To the best of our knowledge, the proposed SRAN is the first RPM solver to induce rule embeddings which are discriminative and measurable. We are also the first to point out and fix the defects of the misleading benchmark RAVEN, and generate an impartial dataset I-RAVEN based on our ABT algorithm. Extensive experiments conducted on widely used dataset PGM and our improved I-RAVEN show that SRAN outperforms state-of-the-art methods by a consider-
+
+able margin, e.g.  $60.8\%$  accuracy compared to the second best  $46.1\%$  on I-RAVEN.
+
+# Our Approach
+
+In this section, we first give a formal definition of the abstract reasoning task on the RPM test. Then we introduce the inductive-biased framework, and present our Stratified Rule-Aware Network (SRAN). Finally, we demonstrate the learning and inference process of the proposed model.
+
+# Preliminary
+
+For a common RPM question, usually a  $3 \times 3$  matrix  $\mathbf{M}^{-}$  is given, with bottom right context panel left blank.  $\Omega$  denotes the answer set with  $N$  multiple-choice panels, where typically  $N = 8$ . The dominant rules governing the features inside the matrix could be induced from the first two intact rows/columns. The goal is to select a multiple-choice panel  $\omega \in \Omega$  to complete the context matrix  $\mathbf{M}^{-}$ , maintaining the dominant rule inside of the context matrix.
+
+We define the completed matrix with a multiple-choice panel  $\omega$  filled as  $\mathbf{M}$ , where  $\mathbf{M}_i$  is denoted as the  $i$ -th row, and  $\mathbf{m}_{ij}$  indicates the panel in  $i$ -th row and  $j$ -th column. Intuitively,  $\mathbf{M}$  is almost the same as  $\mathbf{M}^{-}$ , except for  $\mathbf{m}_{33} = \omega$  while the corresponding element missing in  $\mathbf{M}^{-}$ . In fact, whether rules exist in rows or columns is uncertain. Therefore, our framework induces both the row-wise rule representation and the column-wise representation in the same way. In order to simplify the notation, we only take the induction of the row-wise rule representation as example.
+
+# The Reasoning Framework
+
+Based on the necessary inductive biases for RPM, we develop a novel abstract reasoning architecture named Stratified Rule-Aware Network (SRAN). Given two input rows  $\mathbf{M}_i,\mathbf{M}_j$ , the proposed framework embeds the input into multiple granularity embeddings using a stratified rule embedding module  $\mathbb{E}$ . Named after biological organizations (Parent 1996),  $\mathbb{E}$  consists of three hierarchies including cell-wise network  $\mathbb{E}_{\mathrm{cell}}$ , individual-wise network  $\mathbb{E}_{\mathrm{ind}}$ , and ecological network  $\mathbb{E}_{\mathrm{eco}}$ . With the multiple granularity rule embeddings, the gated embedding fusion module  $\mathbb{G}$  will incrementally integrate these stratified embedding flows and map the two input sequences  $\mathbf{M}_i$  and  $\mathbf{M}_j$  to a discriminative rule embedding  $\mathbf{r}_{ij}^{(3)}$ , while maintaining the order sensitivity and permutation invariance. We further introduce a rule similarity metric  $\mathcal{D}$  to estimate the similarity between the rule representations. The correct answer can be predicted by choosing the multiple-choice panel within the shortest distance to the dominant rule generated by the first two rows in the matrix.
+
+# Stratified Rule Embedding
+
+As we all know, organization of behaviour into a nested hierarchy of tasks is characteristic of purposive cognition in humans. The prevalent Convolution Neural Network inspired by the human visual system, is a stratified model itself, with the projection from each layer showing the hierarchical nature of features. The bottom layers extract low-level features,
+
+such as texture, edge, etc, while the top layers abstract high-level semantic information from the low-level information transmitted from the bottom layers.
+
+However, without specifying information from different levels, it is hard for CNN to figure out different hierarchies, and thus fail to obtain robust and discriminative representations. Therefore, it would be better to feed the input of different hierarchies explicitly and extract rule representations from different granularity with artificial guidance. Motivated by that, we deploy a stratified rule embedding module, consisting of cell-wise hierarchy, individual-wise hierarchy, and ecological hierarchy.
+
+Cell-wise Hierarchy The network of the cell-wise hierarchy  $\mathbb{E}_{\mathrm{cell}}$  takes each panel as input and recognize the attributes of inside graphical elements. It handles each panel independently without considering the difference or correlations among panels inside the matrix. Therefore, it observes the information from the most detailed perspective. We obtain the cell-wise rule representation for each input panel:
+
+$$
+\mathbf {x} _ {i j} = \mathbb {E} _ {\text {c e l l}} (\mathbf {m} _ {i j}). \tag {1}
+$$
+
+Individual-wise Hierarchy Moreover, the network of individual hierarchy takes each row as input. It begins to take the correlations among panels of the same row into consideration, and encode the entire row with a compact embedding, rather than simply combining each panel. In this way, the rule embedding process for each panel is coupled and interacts with each other. Intuitively, each row may contain multiple plausible rules. In this hierarchy, the framework extracts intermediate rule embedding for each row individually, which still ignores the comprehensive information from the matrix perspective, especially the correlations across rows. The individual-wise rule embedding  $\mathbf{y}_i$  is denoted as:
+
+$$
+\mathbf {y} _ {i} = \mathbb {E} _ {\text {i n d}} \left(\mathbf {M} _ {i}\right). \tag {2}
+$$
+
+Ecological Hierarchy Furthermore, the network of the ecological hierarchy takes the two rows together as input and jointly learns the rule patterns underlying the two rows. As we mentioned before, in the individual hierarchy, the framework extracts intermediate rule embedding for each row, without considering the interaction between two rows. The rule that exists in one row may not lie in another. Therefore, to obtain the shared rule patterns between the two rows, it is essential to put these two rows together and jointly learn the features from an ecological level. Thus the shared rule embedding is obtained as follows:
+
+$$
+\mathbf {z} _ {i j} = \mathbb {E} _ {\mathrm {e c o}} ([ \mathbf {M} _ {i}, \mathbf {M} _ {j} ]), \tag {3}
+$$
+
+where  $[\cdot ,\cdot ]$  denotes the concatenating operation.
+
+# Gated Embedding Fusion
+
+Since the rule embeddings at different levels focus on different attributes or patterns, to generate one discriminative representation for the rule, we should aggregate the multiple granularity embeddings. Due to the requirement that the aggregation should preserve the order of cell-wise rule embeddings and be permutation-invariant to the individual-wise ones, we propose a stratified rule embedding learning
+
+![](images/358d2cf7a476f3699d453f0e12c56f09476f3faec58c0bf8e04017f8c67dd619.jpg)  
+Figure 2: The architecture of SRAN, consisting of a hierarchical rule embedding module and a gated embedding fusion module. Given two row sequences as input, it outputs the rule embedding
+
+method named gated embedding fusion module, which is responsible for gradually aggregating the multiple granularity embeddings.
+
+Specifically, we define a gate function  $\varphi$  to fuse the rule embeddings from different hierarchies. It concatenates all the inputs and encodes into a single embedding using fully connected layers. The gate function is similar to the attention mechanism, which detects and concentrates on the useful features according to the task. Even for the same attribute, they may focus on different facets. Based on the gate function, our gated embedding fusion module could regulate the flow of rule embeddings into the framework and make the utmost of their complementary information.
+
+At the cell level, after obtaining cell-wise rule embeddings for panels in  $i$ -th row  $\mathbf{M}_i$ , the module aggregates them to infer a row-wise rule embedding  $\mathbf{r}_i^{(1)}$ :
+
+$$
+\mathbf {r} _ {i} ^ {(1)} = \varphi_ {1} \left(\mathbf {x} _ {i 1}, \mathbf {x} _ {i 2}, \mathbf {x} _ {i 3}\right), \tag {4}
+$$
+
+Similarly, we obtain  $\mathbf{r}_j^{(1)}$  for the  $j$ -th row  $\mathbf{M}_j$ . The fused embedding integrates different types of attributes in the panels.
+
+At the individual level, intuitively both  $\mathbf{r}_i^{(1)}$  and  $\mathbf{y}_i$  are the row-wise embeddings corresponding to the  $i$ -th row, but convey the different granularity rule information. We further fuse them, and jointly mine the shared rules contained in the  $i$ -th and  $j$ -th row:
+
+$$
+\mathbf {r} _ {i j} ^ {(2)} = \varphi_ {2} \left(\mathbf {r} _ {i} ^ {(1)}, \mathbf {y} _ {i}, \mathbf {r} _ {j} ^ {(1)}, \mathbf {y} _ {j}\right). \tag {5}
+$$
+
+At the ecological level, similarly we can further combine fused embedding  $\mathbf{r}_{ij}^{(2)}$  and  $\mathbf{z}_{ij}$  using the gate fusion function, abstracting the final rule embedding:
+
+$$
+\mathbf {r} _ {i j} ^ {(3)} = \varphi_ {3} \left(\mathbf {r} _ {i j} ^ {(2)}, \mathbf {z} _ {i j}\right). \tag {6}
+$$
+
+To make sure the framework is permutation-invariant to the input rows, we exchange the concatenation order of the two input rows and average the output rule embeddings. This invariance ensures that, the rule embedding respects the characteristic of RPM and thus distills the representative information of the relations existing in the inputs.
+
+On the whole, the SRAN can be formulated in its simplest form as follows:
+
+$$
+\begin{array}{l} \mathbf {r} _ {i j} ^ {(3)} = \operatorname {S R A N} \left(\mathbf {M} _ {i}, \mathbf {M} _ {j}\right) \tag {7} \\ = \mathbb {G} \left(\mathbf {x} _ {i}, \mathbf {x} _ {j}, \mathbf {y} _ {i}, \mathbf {y} _ {j}, \mathbf {z} _ {i j}\right), \\ \end{array}
+$$
+
+where  $\mathbf{r}_{ij}^{(3)}$  is the shared rule embedding of the  $\mathbf{M}_i$  and  $\mathbf{M}_j$ . An illustration of SRAN is shown in Figure 2.
+
+# Learning and Inference
+
+With SRAN framework, the question turns to how we train the network, and apply it to infer the correct answer to RPM test. The key to address the question lies in the similarity measure between two rule embeddings, based on which we can define the loss function for SRAN training, and meanwhile determine the best choice during inference.
+
+Similarity function We introduce similarity function  $\mathcal{D}$  to measure the closeness between two rules in the embedding space. In this paper, we adopt inner product similarity for good experimental results:
+
+$$
+\mathcal {D} \left(\mathbf {r}, \mathbf {r} ^ {\prime}\right) = \mathbf {r} ^ {\mathrm {T}} \mathbf {r} ^ {\prime}. \tag {8}
+$$
+
+Training For a given RPM question, the first two rows  $\mathbf{M}_1, \mathbf{M}_2$  are fed into our proposed SRAN and produce the shared rule embedding  $\mathbf{g}$ :
+
+$$
+\mathbf {g} = \mathbf {r} _ {1 2} ^ {(3)} = \operatorname {S R A N} \left(\mathbf {M} _ {1}, \mathbf {M} _ {2}\right), \tag {9}
+$$
+
+which represents the dominant pattern of the matrix.
+
+Intuitively, the rule extracted from the first two rows can be treated as the reference rule, and we name it the dominant rule in the matrix. Subsequently, the correct answer can be found by checking whether its corresponding rule embedding is similar to the dominant rule. Specifically, given a multiple-choice panel  $\omega_{k}\in \Omega$ , where  $k\in \{1,\dots,N\}$ , we denote  $\overline{\mathbf{r}}_k$  as the new rule embedding inside  $\mathbf{M}$  caused by the  $k$ -th multiple-choice panel:
+
+$$
+\bar {\mathbf {r}} _ {k} = \frac {1}{2} \left(\mathbf {r} _ {1 3} ^ {(3)} + \mathbf {r} _ {2 3} ^ {(3)}\right). \tag {10}
+$$
+
+This procedure is illustrated in Figure 3. In practice, we generate the column-wise rule representation just as the row-wise one, and concatenate the two representations together as the final representation.
+
+For the rule embedding  $\overline{\mathbf{r}}^*$  generated by rows/columns filled with correct answer, the desirable SRAN should enforce it to be more similar to the dominant rule  $\mathbf{g}$ , compared to the other rules  $\overline{\mathbf{r}}_k$  corresponding to the wrong answers, where  $\overline{\mathbf{r}}_k \neq \overline{\mathbf{r}}^*$ . Subsequently, the generated rules of  $N$  candidates, alongside with the dominant rule, form a tuple containing  $N + 1$  elements. Based on the similarity function, the  $(N + 1)$ -tuple loss (Sohn 2016) can be defined for SRAN training:
+
+$$
+\mathcal {L} = \log \left(1 + \sum_ {k = 1, \overline {{\mathbf {r}}} _ {k} \neq \overline {{\mathbf {r}}} ^ {*}} ^ {N} \exp \left(\mathcal {D} \left(\mathbf {g}, \overline {{\mathbf {r}}} _ {k}\right) - \mathcal {D} \left(\mathbf {g}, \overline {{\mathbf {r}}} ^ {*}\right)\right)\right), \tag {11}
+$$
+
+which means the SRAN can be trained in a fully end-to-end manner. The architecture of the SRAN (Figure 2) is well matched to the problem of abstract reasoning, because it leverages human strategies and explicitly generates the rules governing the matrix.
+
+![](images/51f667bc379d0bf01a71ae92dd30950171448c3f72f94ce2eecaf80a0451403e.jpg)  
+Figure 3: The similarity score for a candidate answer. A multiple-choice panel from the answer set is inflated in the blank panel (row 3), generating a rule embedding  $\overline{\mathbf{r}}_k$  through SRAN. The similarity score for the candidate answer can be estimated based on  $\overline{\mathbf{r}}_k$  and the dominant rule embedding  $\mathbf{g}$  extracted from row 1 and 2
+
+Inference Once the training of SRAN is finished, we could make the inference of the newly given RPM question. Initially, the intact rows/columns of the RPM are fed into the framework to get the dominant rule  $\mathbf{g}$ . After that, each multiple-choice panel is filled to the blank position to complete the matrix, and the framework will generate the rule embeddings  $\overline{\mathbf{r}}_k$  for all candidate answers, given the current completed matrix. We can accomplish the abstract reasoning by choosing the correct multiple-choice as follows:
+
+$$
+k ^ {*} = \underset {k} {\arg \max } \mathcal {D} (\mathbf {g}, \overline {{\mathbf {r}}} _ {k}). \tag {12}
+$$
+
+Note that since we investigate each panel independently, the above inference process promises that our model's output stays invariant if the answer set is shuffled.
+
+# Attribute Bisection Tree for Impartial Dataset
+
+RAVEN (Zhang et al. 2019a) is a popular RPM-style dataset adopted by all recent studies (Zhang et al. 2019b; Zheng, Zha, and Wei 2019; Wang, Jamnik, and Lio 2020). However, we find severe defects in its answer sets, making RAVEN incompetence as a measurement of abstract reasoning. In this section, we first give a brief review of RAVEN, and then explain the defects with analysis and experiments. Finally we introduce a general algorithm to generate an impartial answer set for any attribute-based RPM question. Thus we fix the defects of RAVEN and propose an improved dataset.
+
+# Defects of RAVEN
+
+RAVEN dataset consists of 70,000 RPM questions distributed in 7 different figure configurations. Panels are constructed with 5 attributes (Number, Position, Type, Size, Color). Each attribute is governed by one of 4 rules and takes a value from a predefined set. Rules are applied only row-wise in RAVEN.
+
+After carefully examining the data in RAVEN, we find unexpected pattern among the eight multiple-choice panels. Each distractor in the answer set is generated by randomly modifying one attribute of the correct answer (see Figure 4(a)). As a consequence, the panel with the most common values for each attribute will be the correct answer. This means the correct answer can be found by simply scanning
+
+![](images/e1e302cb5394cea707cf87afa2c29a036f13bea8fdbf4630e1fd6e1e291d8740.jpg)  
+Figure 4: Comparison between RAVEN and I-RAVEN
+
+<table><tr><td>Model</td><td>RAVEN</td><td>I-RAVEN</td></tr><tr><td>ResNet (Zhang et al. 2019a)</td><td>53.4</td><td>40.3</td></tr><tr><td>CoPINet (Zhang et al. 2019b)</td><td>91.4</td><td>46.1</td></tr><tr><td>Context-blind ResNet</td><td>71.9</td><td>12.2</td></tr><tr><td>Context-blind CoPINet</td><td>94.2</td><td>14.2</td></tr></table>
+
+Table 1: Test on RAVEN and I-RAVEN
+
+the answer set without considering the context images. An example is also shown on the right of Figure 4(a). Among the answer set, the most common Color and Type are black (1, 3, 4, 5, and 7) and pentagon (1, 2, 3, 4, 6, and 8). Besides, multiple-choice panel 1, 2, 5, 6, 7, and 8 are in the same Size. Therefore, multiple-choice panel 1, which is the panel with the most common attribute values, is inferred as (and indeed is) the correct answer, even without considering the context matrix.
+
+Note that understanding of the context matrix is the cornerstone of RPM test. The RAVEN dataset, where the correct answer can be found without the context, is obviously against the essence of abstract reasoning, and thus is incapable of evaluating abstract reasoning ability.
+
+More severely, such underlying patterns can also be captured by neural networks, especially for models which combine features of eight multiple-choice panels. We train two models with context-blind (Barrett et al. 2018) setting, including a simple ResNet-based classifier (Zhang et al. 2019a) and the competitive CoPINet (Zhang et al. 2019b). These context-blind models are trained with only eight multiple-choice panels as input, and should have predicted the answer randomly, if the dataset is logical. However, as shown in Table 1, the context-blind models can achieve even better performance to the normal models, which proves that RAVEN contains illogical patterns where the correct answer can be found when only presented with the answer set. This type of back-door solutions is quite hidden and has also been discussed in other relational reasoning benchmarks, such as Visual Question Answering (VQA) (Johnson et al. 2017) and symbolic analogy (Hill et al. 2019). We can conclude that the 'overfitting' phenomenon on RAVEN reported by (Wang, Jamnik, and Lio 2020) is not caused by a permutation-invariant structure but by the dataset itself.
+
+# Algorithm 1 Attribute Bisection Tree
+
+# Input: the correct answer  $\omega^{*}$
+
+1: Initialize the answer set  $\Omega = \{\omega^{*}\}$
+
+2: Sample 3 attributes  $a_1, a_2, a_3$  according to  $\omega^*$
+
+3: Sample new value  $v_{i}$  for each  $a_{i}$
+
+4: for  $i = 1$  to 3 do
+
+5: Initialize  $\Gamma = \{\}$
+
+6: for each  $w_{k}$  in the current answer set  $\Omega$  do
+
+7:  $\gamma \gets$  modifying attribute  $a_{i}$  of  $\omega_{k}$  with  $v_{i}$
+
+8:  $\Gamma \leftarrow \Gamma \bigcup \{\gamma \}$
+
+9: end for
+
+10:  $\Omega \gets \Omega \bigcup \Gamma$
+
+11: end for
+
+Output: the answer set  $\Omega (|\Omega | = 2^3 = 8)$
+
+# Attribute Bisection Tree
+
+We design a general algorithm named Attribute Bisection Tree (ABT) to generate an impartial answer set for any attribute-based RPM question. The ABT ensures attribute modifications among the answer set are well balanced. Thus, no clue can be found to guess the correct answer only depending on the answer set, and no distractor can be eliminated without reasoning from the context matrix as well.
+
+Figure 4(b) demonstrates the generation process using a tree structure. Each node indicates a multiple-choice panel, and the root of the tree structure is the correct answer. Different levels indicate different iterations, where nodes of this level are the candidate answers of current answer set. The generation process flows in a top-down manner. For each iteration, only one attribute will be modified. At each level, a node has two children nodes, where one node remains the same with the father node, the other changes the value of the attribute sampled for this iteration of the father node. Finally, at the bottom level, we could obtain the whole answer set. Algorithm 1 summarizes the key steps of the answer generation process.
+
+# I-RAVEN
+
+With ABT, we generate an alternative answer set for each RPM question in the RAVEN dataset, forming an improved dataset named Impartial-RAVEN (I-RAVEN). Next, we will show that compared with RAVEN, I-RAVEN is more rigorous and fair for evaluating abstract reasoning capability.
+
+Taking Figure 4(b) for example, each attribute has two different values which distribute evenly in the answer set. The attribute Color of half answer candidates (1, 2, 4, and 7) are black, while the other half (3, 5, 6, and 8) are light grey. Similarly, the attribute Type of half answer candidates (1, 2, 6, and 8) are pentagon, while the other half (3, 4, 5, and 7) are circle. Half of the answer set (1, 3, 4, and 6) are in the same size, which are different from the other same-sized half (2, 5, 7, and 8). As a result, there is no candidate with the most common values for each attribute. In other words, the back-door solution on RAVEN can no longer be applied to the new answer set.
+
+To better explain the superiority of I-RAVEN over RAVEN, as shown in Figure 5, we use undirected graphs
+
+<table><tr><td>Model</td><td>Acc</td><td>Center</td><td>2×2G</td><td>3×3G</td><td>O-IC</td><td>O-IG</td><td>L-R</td><td>U-D</td></tr><tr><td>LSTM (Zhang et al. 2019a)</td><td>18.9</td><td>26.2</td><td>16.7</td><td>15.1</td><td>21.9</td><td>21.1</td><td>14.6</td><td>16.5</td></tr><tr><td>WReN (Barrett et al. 2018)</td><td>23.8</td><td>29.4</td><td>26.8</td><td>23.5</td><td>22.5</td><td>21.5</td><td>21.9</td><td>21.4</td></tr><tr><td>ResNet (Zhang et al. 2019a)</td><td>40.3</td><td>44.7</td><td>29.3</td><td>27.9</td><td>46.2</td><td>35.8</td><td>51.2</td><td>47.4</td></tr><tr><td>ResNet+DRT (Zhang et al. 2019a)</td><td>40.4</td><td>46.5</td><td>28.8</td><td>27.3</td><td>46.0</td><td>34.2</td><td>50.1</td><td>49.8</td></tr><tr><td>LEN (Zheng, Zha, and Wei 2019)</td><td>41.4</td><td>56.4</td><td>31.7</td><td>29.7</td><td>52.1</td><td>31.7</td><td>44.2</td><td>44.2</td></tr><tr><td>Wild ResNet (Barrett et al. 2018)</td><td>44.3</td><td>50.9</td><td>33.1</td><td>30.8</td><td>50.9</td><td>38.7</td><td>53.1</td><td>52.6</td></tr><tr><td>CoPINet (Zhang et al. 2019b)</td><td>46.1</td><td>54.4</td><td>36.8</td><td>31.9</td><td>52.2</td><td>42.8</td><td>51.9</td><td>52.5</td></tr><tr><td>SRAN (Ours)</td><td>60.8</td><td>78.2</td><td>50.1</td><td>42.4</td><td>68.2</td><td>46.3</td><td>70.1</td><td>70.3</td></tr></table>
+
+Table 2: Test accuracy of different models on I-RAVEN. Acc denotes the mean accuracy, while other columns show accuracy across seven figure configurations.  $2 \times 2\mathrm{G}$ ,  $3 \times 3\mathrm{G}$ , O-IC, O-IG, L-R, and U-D denote  $2 \times 2\mathrm{Grid}$ ,  $3 \times 3\mathrm{Grid}$ , Out-InCenter, Out-InGrid, Left-Right, and Up-Down, respectively  
+
+<table><tr><td>Model</td><td>LSTM</td><td>ResNet</td><td>Wild ResNet</td><td>CoPINet</td><td>WReN</td><td>MXGNet</td><td>LEN</td><td>SRAN</td></tr><tr><td>Acc</td><td>35.8</td><td>42.0</td><td>48.0</td><td>56.4</td><td>62.6</td><td>66.7</td><td>68.1</td><td>71.3</td></tr></table>
+
+Table 3: Test accuracy of different models on PGM
+
+$\bigcirc$  Correct answer  
+$\bigcirc$  Distractor  
+Differ in one attribute
+
+![](images/ec49ec108e761339e6e4bd0e03cc69e747e1bf3cbac66cb615de59d2229d3dfb.jpg)  
+(a) RAVEN
+
+![](images/4c808eede0a60e80ed450a8a103ba09f045db01e3ac1637cd1476cebd5ea1ce6.jpg)  
+(b) I-RAVEN  
+Figure 5: Characterizing answer sets of RAVEN and I-RAVEN using graphs
+
+to characterize typical answer sets of the two datasets respectively, where each candidate answer is represented by a node with its degree inflated. An edge between two nodes represents that the corresponding candidates differ in one attribute. In Figure 5(a), there is always a central node with a degree of 7 and the other nodes with less degrees. The back-door solution is to find the central node, which is indeed the correct answer. By contrast, in Figure 5(b), due to balanced modifications of attributes, each node always has the same degree of 3, which is indistinguishable from each other without the context matrix. Moreover, inspired by (Hill et al. 2019), we make the noise attribute Uniformity of each distractor stay consistent with the correct answer, so that each distractor is perceptually plausible and cannot be eliminated simply by attribute mismatching. This setting encourages models to reason from the context.
+
+We also train ResNet and CoPINet on I-RAVEN alongside with their context-blind versions to verify the fairness of the proposed dataset. The right column in Table 1 lists the results which are in stark contrast with those on the original RAVEN dataset. The performance of context-blind models is almost at a random guess level (12.5%), while the normal models relying on the context can perform much better.
+
+# Experiments
+
+# Experimental Setup
+
+With I-RAVEN, we first compare our method with several state-of-the-art models using public implementations, including LSTM (Hochreiter and Schmidhuber 1997), ResNet-based (He et al. 2016) image classifier (ResNet), ResNet with DRT (Zhang et al. 2019a), Wild ResNet (Barrett et al. 2018), WReN (Barrett et al. 2018), CoPINet (Zhang et al. 2019b), and LEN (Zheng, Zha, and Wei 2019). We adopt the public implementations of LSTM, ResNet, and DRT in (Zhang et al. 2019a). Other variants of LEN are not included in this section because they require additional training labels.
+
+PGM (Barrett et al. 2018) is another RPM dataset consisting of 1.42M questions. Rules in a matrix are composed with 1 to 4 relation-object-attribute tuples and can be applied along the rows or columns. SRAN is compared with results on PGM reported in (Barrett et al. 2018; Zhang et al. 2019b; Zheng, Zha, and Wei 2019; Wang, Jamnik, and Lio 2020).
+
+For our SRAN, we adopt three ResNet-18 (He et al. 2016) as the embedding networks for the three hierarchies, by modifying the input channels. The gate fusion  $\varphi_{1}$  and  $\varphi_{2}$  are 2-layer fully connected networks, while  $\varphi_{3}$  is a 4-layer fully connected network with dropout (Srivastava et al. 2014) of 0.5 applied on the last layer. We adopt stochastic gradient descent using ADAM (Kingma and Ba 2014) optimizer. The exponential decay rate parameters are  $\beta_{1} = 0.9$ ,  $\beta_{2} = 0.999$ ,  $\epsilon = 10^{-8}$ . Each reported accuracy is averaged over 5 runs.
+
+# Comparisons with State-of-the-art Methods
+
+Table 2 and Table 3 list the test accuracy of different models trained on I-RAVEN and PGM, respectively. From the table, it is obvious that our proposed SRAN outperforms other methods by a considerable margin. Besides, we observe that models benefit from inductive biases, such as the competitive CoPINet, LEN, Wild ResNet, and our SRAN. Such in-
+
+ductive biases (even partly) can encourage models to explore the underlying rules. For more detailed comparison, Table 2 also reports the accuracy on seven figure configurations of I-RAVEN. We can observe that accuracy on different configurations is not uniform, possibly due to the difficulty of configurations. But compared with other models, our SRAN consistently achieves the best performance on all the configurations, which proves that our model can work stably, even facing diverse conditions and complex rules.
+
+We observe that the accuracy of SRAN on I-RAVEN is very close to that on the original RAVEN dataset (60.8% vs. 60.7%). This phenomenon is as expected since our method mainly focuses on rules in the context, and thus is robust to the answer set.
+
+# Ablation Study
+
+As aforementioned, our method mainly gains from the inductive-biased architecture. To validate this point, we study the effects of different components in our SRAN. Table 4 lists the results.
+
+We analyze the stratified strategy to incrementally induce rules, using the performance of different choices of hierarchies. Specifically, we set the rule embedding of certain hierarchy as a zero vector before gate function  $\varphi$ . Thus, the gate function regulates the flow of features into the gated embedding fusion module. We observe that combing more hierarchies always leads to better performance on I-RAVEN, which shows all hierarchies contribute to our framework. We make  $\mathbb{E}_{\mathrm{cell}}$  orderless by summing all cell-wise embeddings and observe a major drop in performance. These observations prove the effectiveness of the proposed inductive biases of order sensitivity and incremental rule induction.
+
+We further discover that the effectiveness of our model can be put down to its attention to different attributes. We conduct experiments only utilizing single-hierarchy rule embeddings from  $\mathbb{E}_{\mathrm{cell}}$ ,  $\mathbb{E}_{\mathrm{ind}}$ ,  $\mathbb{E}_{\mathrm{eco}}$ , with respect to three attributes (Type, Size, and Color) of I-RAVEN. As shown in Figure 6,  $\mathbb{E}_{\mathrm{cell}}$  has strong capacity to infer attributes Type and Size, but struggles to distinguish attribute Color. By contrast,  $\mathbb{E}_{\mathrm{ind}}$  and  $\mathbb{E}_{\mathrm{eco}}$  have modest ability to infer attributes Type and Size, and are efficient for attribute Color.
+
+# The Advantage of Rule Embeddings
+
+In the real RPM test, it is not clear whether the rule exists in rows or columns. Therefore, it is important to check whether the proposed model can discover the knowledge without any guidance. Rule induction for columns is normally left out when trained on I-RAVEN, given the prior knowledge that rules are applied only row-wise. In order to test the ability of distinguishing whether the rules are applied along rows or columns, we train a SRAN model on I-RAVEN which the induction for column rules is reintegrated into. As a result, there is only a bit drop in accuracy (from  $60.8\%$  to  $59.6\%$ ). This indicates that our model can neglect the distraction brought by columns on its own.
+
+# Conclusion
+
+In this paper, we introduced necessary inductive biases for abstract visual reasoning task, such as order sensitivity and
+
+<table><tr><td>Model</td><td>I-RAVEN</td></tr><tr><td>Ecell (orderless)</td><td>23.5</td></tr><tr><td>Ecell</td><td>36.7</td></tr><tr><td>Eind</td><td>48.7</td></tr><tr><td>Eeco</td><td>51.6</td></tr><tr><td>Ecell + Eeco</td><td>52.9</td></tr><tr><td>Eind + Eeco</td><td>57.0</td></tr><tr><td>Ecell + Eind</td><td>57.8</td></tr><tr><td>Ecell + Eind + Eeco</td><td>60.8</td></tr></table>
+
+Table 4: SRAN  $(\mathbb{E}_{\mathrm{cell}} + \mathbb{E}_{\mathrm{ind}} + \mathbb{E}_{\mathrm{eco}})$  and the results of eliminating different components
+
+![](images/42360998645bd612c7a49a954b4d329119c39b0fb26179fcd135a8cb81817d6a.jpg)  
+Figure 6: Accuracy of single hierarchy with respect to the different attributes
+
+incremental rule induction. We further proposed a novel Stratified Rule-Aware Network, which could extract multiple granularity rule embeddings at different level and integrate them through a gated embedding fusion module. A rule similarity metric was further introduced based on the embeddings, so that SRAN can not only be trained using a tuple loss but also infer the best answer according to the similarity score. We also designed an algorithm named Attribute Bisection Tree to fix the defects of the popular dataset RAVEN, and generated a more rigorous dataset based on the algorithm. Extensive experiments conducted on PGM dataset and our improved dataset I-RAVEN proved that, our proposed framework could significantly outperform other state-of-the-art approaches. Moreover, we studied the effects of each component of our proposed model and evaluated the advantage of our induced rule embeddings.
+
+# Acknowledgments
+
+This work was supported by National Natural Science Foundation of China (62022009, 61872021), Beijing Nova Program of Science and Technology (Z191100001119050), State Key Lab of Software Development Environment (SKLSDE-2020ZX-06), Fundamental Research Funds for Central Universities (YWF-20-BJ-J-646), and the Academic Excellence Foundation of BUAA for PhD Students.
+
+# References
+
+Barrett, D.; Hill, F.; Santoro, A.; Morcos, A.; and Lillicrap, T. 2018. Measuring abstract reasoning in neural networks. In Proceedings of International Conference on Machine Learning (ICML), 511-520.  
+Carpenter, P. A.; Just, M. A.; and Shell, P. 1990. What One Intelligence Test Measures: A Theoretical Account of the Processing in the Raven Progressive Matrices Test. Psychological Review 97(3): 404-431.  
+He, K.; Zhang, X.; Ren, S.; and Sun, J. 2016. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 770-778.  
+Hill, F.; Santoro, A.; Barrett, D.; Morcos, A.; and Lillicrap, T. 2019. Learning to Make Analogies by Contrasting Abstract Relational Structure. In International Conference on Learning Representations (ICLR).  
+Hochreiter, S.; and Schmidhuber, J. 1997. Long short-term memory. Neural computation 9(8): 1735-1780.  
+Hoshen, D.; and Werman, M. 2017. Iq of neural networks. arXiv preprint arXiv:1710.01692.  
+Johnson, J.; Hariharan, B.; van der Maaten, L.; Fei-Fei, L.; Lawrence Zitnick, C.; and Girshick, R. 2017. Clevr: A diagnostic dataset for compositional language and elementary visual reasoning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2901–2910.  
+Kingma, D. P.; and Ba, J. 2014. Adam: A method for stochastic optimization. International Conference on Learning Representations (ICLR).  
+Krizhevsky, A.; Sutskever, I.; and Hinton, G. E. 2012. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems (NeurIPS), 1097-1105.  
+Kunda, M.; McGregor, K.; and Goel, A. K. 2013. A computational model for solving problems from the Raven's Progressive Matrices intelligence test using iconic visual representations. Cognitive Systems Research 22: 47-66.  
+Lovett, A.; and Forbus, K. 2017. Modeling visual problem solving as analogical reasoning. *Psychological Review* 124(1): 60-90.  
+Lovett, A.; Forbus, K.; and Usher, J. 2010. A structure-mapping model of Raven's Progressive Matrices. In Proceedings of the Annual Meeting of the Cognitive Science Society, volume 32.  
+Lovett, A.; Tomai, E.; Forbus, K.; and Usher, J. 2010. Solving Geometric Analogy Problems Through Two-Stage Analogical Mapping. Cognitive Science 33(7): 1192-1231.  
+Parent, E. 1996. The living systems theory of James Grier Miller. Retrieved November 29: 2007.  
+Raven, J. 2000. The Raven's progressive matrices: change and stability over culture and time. Cognitive psychology 41(1): 1-48.
+
+Raven, J. C. 1938. Raven's progressive matrices. Western Psychological Services.  
+Simonyan, K.; and Zisserman, A. 2015. Very deep convolutional networks for large-scale image recognition. In International Conference on Learning Representations (ICLR).  
+Sohn, K. 2016. Improved deep metric learning with multiclass n-pair loss objective. In Advances in Neural Information Processing Systems (NeurIPS), 1857-1865.  
+Srivastava, N.; Hinton, G.; Krizhevsky, A.; Sutskever, I.; and Salakhutdinov, R. 2014. Dropout: a simple way to prevent neural networks from overfitting. The journal of machine learning research 15(1): 1929-1958.  
+Steenbrugge, X.; Leroux, S.; Verbelen, T.; and Dhoedt, B. 2018. Improving generalization for abstract reasoning tasks using disentangled feature representations. arXiv preprint arXiv:1811.04784.  
+Strannegård, C.; Cirillo, S.; and Ström, V. 2013. An anthropomorphic method for progressive matrix problems. Cognitive Systems Research 22: 35-46.  
+Szegedy, C.; Liu, W.; Jia, Y.; Sermanet, P.; Reed, S.; Anguelov, D.; Erhan, D.; Vanhoucke, V.; and Rabinovich, A. 2015. Going deeper with convolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 1-9.  
+van Steenkiste, S.; Locatello, F.; Schmidhuber, J.; and Bachem, O. 2019. Are Disentangled Representations Helpful for Abstract Visual Reasoning? In Advances in Neural Information Processing Systems (NeurIPS), 14222-14235.  
+Wang, D.; Jamnik, M.; and Lio, P. 2020. Abstract diagrammatic reasoning with multiplex graph networks. In International Conference on Learning Representations (ICLR).  
+Zhang, C.; Gao, F.; Jia, B.; Zhu, Y.; and Zhu, S.-C. 2019a. RAVEN: A dataset for relational and analogical visual reasoning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 5317-5327.  
+Zhang, C.; Jia, B.; Gao, F.; Zhu, Y.; Lu, H.; and Zhu, S.-C. 2019b. Learning perceptual inference by contrasting. In Advances in Neural Information Processing Systems (NeurIPS), 1073-1085.  
+Zheng, K.; Zha, Z.-J.; and Wei, W. 2019. Abstract Reasoning with Distracting Features. In Advances in Neural Information Processing Systems (NeurIPS), 5834-5845.

2002.06xxx/2002.06838/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0223db86c46b6a3627f7756fe8ad798e6818eb71d1fcf910ec76361ce9a7c9cb
+size 328950

2002.06xxx/2002.06910/5e70957f-dbc4-4f22-8541-fa2060314a2e_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:edeb2116a0134f2363966b731c1268140fcb650a555898abe03ab059a1258bd7
+size 2120443

2002.06xxx/2002.06910/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc163d59a82d0ad4865de87309cb37684ffb1ac943338ab60d97d0f6100e5308
+size 916001