Add files using upload-large-folder tool

parse/train/8q_ca26L1fz/8q_ca26L1fz.md

@@ -0,0 +1,346 @@
+# REVISITING GRAPH NEURAL NETWORKS FOR LINK PREDICTION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Graph neural networks (GNNs) have achieved great success in recent years. Three most common applications include node classification, link prediction, and graph classification. While there is rich literature on node classification and graph classification, GNNs for link prediction is relatively less studied and less understood. Two representative classes of methods exist: GAE and SEAL. GAE (Graph Autoencoder) first uses a GNN to learn node embeddings for all nodes, and then aggregates the embeddings of the source and target nodes as their link representation. SEAL extracts a subgraph around the source and target nodes, labels the nodes in the subgraph, and then uses a GNN to learn a link representation from the labeled subgraph. In this paper, we thoroughly discuss the differences between these two classes of methods, and conclude that simply aggregating node embeddings does not lead to effective link representations, while learning from properly labeled subgraphs around links provides highly expressive and generalizable link representations. Experiments on the recent large-scale OGB link prediction datasets show that SEAL has up to $19 5 \%$ performance gains over GAE methods, achieving new state-of-the-art results on 3 out of 4 datasets.
+
+# 1 INTRODUCTION
+
+Link prediction is to predict potential or missing links connecting pairwise nodes in a network. It has wide applications in various fields, such as friend recommendation in social networks (Adamic & Adar, 2003), movie recommendation in Netflix (Bennett et al., 2007), protein-protein interaction prediction (Qi et al., 2006), and knowledge graph completion (Nickel et al., 2015), etc.
+
+Traditional link prediction approaches include heuristic methods, embedding methods, and featurebased methods. Heuristic methods compute some heuristic node similarity scores as the likelihood of links (Liben-Nowell & Kleinberg, 2007), such as common neighbors, preferential attachment (Barabasi & Albert, 1999), and Katz index (Katz, 1953), which can be regarded as some ´ predefined graph structure features. Embedding methods, including matrix factorization (MF) and Node2vec (Grover & Leskovec, 2016), learn free-parameter node embeddings from the observed network transductively, thus do not generalize to unseen nodes and networks. Feature-based methods only use explicit node features yet do not consider the graph structure. Recently, graph neural networks (GNNs) emerged to be powerful tools for learning over graph-structured data (Scarselli et al., 2009; Bruna et al., 2013; Duvenaud et al., 2015; Li et al., 2015; Kipf & Welling, 2016a; Niepert et al., 2016; Dai et al., 2016), and have been successfully used in link prediction as well (Kipf & Welling, 2016b; Zhang & Chen, 2018; You et al., 2019; Chami et al., 2019; Li et al., 2020).
+
+There are two main types of GNN-based link prediction methods. One is Graph Autoencoder (Kipf & Welling, 2016b), where a GNN is first applied to the entire network to learn an embedding vector for each node. Then the embeddings of the source and target nodes are aggregated to predict the target link. The second type is SEAL (Zhang & Chen, 2018; Li et al., 2020), where an enclosing subgraph is extracted around each target link. Then the nodes in each enclosing subgraph are labeled differently according to their distances to the source and target nodes. Finally a GNN is applied to each enclosing subgraph to learn a link representation for link prediction. At first glance, both methods seem to learn graph structure features associated with the target link, and leverage these structure features for link prediction. However, as we will see, the two methods have fundamentally different power in terms of learning the structural representations of links.
+
+![](images/cb0de5341280f60df880d25ad447e1303069e49387c26cc501083367c65cb43a.jpg)  
+Figure 1: The structural roles of link $( v _ { 1 } , v _ { 2 } )$ and link $( v _ { 1 } , v _ { 3 } )$ are different, but GAE will assign equal probabilities to them.
+
+We first show that by individually learning source and target node embeddings, GAE methods cannot differentiate links with different structural roles. To intuitively understand this, we give an example in Figure 1. In this graph, nodes $v _ { 2 }$ and $v _ { 3 }$ have the same structural roles (symmetric/isomorphic to each other). A GAE will learn the same node embeddings for $v _ { 2 }$ and $v _ { 3 }$ , thus giving the same predicted probabilities for link $( v _ { 1 } , v _ { 2 } )$ and link $( v _ { 1 } , v _ { 3 } )$ . However, the structural roles of link $( v _ { 1 } , v _ { 2 } )$ and link $( v _ { 1 } , v _ { 3 } )$ are apparently different – $v _ { 1 }$ intuitively should have unequal probabilities connecting to $v _ { 2 }$ and $v _ { 3 }$ . Next, we propose a labeling trick, which gives a label to each node as its additional feature, where the source and target nodes are labeled differently from the rest. We show that combined with the labeling trick, a sufficiently expressive GNN can learn the same representations for two links if and only if their structural roles are the same within the graph. This way, $( v _ { 1 } , v _ { 2 } )$ and $( v _ { 1 } , v _ { 3 } )$ will be predicted differently in Figure 1. We further show that SEAL is such an example. Finally, we give a more practical definition of isomorphism, called local isomorphism, which defines two nodes/links as isomorphic if their local neighborhood subgraphs are isomorphic. We argue that GNNs for link prediction should target on local-isomorphism-discriminating.
+
+We conduct a thorough comparison among different link prediction methods, including SEAL and various GAE and embedding methods, on the recent large-scale Open Graph Benchmark (OGB) datasets (Hu et al., 2020). We show that SEAL with the labeling trick has up to $19 5 \%$ higher Hits $@ 1 0 0$ than GAE methods, achieving new state-of-the-art results on 3 out of 4 datasets.
+
+# 2 PRELIMINARIES
+
+In this section, we formally define the notions of graph, permutation, isomorphism, and GNN.
+
+Definition 1. (Graph). We consider an undirected graph $\mathcal { G } = ( V , E , \pmb { \Delta } )$ , where $V = \{ 1 , 2 , \dots , n \}$ is the set of n vertices, $E \subseteq V \times V$ is the set of edges, and $\pmb { \mathsf { A } } \in \mathbb { R } ^ { n \times n \times k }$ contains the node and edge features with its diagonal components $\mathsf { \pmb { A } } _ { i , i } ,$ : denoting node attributes and off-diagonal components $\mathsf { \pmb { A } } _ { i , j } ,$ : denoting edge attributes. We further use $\pmb { A } \in \mathsf { \bar { \{ 0 , 1 \} } } ^ { n \times n }$ to denote the adjacency matrix of $\mathcal { G }$ with $A _ { i , j } = 1$ iff $( i , j ) \in E$ . If there are no node/edge features, we let $\pmb { \mathsf { A } } = \pmb { A }$ . Otherwise, $\pmb { A }$ can be regarded as the first slice of $\pmb { \mathsf { A } }$ , i.e., $A = \pmb { \mathsf { A } } _ { : , : , 1 }$ .
+
+Definition 2. (Permutation) $A$ node permutation $\pi$ is a bijective mapping from $\{ 1 , 2 , \ldots , n \}$ to $\{ 1 , 2 , \ldots , n \}$ . All $n$ ! possible $\pi$ ’s constitute the permutation group $\Pi _ { n }$ . We define $\pi ( S ) = \{ \pi ( i ) | i \in$ $S \}$ when $S$ is a subset of $\{ 1 , 2 , \ldots , n \}$ . We further define the permutation of $\pmb { \mathsf { A } }$ as $\pi ( \pmb { \mathsf { A } } )$ , where $\pi ( \pmb { \ A } ) _ { \pi ( i ) , \pi ( j ) , : } = \pmb { \ A } _ { i , j , : }$ . In other words, $\pi ( \mathbf { A } ) _ { i , j , : } = \pmb { \Delta } _ { \pi ^ { - 1 } ( i ) , \pi ^ { - 1 } ( j ) , }$ : .
+
+Definition 3. (Set isomorphism) Given two $n$ -node graphs $\mathcal { G } = ( V , E , \pmb { \Delta } )$ , $\mathcal { G } ^ { \prime } = ( V ^ { \prime } , E ^ { \prime } , \pmb { \Delta } ^ { \prime } )$ , and two node sets $S \subseteq V$ , $S ^ { \prime } \subseteq V ^ { \prime }$ , we say $( S , \pmb { \mathsf { A } } )$ and $( S ^ { \prime } , { \pmb { \mathsf { A } } } ^ { \prime } )$ are isomorphic (denoted by $( S , \pmb { \mathsf { A } } ) \simeq ( S ^ { \prime } , \pmb { \mathsf { A } } ^ { \prime } ) )$ ) $i f \exists \pi \in \Pi _ { n }$ such that $S = \pi ( S ^ { \prime } )$ and $\pmb { \mathsf { A } } = \pi ( \pmb { \mathsf { A } } ^ { \prime } )$ .
+
+When $( V , \pmb { \mathsf { A } } ) \simeq ( V ^ { \prime } , \pmb { \mathsf { A } } ^ { \prime } )$ , we say two graphs $\mathcal { G }$ and $\mathcal { G } ^ { \prime }$ are isomorphic (abbreviated as $\mathsf { \pmb { A } } \simeq \mathsf { \pmb { A } } ^ { \prime }$ because $V = \pi ( V ^ { \prime } )$ for any $\pi$ ). Note that set isomorphism is more strict than graph isomorphism, because it not only requires graph isomorphism, but also requires the permutation maps a specific subset $S$ to another subset $S ^ { \bar { \prime } }$ . When $S \subset V$ and $S ^ { \prime } \subset V ^ { \prime }$ , we are often more concerned with the case of $\pmb { \mathsf { A } } = \pmb { \mathsf { A } } ^ { \prime }$ , where we are to find isomorphic node sets in the same graph (automorphism). For example, when $S = \{ i \} , S ^ { \prime } = \{ j \}$ (single node case) and $( i , \pmb { \mathsf { A } } ) , ( j , \pmb { \mathsf { A } } )$ are isomorphic, it means $i$ and $j$ are on the same orbit of graph $\pmb { \mathsf { A } }$ (i.e., they have symmetric positions/same structural roles within the graph). An example is $v _ { 2 }$ and $v _ { 3 }$ in Figure 1.
+
+Definition 4. (Invariant function) A function $f$ defined over the space of $( S , \pmb { \mathsf { A } } )$ is invariant if $\forall \pi \in \Pi _ { n }$ , $f ( S , \mathbf { A } ) = f ( \pi ( S ) , \pi ( \mathbf { A } ) )$ .
+
+Definition 5. (GNN) $A$ GNN is an invariant function mapping from the space of $( S , \pmb { \mathsf { A } } )$ to $\mathbb { R } ^ { d }$ . More specifically, a GNN first performs multiple invariant message passing operations to compute a node embedding $z _ { i } = \mathbf { G N N } ( i , \mathbf { A } )$ for all $i \in S$ , and then performs a set aggregation (pooling) over $\{ z _ { i } | i \in S \}$ , written as $\mathrm { A G G } ( \{ z _ { i } | i \in S \} )$ , as the set $S$ ’s representation $\mathrm { G N N } ( S , \pmb { \mathsf { A } } )$ .
+
+Note that, when $| S | = 1$ , the set aggregation is often an identity mapping. In graph classification $S = V )$ , we use a graph pooling layer over node embeddings to compute the graph representation.
+
+# 3 GAE AND STRUCTURAL LINK REPRESENTATION
+
+In this section, we review how GAE methods predict links, and show that simply aggregating node embeddings learned by a GNN cannot lead to effective link representations. We use $\pmb { \mathsf { A } }$ to denote the incomplete network to perform link prediction.
+
+# 3.1 GAE FOR LINK PREDICTION
+
+Graph Autoencoder (GAE) methods (Kipf & Welling, 2016b) first use a GNN to compute a node embedding $z _ { i }$ for each node $i$ , and then use $f ( z _ { i } , z _ { j } )$ to predict the link $( i , j )$ :
+
+$$
+\hat { A } _ { i , j } = f ( z _ { i } , z _ { j } ) , \mathrm { w h e r e } z _ { i } = \mathrm { G N N } ( i , \mathsf { A } ) , z _ { j } = \mathrm { G N N } ( j , \mathsf { A } )
+$$
+
+where $\hat { A } _ { i , j }$ is the predicted score for link $( i , j )$ . The model is trained to maximize the likelihood of reconstructing the true adjacency matrix. The original GAE uses a two-layer GCN (Kipf & Welling, 2016a) as the GNN, and let $f ( z _ { i } , z _ { j } ) : = \sigma ( z _ { i } ^ { \top } z _ { j } )$ . In principle, we can replace GCN with any message passing neural network (Gilmer et al., 2017), and use an MLP over the aggregation of $z _ { i }$ and $z _ { j }$ as the $f ( z _ { i } , z _ { j } )$ . Popular aggregation functions include concatenation, mean and Hadamard product, etc. In the following, we will use GAE to denote a general class of GNN-based link prediction methods, without differentiating the specific choices of GNN and $f$ .
+
+# 3.2 GAE CAN LEARN STRUCTURAL NODE REPRESENTATIONS
+
+Following (Srinivasan & Ribeiro, 2020; Li et al., 2020), we first define most expressive structural representations for nodes and links. Then we relate them to GAE-learned node embeddings and show that GAE is not capable of learning structural link representations.
+
+Definition 6. Given an invariant function $\Gamma ( \cdot )$ , $\Gamma ( S , \pmb { \mathsf { A } } )$ is a most expressive structural representation for $( S , \pmb { \mathsf { A } } )$ if $\forall ( S , \pmb { \mathsf { A } } , S ^ { \prime } , \pmb { \mathsf { A } } ^ { \prime } )$ , $\Gamma ( S , \pmb { \mathsf { A } } ) = \Gamma ( S ^ { \prime } , \pmb { \mathsf { A } } ^ { \prime } ) \Leftrightarrow ( S , \pmb { \mathsf { A } } ) \simeq ( S ^ { \prime } , \pmb { \mathsf { A } } ^ { \prime } ) .$ .
+
+For simplicity, we will briefly use “structural representation” to denote most expressive structural representation in the rest of the paper. We will omit $\pmb { \mathsf { A } }$ if it is clear from context. We call $\Gamma ( i , \pmb { \mathsf { A } } )$ a structural node representation for $i$ , and call $\Gamma ( \{ i , j \} , \mathbf { A } )$ a structural link representation for $( i , j )$ .
+
+The above definition indicates that two node sets have the same structural representations if and only if they are isomorphic to each other. In the same graph $\pmb { \mathsf { A } }$ , structural representations uniquely mark the structural roles of nodes or node sets. This is in contrast to positional node embeddings such as DeepWalk (Perozzi et al., 2014) and matrix factorization (Mnih & Salakhutdinov, 2008), where two isomorphic nodes can have different node embeddings (Ribeiro et al., 2017).
+
+So why do we need to define structural representations? From a node classification point of view, it is because two isomorphic nodes in a network are perfectly symmetric to each other, and should be indistinguishable using any labeling functions on graphs (i.e., they should have the same ground truth $y$ ). Learning a structural node representation can guarantee that isomorphic nodes are always classified into the same class.
+
+Then, a natural question to ask is, do GNNs learn structural node representations? The answer is no. Recall that $( { \dot { i } } , \mathbf { A } ) \simeq ( j , \mathbf { A } ^ { \prime } ) \Rightarrow \mathbf { A } \simeq \mathbf { A } ^ { \prime }$ . If a GNN can learn structural node representations, we can always use it for graph isomorphism test by checking whether there exist two nodes in two graphs sharing the same structural node representation. In fact, existing GNNs’ graph discriminating power is bounded by the Weisfeiler-Lehman (WL) test (Morris et al., 2019; Maron et al., 2019), which provably fails to distinguish certain non-isomorphic graphs (Cai et al., 1992). Despite this, GNNs/WL are still powerful enough to learn representations that can distinguish almost all nonisomorphic nodes and graphs (Babai & Kucera, 1979).
+
+For easy analysis, we assume there exists a node-most-expressive GNN that can output structural node representations thus able to distinguish all non-isomorphic nodes. Despite this, the techniques we will present are not limited to node-most-expressive GNNs, but also benefit practical GNNs.
+
+Definition 7. A GNN is node-most-expressive if $\forall ( i , \mathsf { \pmb A } , j , \mathsf { \pmb A } ^ { \prime } )$ , $\mathrm { G N N } ( i , \pmb { \mathsf { A } } ) = \mathrm { G N N } ( j , \pmb { \mathsf { A } } ^ { \prime } ) \Leftrightarrow$ $( i , \mathsf { \pmb A } ) \simeq ( j , \mathsf { \pmb A } ^ { \prime } )$ .
+
+Recall that GAE first uses a GNN to compute node embeddings. Therefore, GAE with a node-mostexpressive GNN is able to leverage structural node representations for link prediction.
+
+# 3.3 GAE CANNOT LEARN STRUCTURAL LINK REPRESENTATIONS
+
+The next question to ask is whether GAE learns structural link representations. That is, does the aggregation of structural node representations of $i$ and $j$ result in a structural link representation of $( i , j ) ^ { \prime }$ ? The answer is no, as shown in previous works (Srinivasan & Ribeiro, 2020; Zhang & Chen, 2020). We have also illustrated it in the introduction. In Figure 1, we have two isomorphic nodes $v _ { 2 }$ and $v _ { 3 }$ , thus $v _ { 2 }$ and $v _ { 3 }$ will have the same structural node representation. By aggregating structural node representations as link representations, GAE will assign $( v _ { 1 } , v _ { 2 } )$ and $( v _ { 1 } , v _ { 3 } )$ the same link representation and predict them to have equal probabilities of forming a link. However, $( v _ { 1 } , v _ { 2 } )$ and $( v _ { 1 } , v _ { 3 } )$ apparently have different structural link representations, which indicates that
+
+Proposition 1. Even with a node-most-expressive GNN, GAE cannot learn structural link representations.
+
+The root cause of this problem is that GAE learns representations for the source and target nodes individually, without considering their relative positions and associations. For example, although $v _ { 2 }$ and $v _ { 3 }$ are perfectly symmetric in the graph, when considering the source node $v _ { 1 }$ to predict link from, $v _ { 2 }$ and $v _ { 3 }$ ’s positions w.r.t. $v _ { 1 }$ are no longer symmetric.
+
+# 4 HOW TO LEARN STRUCTURAL LINK REPRESENTATIONS?
+
+In this section, we discuss how to enable GNNs to learn structural link representations with a simple labeling trick, and show that SEAL is a valid example to learn structural link representations.
+
+# 4.1 LABELING TRICK
+
+We first introduce the labeling trick.
+
+Definition 8. (Labeling trick) Given $( S , \pmb { \mathsf { A } } )$ , we stack a diagonal labeling matrix $\pmb { I } ^ { ( S ) } \in \mathbb { R } ^ { n \times n }$ in the third dimension of $\pmb { \mathsf { A } }$ to get a new $\tilde { \textbf { A } } \in \mathbb { R } ^ { n \times n \times ( k + 1 ) }$ , where $\pmb { I }$ satisfies: $\forall \pi \ \in \ \Pi _ { n }$ , (1) $\pmb { I } ^ { ( S ) } = \pi ( \pmb { I } ^ { ( S ^ { \prime } ) } ) \Rightarrow S = \pi ( S ^ { \prime } )$ , and (2) $S = \pi ( S ^ { \prime } ) , \pmb { \mathrm { A } } = \pi ( \pmb { \mathrm { A } } ^ { \prime } ) \Rightarrow \pmb { I } ^ { ( S ) } = \pi ( \pmb { I } ^ { ( S ^ { \prime } ) } )$ . A simplest labeling trick is to let $I _ { i i } ^ { ( S ) } = 1$ if $i \in S$ otherwise $O$ .
+
+Note that the notation $\tilde { \pmb { A } }$ should actually depend on $S$ . For convenience, we omit such dependence on $S$ and infer it from the context. The first condition in Definition 8 requires the labeling matrix to identify the target node set $S$ ; and the second condition requires the labeling trick to be permutation equivariant, i.e., when $( S , A )$ and $( S ^ { \prime } , A ^ { \prime } )$ are isomorphic under $\pi$ , the corresponding nodes $i = \pi ( j )$ always have the same label. Essentially, the labeling trick distinguishes nodes in $S$ from the rest nodes. It can be as simple as only giving label 1 to nodes in $S$ and otherwise 0. Next, we show that with the labeling trick, a node-most-expressive GNN can learn structural link representations.
+
+Theorem 1. If a GNN is node-most-expressive, then with an injective set aggregation function AGG in Definition 5, $\mathrm { G N N } ( S , { \tilde { \mathbf { A } } } ) = \mathrm { G N N } ( S ^ { \prime } , { \tilde { \mathbf { A } } } ^ { \prime } ) \Leftrightarrow ( S , \mathbf { A } ) \simeq ( S ^ { \prime } , \mathbf { A } ^ { \prime } )$ for any $S , \pmb { \mathsf { A } } , S ^ { \prime } , \pmb { \mathsf { A } } ^ { \prime }$ .
+
+We include all the proofs in the appendix. Theorem 1 implies that $\mathbf { G N N } ( S , \tilde { \mathbf { A } } )$ is a structural representation for $( S , \pmb { \mathsf { A } } )$ . Recall Definition 5 defines $\mathrm { G N N } ( S , \tilde { \mathbf { A } } ) = \mathrm { A G G } ( \{ \mathrm { G N N } ( i , \tilde { \mathbf { A } } ) | i \in S \} )$ ). The above theorem indicates that although directly aggregating structural node representations learned from the original graph $\pmb { \mathsf { A } }$ does not lead to structural link representations, an injective aggregation over the structural node representations learned from the labeled graph $\tilde { \pmb { A } }$ does lead to structural link representations. How intuitively is it possible? Let’s return to the example in Figure 1. When we want to predict link $( v _ { 1 } , v _ { 2 } )$ , we can mark $v _ { 1 } , v _ { 2 }$ with a different label from the rest nodes, as shown by the different color in Figure 2 left. With the source and target nodes labeled, when the GNN is computing $v _ { 2 }$ ’s embedding, it is also “aware” of the source node $v _ { 1 }$ , instead of the previous agnostic way that treats $v _ { 1 }$ the same as other nodes. And when we want to predict link $( v _ { 1 } , v _ { 3 } )$ , we can again mark $v _ { 1 } , v _ { 3 }$ with a different label, as shown in Figure 2 right. This way, $v _ { 2 }$ and $v _ { 3 }$ ’s structural node representations are no longer the same in the two differently labeled graphs because of their different relative positions w.r.t. $v _ { 1 }$ , and we are able to give different predictions to $( v _ { 1 } , v _ { 2 } )$ and $( v _ { 1 } , v _ { 3 } )$ .
+
+![](images/0c80af1e196f06c0d917383391b3bcd048f7a9aab2dfb11f64f4175ed75c2d87.jpg)  
+Figure 2: When we predict $( v _ { 1 } , v _ { 2 } )$ , we will label these two nodes differently from the rest, so that a GNN is aware of the target link when computing $v _ { 1 }$ and $v _ { 2 }$ ’s embeddings. Similarly, when predicting $( v _ { 1 } , v _ { 3 } )$ , nodes $v _ { 1 } , v _ { 3 }$ will be labeled differently. The aggregated embedding of $v _ { 1 } , v _ { 2 }$ in the left graph will be different from the aggregated embedding of $v _ { 1 } , v _ { 3 }$ in the right graph, enabling GNNs to predict $( v _ { 1 } , v _ { 2 } )$ and $( v _ { 1 } , v _ { 3 } )$ differently.
+
+# 4.2 SEAL CAN LEARN STRUCTURAL LINK REPRESENTATIONS
+
+In this section, we will review SEAL (Zhang & Chen, 2018; Li et al., 2020), and show that SEAL exactly uses a valid labeling trick that is able to learn structural link representations.
+
+SEAL first extracts an enclosing subgraph ( $h$ -hop ego-network) around the link to predict.
+
+Definition 9. (Enclosing subgraph) Given $( S , \pmb { \mathsf { A } } )$ , the $h$ -hop enclosing subgraph ${ \pmb { \mathsf { A } } } _ { S } ^ { ( h ) }$ of $S$ is the subgraph induced from A by $\cup _ { i \in S } \{ j | d ( j , i ) \leq h \}$ , where $d ( j , i )$ is the shortest path distance between nodes $j$ and $i$ .
+
+Then, SEAL applies a Double Radius Node Labeling (DRNL) to give an integer label to each node within the enclosing subgraph. DRNL assigns different labels to nodes with different distances w.r.t. both the source and target nodes, where the source and target nodes are always labeled 1, and nodes farther away from the source and target nodes get larger labels (starting from 2). For example, nodes with distances 1 and 1 to the source and target nodes will get label 2, and nodes with distances 1 and 2 to the source and target nodes will get label 3. So on and so forth. Finally the labeled enclosing subgraph is fed to a GNN to learn the link representation and output the probability of link existence.
+
+It can be easily proved that DRNL satisfies the definition of the labeling trick, because node distances are invariant under permutation. DRNL not only differentiates the source and target nodes from the rest, but also differentiates nodes of different distances to the source and target nodes. The DRNL-labeled graphs also satisfy Theorem 1 and thus can enable a node-most-expressive GNN to learn structural link representations. Moreover, SEAL’s distance-based node labeling scheme is formalized into distance encoding, or $D E$ , in (Li et al., 2020), which theoretically shows that encoding distances between nodes can increase the representation power of normal GNNs.
+
+SEAL only uses a subgraph ${ \pmb { \mathsf { A } } } _ { S } ^ { ( h ) }$ within $h$ hops from the source and target nodes instead of using the whole graph. This is for practical concerns (just like GAE typically uses less than 3 message passing layers in practice), and will be discussed in detail in Section 5. When $h  \infty$ , SEAL can also leverage the entire graph and learn structural representations for $( S , \pmb { \mathsf { A } } )$ :
+
+Proposition 2. When $h  \infty$ , SEAL can learn structural link representations with a node-mostexpressive GNN.
+
+Note that although we show a node-most-expressive GNN combining with the labeling trick is able to learn structural link representations, even without a node-most-expressive GNN, the labeling trick can still benefit most link representation learning tasks. For example, in Figure 2, as long as a normal GNN can give different embeddings to $v _ { 2 }$ and $v _ { 3 }$ in the left and right graphs (which is easy for most GNNs), we can still differentiate link $( v _ { 1 } , v _ { 2 } )$ from link $( v _ { 1 } , v _ { 3 } )$ . And this is not possible for GAE.
+
+Despite the power, the labeling trick introduces extra computational complexity. The reason is that for every link $( i , j )$ to predict, we need to relabel the graph according to $( i , j )$ . The same node $i$ will be labeled differently depending on the target link, and will be given a different node embedding by the GNN when it appears in different links’ labeled graphs. This is different from GAE, where we do not relabel the graph and each node only has a single embedding vector. For a graph with $n$ nodes and $m$ links to predict, GAE needs to apply the GNN ${ \mathcal { O } } ( n )$ times to compute an embedding for each node, while SEAL needs to apply the GNN $\mathcal { O } ( m )$ times for all links. When $m \gg n$ , SEAL has worse time complexity than GAE, which is a trade-off for learning structural link representations.
+
+In the previous analysis, we have assumed there exists a node-most-expressive GNN that can discriminate non-isomorphic nodes. Although a practical GNN can also discriminate almost all nonisomorphic nodes, there is little research discussing how to reach this discriminating power. In this section, we analyze GNNs for link prediction from a more practical point of view.
+
+Practical GNNs usually simulate the 1-dimensional Weisfeiler-Lehman (1-WL) test (Weisfeiler & Lehman, 1968) to iteratively update each node’s hidden state by aggregating its neighbors’ states (we call them 1-WL-GNN). One most powerful 1-WL-GNN is the Graph Isomorphism Network (GIN) (Xu et al., 2018), which achieves theoretically the same discriminating power as 1-WL.
+
+Although showing 1-WL-GNN’s maximum discriminating power, previous GNN research has not discussed how many message passing layers are required to reach this theoretical power. We therefore introduce the following lemma.
+
+Lemma 1. Given a graph with n nodes, a most powerful 1-WL-GNN takes up to ${ \mathcal { O } } ( n )$ message passing layers to discriminate all non-isomorphic nodes that 1-WL can discriminate.
+
+Lemma 1 suggests that 1-WL-GNN needs a number of message passing layers of the same order as the number of nodes in the graph to reach its maximum discriminating power. However, practical GNNs usually only use a small number of message passing layers (such as 1 or 2) while still achieving good performance. This perhaps suggests that in practice, we do not necessarily need to find nodes/links that are exactly isomorphic to each other. Instead, nodes/links which are locally isomorphic could even more strongly suggest they should be classified into the same class.
+
+Definition 10. (Local $h$ -isomorphism) $\forall ( S , \pmb { \mathsf { A } } , S ^ { \prime } , \pmb { \mathsf { A } } ^ { \prime } )$ , $( S , \pmb { \mathsf { A } } )$ and $( S ^ { \prime } , { \pmb { \mathsf { A } } } ^ { \prime } )$ are locally $h$ -isomorphic to each other if $\mathbf { \Sigma } ( S , \mathbf { A } _ { S } ^ { ( h ) } ) \simeq ( S ^ { \prime } , \mathbf { A ^ { \prime } } _ { S ^ { \prime } } ^ { ( h ) } )$ .
+
+For two sets $S , S ^ { \prime }$ , if their tuples with their $h$ -hop enclosing subgraphs $( S , \pmb { \mathsf { A } } _ { S } ^ { ( h ) } )$ and $( S ^ { \prime } , \pmb { A } _ { S ^ { \prime } } ^ { \prime ( h ) } )$ are isomorphic, then we say they are locally -isomorphic. We argue that this is a more useful definition than isomorphism, because isomorphism requires the entire graph looks identical from two sets’ separate views, which is often too strict in practice. If we use the strict definition of isomorphism, we may fail to identify a lot of nodes/links that actually have very similar neighborhood structures. In fact, Babai & Kucera (1979) prove that at least $\left( n - \log n \right)$ nodes in almost all $n$ -node graphs are non-isomorphic to each other. Therefore, it is less meaningful to only assign the same representations to nodes/links when they are strictly isomorphic, and GNNs targeting on isomorphismdiscriminating tend to overfit. In comparison, local $h$ -isomorphism only cares about whether the $h$ -hop neighborhoods are isomorphic, which is more realistic and allows better generalizability.
+
+With local $h$ -isomorphism, all our previous conclusions using the standard isomorphism definition still apply. For example, GAE with a node-most-expressive GNN can be used to identify locally $h$ -isomorphic nodes, but cannot discriminate locally $h$ -non-isomorphic links. And a node-mostexpressive GNN with the labeling trick (SEAL) can identify locally $h$ -isomorphic node sets, etc. To enable a GNN to focus on local $h$ -isomorphism-discriminating, all we need to do is to set a boundary between the $h$ -hop enclosing subgraph and the rest of the graph, and apply the GNN only to the extracted subgraph within the boundary (possibly use more than $h$ message passing layers).
+
+Finally, we want to answer a question: in what chance node local $h$ -isomorphism also indicates link local $h$ -isomorphism? If in a graph, two nodes being locally $h$ -isomorphic almost always indicates their links with a third node are locally $h$ -isomorphic, then learning structural link representations with SEAL may no longer be necessary, and using GAE to learn structural node representations may already be enough. In other words, we are interested in how often examples like Figure 1 appear in graphs. Fortunately, we have the following theorem, which shows that there are enough links where only identifying locally $h$ -isomorphic nodes is not enough.
+
+Theorem 2. In any graphs with n nodes and without node/edge features, if the degree of each node in the graph is between 1 and $\mathcal { O } ( \log ^ { \frac { 1 - \epsilon } { 2 h } } n )$ for any constant $\epsilon > 0$ , then there exists $\omega ( n ^ { 2 \epsilon } )$ many pairs of nodes $u , v$ such that u and $v$ are locally $h$ -isomorphic while there exists another node $w$ such that $( u , w )$ and $( v , w )$ are not locally $h$ -isomorphic.
+
+Table 1: Statistics and evaluation metrics of OGB link prediction datasets.   
+
+<table><tr><td>Dataset</td><td>#Nodes</td><td>#Edges</td><td>Avg. node deg.</td><td>Density</td><td>Split ratio</td><td>Metric</td></tr><tr><td>ogbl-ppa</td><td>576,289</td><td>30,326,273</td><td>73.7</td><td>0.018%</td><td>70/20/10</td><td>Hits @100</td></tr><tr><td>ogbl-collab</td><td>235,868</td><td>1,285,465</td><td>8.2</td><td>0.0046%</td><td>92/4/4</td><td>Hits@50</td></tr><tr><td>ogbl-ddi</td><td>4,267</td><td>1,334,889</td><td>500.5</td><td>14.67%</td><td>80/10/10</td><td>Hits @20</td></tr><tr><td>ogbl-citation</td><td>2,927,963</td><td>30,561,187</td><td>20.7</td><td>0.00036%</td><td>98/1/1</td><td>MRR</td></tr></table>
+
+# 6 RELATED WORK
+
+There are emerging interests in studying the expressive power of graph neural networks recently. Xu et al. (2018) and Morris et al. (2019) first show that the discriminating power of GNNs performing neighbor aggregation is bounded by the 1-WL test. Many works have since been proposed to increase the power of GNNs by simulating higher-order WL tests (Morris et al., 2019; Maron et al., 2019; Chen et al., 2019). However, most previous works focus on improving GNN’s graph representation power. Little work has been done to analyze GNN’s node/link representation power. Srinivasan & Ribeiro (2020) first formally studied the difference between structural representations of nodes and links. Although showing that structural node representations alone cannot perform link prediction, their way of learning structural link representations is to give up GNNs and instead use Monte Carlo samples of node embeddings learned by network embedding methods. In this paper, we show that GNNs combined with a simple labeling trick can as well learn structural link representations, which reassures using GNNs for link prediction.
+
+Many works have implicitly assumed that if a model can learn node embeddings well, then combining the pairwise node embeddings can also lead to good link representations (Grover & Leskovec, 2016; Kipf & Welling, 2016b; Hamilton et al., 2017). However, we argue in this paper that by considering the source and target nodes explicitly with the labeling trick, we can aggregate better link representations from node embeddings. Li et al. (2020) studied one particular form of the labeling trick based on distance, and proved that distance encoding can improve 1-WL-GNNs’ expressive power, enabling them to distinguish almost all $( S , \pmb { \mathsf { A } } )$ tuples sampled from r-regular graphs. In this paper, we do not focus on improving 1-WL-GNNs’ expressive power, but focus on how to enable a sufficiently expressive GNN to learn structural link representations in any graphs. We also provide a general definition of the labeling trick, and argue that a labeling trick as simple as only giving the source and target nodes 1 and other nodes 0 suffices to enable structural link representation learning.
+
+# 7 EXPERIMENTS
+
+In this section, we compare SEAL, GAE methods, and network embedding methods on the Open Graph Benchmark (OGB) (Hu et al., 2020) datasets. We use all the four link prediction datasets in OGB: ogbl-ppa, ogbl-collab, ogbl-ddi, and ogbl-citation. These datasets adopt realistic train/validation/test splitting methods, such as by resource cost in laboratory (ogbl-ppa), by time (ogbl-collab and ogbl-citation), and by drug target in the body (ogbl-ddi). They are also large-scale (up to 2.9M nodes and $3 0 . 6 \mathbf { M }$ edges), open-sourced, and have standard evaluation metrics, thus providing an ideal place to benchmark an algorithm’s realistic link prediction power. The evaluation metrics include Hits $@ K$ and MRR. Hits $@ K$ counts the ratio of positive edges ranked at the K-th place or above against all the negative edges. MRR (Mean Reciprocal Rank) computes the reciprocal rank of the true target node against 1,000 negative candidates, averaged over all the true source nodes. Both metrics are higher the better. The statistics are in Table 1.
+
+Baselines. We consider the following representative models. Except SEAL, all models first compute node embeddings from the original graph and use the Hadamard product between pairwise node embeddings as link representations. The link representations are fed to an MLP for final prediction.
+
+• MLP: Input node features are directly used as the node embeddings.   
+• Node2vec (Perozzi et al., 2014; Grover & Leskovec, 2016): The node embeddings are the concatenation of node features and Node2vec embeddings.   
+• MF: Use free-parameter node embeddings trained end-to-end as the node embeddings.   
+• GraphSAGE (Hamilton et al., 2017): A GAE method with GraphSAGE as the GNN. • GCN (Kipf & Welling, 2016b): A GAE method with GCN as the GNN.   
+• GCN+LRGA (Puny et al., 2020): A GAE method with LRGA-module-enhanced GCN.   
+• SEAL (Zhang & Chen, 2018): Learn link representations from labeled subgraphs via a GNN.
+
+Table 2: Results for ogbl-ppa, ogbl-collab, ogbl-ddi and ogbl-citation.   
+
+<table><tr><td></td><td colspan="2">ogbl-ppa Hits @100 (%)</td><td colspan="2">ogbl-collab Hits @50 (%)</td><td colspan="2">ogbl-ddi Hits @20 (%)</td><td colspan="2">ogbl-citation MRR (%)</td></tr><tr><td>Method</td><td>Validation</td><td>Test</td><td>Validation</td><td>Test</td><td>Validation</td><td>Test</td><td>Validation</td><td>Test</td></tr><tr><td>MLP</td><td>0.46±0.00</td><td>0.46±0.00</td><td>24.02±1.45</td><td>19.27±1.29</td><td></td><td></td><td>28.98±0.14</td><td>29.04±0.13</td></tr><tr><td>Node2vec</td><td>22.53±0.88</td><td>22.26±0.88</td><td>57.03±0.52</td><td>48.88±0.54</td><td>32.92±1.21</td><td>23.26±2.09</td><td>59.44±0.11</td><td>59.64±0.11</td></tr><tr><td>MF</td><td>32.28±4.28</td><td>32.29±0.94</td><td>48.96±0.29</td><td>38.86±0.29</td><td>33.70±2.64</td><td>13.68±4.75</td><td>53.11±5.65</td><td>53.16±5.65</td></tr><tr><td>GraphSAGE</td><td>17.24±2.64</td><td>16.55±2.40</td><td>56.88±0.77</td><td>48.10±0.81</td><td>62.62±0.37</td><td>53.90±4.74</td><td>82.17±0.86</td><td>82.28±0.84</td></tr><tr><td>GCN</td><td>18.45±1.40</td><td>18.67±1.32</td><td>52.63±1.15</td><td>44.75±1.07</td><td>55.50±2.08</td><td>37.07±5.07</td><td>84.49±1.08</td><td>84.56±1.10</td></tr><tr><td>GCN+LRGA</td><td>25.75±2.82</td><td>26.12±2.35</td><td>60.88±0.59</td><td>52.21±0.72</td><td>66.75±0.58</td><td>62.30±9.12</td><td>65.05±0.22</td><td>65.05±0.22</td></tr><tr><td>SEAL</td><td>51.25±2.52</td><td>48.80±3.16</td><td>63.89±0.49</td><td>53.71±0.47</td><td>28.49±2.69</td><td>30.56±3.86</td><td>85.09±0.88</td><td>85.27±0.91</td></tr></table>
+
+All the GAE methods’ GNNs have 3 message passing layers with 256 hidden dimensions, with a tuned dropout ratio in $\{ 0 , 0 . 5 \}$ . The GNN in SEAL follows the original paper, which has 3 GCN layers with 32 hidden dimensions each, with a tuned subgraph hop $h$ in $\{ 1 , 2 \}$ . The ogbl-ddi graph contains no node features, so MLP is omitted, and the GAE methods here use free-parameter node embeddings as the GNN input node features and trained them together with the GNN parameters. For SEAL, the DRNL node labels are input to an embedding layer and then concatenated with the node features (if any) as the GNN input. More details are in Appendix D.
+
+Results and discussion. We compare the baselines’ link prediction performance on ogbl-ppa, ogbl-collab, ogbl-ddi, and ogbl-citation. Among them, ogbl-ppa is a proteinprotein association graph where the task is to predict biologically meaningful associations between proteins. ogbl-collab is an author collaboration graph, where the task is to predict future collaborations. ogbl-ddi is a drug-drug interaction network, where each edge represents an interaction between drugs which indicates the join effect of taking the two drugs together is considerably different from their independent effects. ogbl-citation is a paper citation network, where the task is to predict missing citations. We present the ten-time average results in Table 2. The results show that SEAL achieves the best performance on 3 out of 4 datasets. It outperforms GAE and network embedding methods, sometimes by surprisingly large margins. For example, in the challenging ogbl-ppa graph, SEAL achieves an $\operatorname { H i t s } @ 1 0 0$ of 48.80, which is over $50 \%$ higher than the second-best baseline MF which only has an Hits $@ 1 0 0$ of 32.29. In comparison, all GAE methods achieve Hits $@ 1 0 0$ lower than 30. SEAL has $8 7 \% . 1 9 5 \%$ improvement over GAE methods in this dataset, which demonstrates the superiority of learning structural link representations over structural node representations for link prediction. SEAL also improves the state-of-the-art results for ogbl-collab and ogbl-citation in both validation and test performance.
+
+Nevertheless, we observe that SEAL does not perform well on ogbl-ddi. ogbl-ddi is considerably denser than the other graphs. It only has 4,267 nodes, but has 1,334,889 edges, which results in an average node degree of 500.5 and density of $1 4 . 6 7 \%$ . Interestingly, although SEAL is able to beat MF and Node2vec, it falls behind GAE methods with free-parameter node embeddings. One possible reason is that the nodes in ogbl-ddi are so densely connected that a practical GNN with limited expressive power is hard to inductively learn any meaningful structural patterns. In comparison, the free-parameter node embeddings make GAE methods transductive and no longer focus on learning structural patterns, but focus on optimizing node embeddings. An interesting topic is thus how to improve structural representation learning on dense graphs, which we leave for future work.
+
+# 8 CONCLUSIONS
+
+In this paper, we have revisited the topic of using graph neural networks for link prediction. We reviewed two popular classes of methods, GAE and SEAL. We first showed that GAE methods cannot learn structural link representations by aggregating individually learned node embeddings. We further showed that combining with a simple labeling trick, a node-most-expressive GNN can learn structural link representations, and SEAL is such an example. Experiments on 4 large-scale OGB datasets demonstrate the superiority of learning structural link representations with SEAL.
+
+# REFERENCES
+
+Lada A Adamic and Eytan Adar. Friends and neighbors on the web. Social networks, 25(3):211–230, 2003.
+
+Laszl ´ o Babai and Ludik Kucera. Canonical labelling of graphs in linear average time. In ´ 20th Annual Symposium on Foundations of Computer Science (sfcs 1979), pp. 39–46. IEEE, 1979.
+
+Albert-Laszl ´ o Barab ´ asi and R ´ eka Albert. Emergence of scaling in random networks. ´ science, 286 (5439):509–512, 1999.
+
+James Bennett, Stan Lanning, et al. The netflix prize. In Proceedings of KDD cup and workshop, volume 2007, pp. 35. New York, 2007.
+
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. arXiv preprint arXiv:1312.6203, 2013.
+
+Jin-Yi Cai, Martin Furer, and Neil Immerman. An optimal lower bound on the number of variables ¨ for graph identification. Combinatorica, 12(4):389–410, 1992.
+
+Ines Chami, Zhitao Ying, Christopher Re, and Jure Leskovec. Hyperbolic graph convolutional neural ´ networks. In Advances in neural information processing systems, pp. 4868–4879, 2019.
+
+Zhengdao Chen, Soledad Villar, Lei Chen, and Joan Bruna. On the equivalence between graph isomorphism testing and function approximation with gnns. In Advances in Neural Information Processing Systems, pp. 15894–15902, 2019.
+
+Hanjun Dai, Bo Dai, and Le Song. Discriminative embeddings of latent variable models for structured data. In Proceedings of The 33rd International Conference on Machine Learning, pp. 2702– 2711, 2016.
+
+David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alan´ Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in neural information processing systems, pp. 2224–2232, 2015.
+
+Matthias Fey and Jan Eric Lenssen. Fast graph representation learning with pytorch geometric. arXiv preprint arXiv:1903.02428, 2019.
+
+Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1263–1272. JMLR. org, 2017.
+
+Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 855–864. ACM, 2016.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, pp. 1025–1035, 2017.
+
+Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. arXiv preprint arXiv:2005.00687, 2020.
+
+Leo Katz. A new status index derived from sociometric analysis. Psychometrika, 18(1):39–43, 1953.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016a.
+
+Thomas N Kipf and Max Welling. Variational graph auto-encoders. arXiv preprint arXiv:1611.07308, 2016b.
+
+Pan Li, Yanbang Wang, Hongwei Wang, and Jure Leskovec. Distance encoding–design provably more powerful gnns for structural representation learning. arXiv preprint arXiv:2009.00142, 2020.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015.
+
+David Liben-Nowell and Jon Kleinberg. The link-prediction problem for social networks. Journal of the American society for information science and technology, 58(7):1019–1031, 2007.
+
+Haggai Maron, Heli Ben-Hamu, Hadar Serviansky, and Yaron Lipman. Provably powerful graph networks. In Advances in Neural Information Processing Systems, pp. 2156–2167, 2019.
+
+Andriy Mnih and Ruslan R Salakhutdinov. Probabilistic matrix factorization. In Advances in neural information processing systems, pp. 1257–1264, 2008.
+
+Christopher Morris, Martin Ritzert, Matthias Fey, William L Hamilton, Jan Eric Lenssen, Gaurav Rattan, and Martin Grohe. Weisfeiler and leman go neural: Higher-order graph neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 4602–4609, 2019.
+
+Maximilian Nickel, Kevin Murphy, Volker Tresp, and Evgeniy Gabrilovich. A review of relational machine learning for knowledge graphs. arXiv preprint arXiv:1503.00759, 2015.
+
+Mathias Niepert, Mohamed Ahmed, and Konstantin Kutzkov. Learning convolutional neural networks for graphs. In Proceedings of the 33rd annual international conference on machine learning. ACM, 2016.
+
+Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 701–710. ACM, 2014.
+
+Omri Puny, Heli Ben-Hamu, and Yaron Lipman. From graph low-rank global attention to 2-fwl approximation. arXiv preprint arXiv:2006.07846, 2020.
+
+Yanjun Qi, Ziv Bar-Joseph, and Judith Klein-Seetharaman. Evaluation of different biological data and computational classification methods for use in protein interaction prediction. Proteins: Structure, Function, and Bioinformatics, 63(3):490–500, 2006.
+
+Leonardo FR Ribeiro, Pedro HP Saverese, and Daniel R Figueiredo. struc2vec: Learning node representations from structural identity. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 385–394. ACM, 2017.
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2009.
+
+Balasubramaniam Srinivasan and Bruno Ribeiro. On the equivalence between positional node embeddings and structural graph representations. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } }$ SJxzFySKwH.
+
+Boris Weisfeiler and AA Lehman. A reduction of a graph to a canonical form and an algebra arising during this reduction. Nauchno-Technicheskaya Informatsia, 2(9):12–16, 1968.
+
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv:1810.00826, 2018.
+
+Jiaxuan You, Rex Ying, and Jure Leskovec. Position-aware graph neural networks. arXiv preprint arXiv:1906.04817, 2019.
+
+Muhan Zhang and Yixin Chen. Link prediction based on graph neural networks. In Advances in Neural Information Processing Systems, pp. 5165–5175, 2018.
+
+Muhan Zhang and Yixin Chen. Inductive matrix completion based on graph neural networks. In International Conference on Learning Representations, 2020. URL https://openreview. net/forum?id $=$ ByxxgCEYDS.
+
+Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. In AAAI, pp. 4438–4445, 2018.
+
+# A PROOF OF THEOREM 1
+
+Recall Definition 5 defines:
+
+$$
+\mathrm { G N N } ( S , \tilde { \mathbf { A } } ) = \mathrm { A G G } ( \{ \mathrm { G N N } ( i , \tilde { \mathbf { A } } ) | i \in S \} ) .
+$$
+
+Thus, we only need to show $\mathrm { A G G } ( \{ \mathrm { G N N } ( i , \tilde { \mathbf { A } } ) | i \in S \} ) = \mathrm { A G G } ( \{ \mathrm { G N N } ( i , \tilde { \mathbf { A } } ^ { \prime } ) | i \in S ^ { \prime } \} )$ iff $( S , \pmb { \mathsf { A } } ) \simeq$ $( S ^ { \prime } , { \pmb { \mathsf { A } } } ^ { \prime } )$ .
+
+To prove the first direction, we notice that with an injective AGG,
+
+$$
+\begin{array} { r l } & { ~ \mathrm { A G G } ( \{ \mathrm { G N N } ( i , \tilde { \mathbf { A } } ) | i \in S \} ) = \mathrm { A G G } ( \{ \mathrm { G N N } ( i , \tilde { \mathbf { A } } ^ { \prime } ) | i \in S ^ { \prime } \} ) } \\ & { \implies \exists v _ { 1 } \in S , v _ { 2 } \in S ^ { \prime } , \mathrm { ~ s u c h ~ t h a t ~ G N N } ( v _ { 1 } , \tilde { \mathbf { A } } ) = \mathrm { G N N } ( v _ { 2 } , \tilde { \mathbf { A } } ^ { \prime } ) } \\ & { \implies ( v _ { 1 } , \tilde { \mathbf { A } } ) \simeq \left( v _ { 2 } , \tilde { \mathbf { A } } ^ { \prime } \right) \quad ( \mathrm { b e c a u s e ~ G N N ~ i s ~ n o d e - m o s t - e x p r e s s i v e } , } \\ & { \implies \exists \pi \in \Pi _ { n } , \mathrm { ~ s u c h ~ t h a t ~ } v _ { 1 } = \pi ( v _ { 2 } ) , \tilde { \mathbf { A } } = \pi ( \tilde { \mathbf { A } } ^ { \prime } ) . } \end{array}
+$$
+
+Remember $\tilde { \pmb { A } }$ is constructed by stacking $\pmb { \mathsf { A } }$ and $\pmb { I } ^ { ( S ) }$ in the third dimension, where $\pmb { I } ^ { ( S ) }$ is a diagonal matrix satisfying: $\forall \pi \in \Pi _ { n }$ , (1) $\pmb { I } ^ { ( S ) } = \pi ( \pmb { I } ^ { ( S ^ { \prime } ) } ) \Rightarrow S = \pi ( S ^ { \prime } )$ , and (2) $S = \pi ( S ^ { \prime } ) , \pmb { \mathbb { A } } = \pi ( \pmb { \mathbb { A } } ^ { \prime } ) \Rightarrow$ $\pmb { I } ^ { ( S ) } = \pi ( \pmb { I } ^ { ( S ^ { \prime } ) } )$ . With $\tilde { \pmb { \mathsf { A } } } = \pi ( \tilde { \pmb { \mathsf { A } } } ^ { \prime } )$ , we have both
+
+$$
+\mathbf { A } = \pi ( \mathbf { A } ^ { \prime } ) , I ^ { ( S ) } = \pi ( I ^ { ( S ^ { \prime } ) } ) .
+$$
+
+Because $\pmb { I } ^ { ( S ) } = \pi ( \pmb { I } ^ { ( S ^ { \prime } ) } ) \Rightarrow S = \pi ( S ^ { \prime } )$ , we have
+
+$$
+\begin{array} { r l } & { \quad \mathrm { A G G } ( \{ \mathrm { G N N } ( i , \tilde { \mathbf { A } } ) | i \in S \} ) = \mathrm { A G G } ( \{ \mathrm { G N N } ( i , \tilde { \mathbf { A } } ^ { \prime } ) | i \in S ^ { \prime } \} ) } \\ & { \implies \exists \pi \in \Pi _ { n } , \mathrm { ~ s u c h ~ t h a t ~ } S = \pi ( S ^ { \prime } ) , \mathbf { A } = \pi ( \mathbf { A } ^ { \prime } ) } \\ & { \implies ( S , \mathbf { A } ) \simeq ( S ^ { \prime } , \mathbf { A } ^ { \prime } ) . } \end{array}
+$$
+
+Now we prove the second direction. We have:
+
+$$
+\begin{array} { r l } & { \qquad ( S , \boldsymbol { \mathsf { A } } ) \simeq ( S ^ { \prime } , \boldsymbol { \mathsf { A } } ^ { \prime } ) } \\ & { \Longrightarrow \exists \pi \in \Pi _ { n } , \mathrm { ~ s u c h ~ t h a t } S = \pi ( S ^ { \prime } ) , \boldsymbol { \mathsf { A } } = \pi ( \boldsymbol { \mathsf { A } } ^ { \prime } ) } \\ & { \Longrightarrow \exists \pi \in \Pi _ { n } , \mathrm { ~ s u c h ~ t h a t } S = \pi ( S ^ { \prime } ) , I ^ { ( S ) } = \pi ( I ^ { ( S ^ { \prime } ) } ) , \boldsymbol { \mathsf { A } } = \pi ( \boldsymbol { \mathsf { A } } ^ { \prime } ) } \\ & { \Longrightarrow \exists \pi \in \Pi _ { n } , \mathrm { ~ s u c h ~ t h a t } S = \pi ( S ^ { \prime } ) , \tilde { \boldsymbol { \mathsf { A } } } = \pi ( \boldsymbol { \mathsf { A } } ^ { \prime } ) } \\ & { \Longrightarrow \forall v _ { 1 } \in S , v _ { 2 } \in S ^ { \prime } , v _ { 1 } = \pi ( v _ { 2 } ) , \mathrm { ~ w e ~ h a v e ~ G N N } ( v _ { 1 } , \tilde { \boldsymbol { \mathsf { A } } } ) = \mathrm { G N N } ( v _ { 2 } , \tilde { \boldsymbol { \mathsf { A } } } ^ { \prime } ) } \\ & { \Longrightarrow \boldsymbol { \mathsf { A } } \mathrm { G G } ( \{ \mathrm { G N N } ( v _ { 1 } , \tilde { \boldsymbol { \mathsf { A } } } ) | v _ { 1 } \in S \} ) = \boldsymbol { \mathsf { A } } \mathrm { G G } ( \{ \mathrm { G N N } ( v _ { 2 } , \tilde { \boldsymbol { \mathsf { A } } } ^ { \prime } ) | v _ { 2 } \in S ^ { \prime } \} ) , } \end{array}
+$$
+
+which concludes the proof.
+
+# B PROOF OF LEMMA 1
+
+We first note that for a most powerful 1-WL-GNN, after a message passing layer, gives different embeddings to any two nodes that 1-WL gives different colors to after one iteration. So we only need to show how many iterations 1-WL takes to converge in any graph.
+
+Note that if two nodes are given different colors by 1-WL at some iteration (they are discriminated by 1-WL), their colors are always different in any future iteration. And if at some iteration, all nodes’ colors are the same as their colors in the last iteration, then 1-WL will stop (1-WL fails to discriminate any more nodes and has converged). Therefore, before termination, 1-WL will increase its total number of colors by at least 1 after every iteration. Because there are at most $n$ different final colors given an $n$ -node graph, 1-WL takes at most $n - 1 = { \mathcal { O } } ( n )$ iterations before assigning all nodes different colors.
+
+Now it suffices to show that there exists a $n$ -node graph that 1-WL takes ${ \mathcal { O } } ( n )$ iterations to converge. Suppose there is a linked list of $n$ nodes (a path). Then by simple calculation, it takes $\lceil n / 2 \rceil$ iterations for 1-WL to converge, which concludes the proof.
+
+# C PROOF OF THEOREM 2
+
+Our proof has two steps. First, we would like to show that there are $\omega ( n ^ { \epsilon } )$ nodes that are locally $h$ -isomorphic to each other. Then, we prove that among these nodes, there are at least $\omega ( n ^ { 2 \epsilon } )$ pairs of nodes such that there exists another node constructing locally $h$ non-isomorphic links with either of the two nodes in each node pair.
+
+Step 1. Consider an arbitrary node $v$ and denote the subgraph induced by the nodes that are at most $h$ -hop away from $v$ as $G _ { v } ^ { ( h ) }$ (the $h$ -hop enclosing subgraph of $v$ ). As each node is with degree $d = \mathcal { O } ( \log ^ { \frac { 1 - \epsilon } { 2 h } } n )$ , then the number of nodes in $G _ { v } ^ { ( h ) }$ , denoted by $| V ( G _ { v } ^ { ( h ) } ) |$ , satisfies
+
+$$
+| V ( G _ { v } ^ { ( h ) } ) | \leq \sum _ { i = 0 } ^ { h } d ^ { i } = \mathcal { O } ( d ^ { h } ) = \mathcal { O } ( \log ^ { \frac { 1 - \epsilon } { 2 } } n ) .
+$$
+
+We set the max $K = \operatorname* { m a x } _ { v \in V } | V ( G _ { v } ^ { ( h ) } ) |$ and thus $K = \mathcal { O } ( \log ^ { \frac { 1 - \epsilon } { 2 } } n )$
+
+Now we expand subgraphs $G _ { v } ^ { ( h ) }$ to $\bar { G } _ { v } ^ { ( h ) }$ by adding $K - | V ( G _ { v } ^ { ( h ) } ) |$ independent nodes for each node $v \in V$ . Then, all $\bar { G } _ { v } ^ { ( h ) }$ have the same number of nodes, which is $K$ , though they may not be connected graphs.
+
+Next, we consider the number of non-isomorphic graphs over $K$ nodes. Actually, the number of nonisomorphic graph structures over $K$ nodes is bounded by $2 ^ { \binom { K } { 2 } } = \exp ( \mathcal { O } ( \log ^ { 1 - \epsilon } n ) ) = o ( n ^ { 1 - \epsilon } )$ .
+
+Therefore, due to the pigeonhole principle, there exist $n / o ( n ^ { 1 - \epsilon } ) = \omega ( n ^ { \epsilon } )$ many nodes $v$ whose $\bar { G } _ { v } ^ { ( h ) }$ are isomorphic to each other. Denote the set of these nodes as $V _ { i s o }$ , which consist of nodes that are all locally $h$ -isomorphic to each other. Next, we focus on looking for other nodes to form locally $h$ -non-isomorphic links with nodes $V _ { i s o }$ .
+
+Step 2. Let us partition $V _ { i s o } = \cup _ { i = 1 } ^ { q } V _ { i }$ so that for all nodes in $V _ { i }$ , they share the same first-hop neighbor sets. Then, consider any pair of nodes $u , v$ such that $u , v$ are from different $V _ { i }$ ’s. Then, we may pick one $u$ ’s first-hop neighbor $w$ that is not $v$ ’s first-hop neighbor. We know such $w$ exists because of the definition of $V _ { i }$ . As $w$ is $u$ ’s first-hop neighbor and is not $v$ ’s first-hop neighbor, $( u , w )$ and $( v , w )$ are not locally 1-isomorphic and thus not locally $h$ -isomorphic. Therefore, based on this partition, we know the number of node pairs $u , v$ such that there exists another node $w$ making $( u , w )$ and $( v , w )$ not locally $h$ -isomorphic is at least
+
+$$
+Y \geq \prod _ { \substack { i , j = 1 , i \neq j } } ^ { q } | V _ { i } | | V _ { j } | = \frac { 1 } { 2 } \left[ ( \sum _ { i = 1 } ^ { q } | V _ { i } | ) ^ { 2 } - \sum _ { i = 1 } ^ { q } | V _ { i } | ^ { 2 } \right] .
+$$
+
+Because of the definitions of the partition, $\begin{array} { r } { \sum _ { i = 1 } ^ { q } | V _ { i } | = | V _ { i s o } | = \omega ( n ^ { \epsilon } ) } \end{array}$ and the size of each $V _ { i }$ satisfies
+
+$$
+1 \leq | V _ { i } | \leq d _ { w } = \mathcal { O } ( \log ^ { \frac { 1 - \epsilon } { 2 h } } n ) ,
+$$
+
+where $w$ is one of the common first-hop neighbors shared by all nodes in $V _ { i }$ and $d _ { w }$ is its degree.
+
+By plugging in the range of $| V _ { i } |$ , Eq.12 leads to
+
+$$
+Y \ge \frac { 1 } { 2 } ( \omega ( n ^ { 2 \epsilon } ) - \omega ( n ^ { \epsilon } ) \mathcal { O } ( \log ^ { \frac { 1 - \epsilon } { 2 h } } n ) ) = \omega ( n ^ { 2 \epsilon } ) ,
+$$
+
+which concludes the proof.
+
+# D MORE DETAILS ABOUT BASELINES
+
+We include baselines achieving top performances on the OGB Link Prediction Leaderboard1. All the methods have their open-sourced code and paper available from the leaderboard. We adopt the numbers published on the leaderboard if available, otherwise we run the method ourselves using the open-sourced code. For the baseline GCN+LRGA, its default hyperparameters result in out of GPU memory on ogbl-citation, even we use an NVIDIA V100 GPU with 32GB memory. Thus, we have to reduce its hidden dimension to 16 and matrix rank to 10. It is possible that it can achieve better performance with a larger hidden dimension and larger matrix rank using a GPU with a larger memory. Despite this, GCN+LRGA generally performs second to best among all methods.
+
+We implemented SEAL using the PyTorch Geometric (Fey & Lenssen, 2019) package. Following the original paper (Zhang & Chen, 2018), we adopt a SortPooling layer (Zhang et al., 2018) after the GCN layers to readout the subgraph. For all datasets, SEAL only used a fixed $1 \%$ to $10 \%$ of all the available training edges as the positive training links, and sampled an equal number of negative training links randomly. SEAL showed excellent performance even without using the full training data, which indicates its strong inductive learning ability. Due to using different labeled subgraphs for different links, SEAL generally has longer running time than GAE methods. On the largest ogbl-citation graph, SEAL takes about 7 hours to finishing its training of 10 epochs, and takes another 28 hours to evaluate the validation and test MRR each. For ogbl-ppa, SEAL takes about 20 hours to train for 20 epochs and takes about 4 hours for evaluation. The other two datasets are finished within hours. We will release all our code for reproducing the experimental results.

parse/train/8q_ca26L1fz/8q_ca26L1fz_content_list.json

@@ -0,0 +1,1830 @@
+[
+    {
+        "type": "text",
+        "text": "REVISITING GRAPH NEURAL NETWORKS FOR LINK PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph neural networks (GNNs) have achieved great success in recent years. Three most common applications include node classification, link prediction, and graph classification. While there is rich literature on node classification and graph classification, GNNs for link prediction is relatively less studied and less understood. Two representative classes of methods exist: GAE and SEAL. GAE (Graph Autoencoder) first uses a GNN to learn node embeddings for all nodes, and then aggregates the embeddings of the source and target nodes as their link representation. SEAL extracts a subgraph around the source and target nodes, labels the nodes in the subgraph, and then uses a GNN to learn a link representation from the labeled subgraph. In this paper, we thoroughly discuss the differences between these two classes of methods, and conclude that simply aggregating node embeddings does not lead to effective link representations, while learning from properly labeled subgraphs around links provides highly expressive and generalizable link representations. Experiments on the recent large-scale OGB link prediction datasets show that SEAL has up to $19 5 \\%$ performance gains over GAE methods, achieving new state-of-the-art results on 3 out of 4 datasets. ",
+        "bbox": [
+            233,
+            266,
+            764,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            513,
+            336,
+            530
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Link prediction is to predict potential or missing links connecting pairwise nodes in a network. It has wide applications in various fields, such as friend recommendation in social networks (Adamic & Adar, 2003), movie recommendation in Netflix (Bennett et al., 2007), protein-protein interaction prediction (Qi et al., 2006), and knowledge graph completion (Nickel et al., 2015), etc. ",
+        "bbox": [
+            174,
+            545,
+            823,
+            601
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Traditional link prediction approaches include heuristic methods, embedding methods, and featurebased methods. Heuristic methods compute some heuristic node similarity scores as the likelihood of links (Liben-Nowell & Kleinberg, 2007), such as common neighbors, preferential attachment (Barabasi & Albert, 1999), and Katz index (Katz, 1953), which can be regarded as some ´ predefined graph structure features. Embedding methods, including matrix factorization (MF) and Node2vec (Grover & Leskovec, 2016), learn free-parameter node embeddings from the observed network transductively, thus do not generalize to unseen nodes and networks. Feature-based methods only use explicit node features yet do not consider the graph structure. Recently, graph neural networks (GNNs) emerged to be powerful tools for learning over graph-structured data (Scarselli et al., 2009; Bruna et al., 2013; Duvenaud et al., 2015; Li et al., 2015; Kipf & Welling, 2016a; Niepert et al., 2016; Dai et al., 2016), and have been successfully used in link prediction as well (Kipf & Welling, 2016b; Zhang & Chen, 2018; You et al., 2019; Chami et al., 2019; Li et al., 2020). ",
+        "bbox": [
+            174,
+            608,
+            823,
+            775
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There are two main types of GNN-based link prediction methods. One is Graph Autoencoder (Kipf & Welling, 2016b), where a GNN is first applied to the entire network to learn an embedding vector for each node. Then the embeddings of the source and target nodes are aggregated to predict the target link. The second type is SEAL (Zhang & Chen, 2018; Li et al., 2020), where an enclosing subgraph is extracted around each target link. Then the nodes in each enclosing subgraph are labeled differently according to their distances to the source and target nodes. Finally a GNN is applied to each enclosing subgraph to learn a link representation for link prediction. At first glance, both methods seem to learn graph structure features associated with the target link, and leverage these structure features for link prediction. However, as we will see, the two methods have fundamentally different power in terms of learning the structural representations of links. ",
+        "bbox": [
+            174,
+            781,
+            825,
+            921
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/cb0de5341280f60df880d25ad447e1303069e49387c26cc501083367c65cb43a.jpg",
+        "image_caption": [
+            "Figure 1: The structural roles of link $( v _ { 1 } , v _ { 2 } )$ and link $( v _ { 1 } , v _ { 3 } )$ are different, but GAE will assign equal probabilities to them. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            92,
+            359,
+            159
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We first show that by individually learning source and target node embeddings, GAE methods cannot differentiate links with different structural roles. To intuitively understand this, we give an example in Figure 1. In this graph, nodes $v _ { 2 }$ and $v _ { 3 }$ have the same structural roles (symmetric/isomorphic to each other). A GAE will learn the same node embeddings for $v _ { 2 }$ and $v _ { 3 }$ , thus giving the same predicted probabilities for link $( v _ { 1 } , v _ { 2 } )$ and link $( v _ { 1 } , v _ { 3 } )$ . However, the structural roles of link $( v _ { 1 } , v _ { 2 } )$ and link $( v _ { 1 } , v _ { 3 } )$ are apparently different – $v _ { 1 }$ intuitively should have unequal probabilities connecting to $v _ { 2 }$ and $v _ { 3 }$ . Next, we propose a labeling trick, which gives a label to each node as its additional feature, where the source and target nodes are labeled differently from the rest. We show that combined with the labeling trick, a sufficiently expressive GNN can learn the same representations for two links if and only if their structural roles are the same within the graph. This way, $( v _ { 1 } , v _ { 2 } )$ and $( v _ { 1 } , v _ { 3 } )$ will be predicted differently in Figure 1. We further show that SEAL is such an example. Finally, we give a more practical definition of isomorphism, called local isomorphism, which defines two nodes/links as isomorphic if their local neighborhood subgraphs are isomorphic. We argue that GNNs for link prediction should target on local-isomorphism-discriminating. ",
+        "bbox": [
+            390,
+            103,
+            823,
+            228
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            229,
+            825,
+            339
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We conduct a thorough comparison among different link prediction methods, including SEAL and various GAE and embedding methods, on the recent large-scale Open Graph Benchmark (OGB) datasets (Hu et al., 2020). We show that SEAL with the labeling trick has up to $19 5 \\%$ higher Hits $@ 1 0 0$ than GAE methods, achieving new state-of-the-art results on 3 out of 4 datasets. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            402
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            422,
+            339,
+            439
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we formally define the notions of graph, permutation, isomorphism, and GNN. ",
+        "bbox": [
+            171,
+            454,
+            789,
+            469
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Definition 1. (Graph). We consider an undirected graph $\\mathcal { G } = ( V , E , \\pmb { \\Delta } )$ , where $V = \\{ 1 , 2 , \\dots , n \\}$ is the set of n vertices, $E \\subseteq V \\times V$ is the set of edges, and $\\pmb { \\mathsf { A } } \\in \\mathbb { R } ^ { n \\times n \\times k }$ contains the node and edge features with its diagonal components $\\mathsf { \\pmb { A } } _ { i , i } ,$ : denoting node attributes and off-diagonal components $\\mathsf { \\pmb { A } } _ { i , j } ,$ : denoting edge attributes. We further use $\\pmb { A } \\in \\mathsf { \\bar { \\{ 0 , 1 \\} } } ^ { n \\times n }$ to denote the adjacency matrix of $\\mathcal { G }$ with $A _ { i , j } = 1$ iff $( i , j ) \\in E$ . If there are no node/edge features, we let $\\pmb { \\mathsf { A } } = \\pmb { A }$ . Otherwise, $\\pmb { A }$ can be regarded as the first slice of $\\pmb { \\mathsf { A } }$ , i.e., $A = \\pmb { \\mathsf { A } } _ { : , : , 1 }$ . ",
+        "bbox": [
+            173,
+            472,
+            825,
+            558
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Definition 2. (Permutation) $A$ node permutation $\\pi$ is a bijective mapping from $\\{ 1 , 2 , \\ldots , n \\}$ to $\\{ 1 , 2 , \\ldots , n \\}$ . All $n$ ! possible $\\pi$ ’s constitute the permutation group $\\Pi _ { n }$ . We define $\\pi ( S ) = \\{ \\pi ( i ) | i \\in$ $S \\}$ when $S$ is a subset of $\\{ 1 , 2 , \\ldots , n \\}$ . We further define the permutation of $\\pmb { \\mathsf { A } }$ as $\\pi ( \\pmb { \\mathsf { A } } )$ , where $\\pi ( \\pmb { \\ A } ) _ { \\pi ( i ) , \\pi ( j ) , : } = \\pmb { \\ A } _ { i , j , : }$ . In other words, $\\pi ( \\mathbf { A } ) _ { i , j , : } = \\pmb { \\Delta } _ { \\pi ^ { - 1 } ( i ) , \\pi ^ { - 1 } ( j ) , }$ : . ",
+        "bbox": [
+            174,
+            559,
+            825,
+            618
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Definition 3. (Set isomorphism) Given two $n$ -node graphs $\\mathcal { G } = ( V , E , \\pmb { \\Delta } )$ , $\\mathcal { G } ^ { \\prime } = ( V ^ { \\prime } , E ^ { \\prime } , \\pmb { \\Delta } ^ { \\prime } )$ , and two node sets $S \\subseteq V$ , $S ^ { \\prime } \\subseteq V ^ { \\prime }$ , we say $( S , \\pmb { \\mathsf { A } } )$ and $( S ^ { \\prime } , { \\pmb { \\mathsf { A } } } ^ { \\prime } )$ are isomorphic (denoted by $( S , \\pmb { \\mathsf { A } } ) \\simeq ( S ^ { \\prime } , \\pmb { \\mathsf { A } } ^ { \\prime } ) )$ ) $i f \\exists \\pi \\in \\Pi _ { n }$ such that $S = \\pi ( S ^ { \\prime } )$ and $\\pmb { \\mathsf { A } } = \\pi ( \\pmb { \\mathsf { A } } ^ { \\prime } )$ . ",
+        "bbox": [
+            173,
+            622,
+            825,
+            669
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "When $( V , \\pmb { \\mathsf { A } } ) \\simeq ( V ^ { \\prime } , \\pmb { \\mathsf { A } } ^ { \\prime } )$ , we say two graphs $\\mathcal { G }$ and $\\mathcal { G } ^ { \\prime }$ are isomorphic (abbreviated as $\\mathsf { \\pmb { A } } \\simeq \\mathsf { \\pmb { A } } ^ { \\prime }$ because $V = \\pi ( V ^ { \\prime } )$ for any $\\pi$ ). Note that set isomorphism is more strict than graph isomorphism, because it not only requires graph isomorphism, but also requires the permutation maps a specific subset $S$ to another subset $S ^ { \\bar { \\prime } }$ . When $S \\subset V$ and $S ^ { \\prime } \\subset V ^ { \\prime }$ , we are often more concerned with the case of $\\pmb { \\mathsf { A } } = \\pmb { \\mathsf { A } } ^ { \\prime }$ , where we are to find isomorphic node sets in the same graph (automorphism). For example, when $S = \\{ i \\} , S ^ { \\prime } = \\{ j \\}$ (single node case) and $( i , \\pmb { \\mathsf { A } } ) , ( j , \\pmb { \\mathsf { A } } )$ are isomorphic, it means $i$ and $j$ are on the same orbit of graph $\\pmb { \\mathsf { A } }$ (i.e., they have symmetric positions/same structural roles within the graph). An example is $v _ { 2 }$ and $v _ { 3 }$ in Figure 1. ",
+        "bbox": [
+            173,
+            679,
+            825,
+            792
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Definition 4. (Invariant function) A function $f$ defined over the space of $( S , \\pmb { \\mathsf { A } } )$ is invariant if $\\forall \\pi \\in \\Pi _ { n }$ , $f ( S , \\mathbf { A } ) = f ( \\pi ( S ) , \\pi ( \\mathbf { A } ) )$ . ",
+        "bbox": [
+            173,
+            795,
+            823,
+            825
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Definition 5. (GNN) $A$ GNN is an invariant function mapping from the space of $( S , \\pmb { \\mathsf { A } } )$ to $\\mathbb { R } ^ { d }$ . More specifically, a GNN first performs multiple invariant message passing operations to compute a node embedding $z _ { i } = \\mathbf { G N N } ( i , \\mathbf { A } )$ for all $i \\in S$ , and then performs a set aggregation (pooling) over $\\{ z _ { i } | i \\in S \\}$ , written as $\\mathrm { A G G } ( \\{ z _ { i } | i \\in S \\} )$ , as the set $S$ ’s representation $\\mathrm { G N N } ( S , \\pmb { \\mathsf { A } } )$ . ",
+        "bbox": [
+            173,
+            828,
+            825,
+            886
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Note that, when $| S | = 1$ , the set aggregation is often an identity mapping. In graph classification $S = V )$ , we use a graph pooling layer over node embeddings to compute the graph representation. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 GAE AND STRUCTURAL LINK REPRESENTATION",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            606,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we review how GAE methods predict links, and show that simply aggregating node embeddings learned by a GNN cannot lead to effective link representations. We use $\\pmb { \\mathsf { A } }$ to denote the incomplete network to perform link prediction. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            178
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 GAE FOR LINK PREDICTION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            196,
+            411,
+            210
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Graph Autoencoder (GAE) methods (Kipf & Welling, 2016b) first use a GNN to compute a node embedding $z _ { i }$ for each node $i$ , and then use $f ( z _ { i } , z _ { j } )$ to predict the link $( i , j )$ : ",
+        "bbox": [
+            173,
+            222,
+            825,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9aeebd2be66ec08815660fddb5fcf7a8459ab4d5bcccd3cc3deaf02fa9106daf.jpg",
+        "text": "$$\n\\hat { A } _ { i , j } = f ( z _ { i } , z _ { j } ) , \\mathrm { w h e r e } z _ { i } = \\mathrm { G N N } ( i , \\mathsf { A } ) , z _ { j } = \\mathrm { G N N } ( j , \\mathsf { A } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            261,
+            700,
+            281
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { A } _ { i , j }$ is the predicted score for link $( i , j )$ . The model is trained to maximize the likelihood of reconstructing the true adjacency matrix. The original GAE uses a two-layer GCN (Kipf & Welling, 2016a) as the GNN, and let $f ( z _ { i } , z _ { j } ) : = \\sigma ( z _ { i } ^ { \\top } z _ { j } )$ . In principle, we can replace GCN with any message passing neural network (Gilmer et al., 2017), and use an MLP over the aggregation of $z _ { i }$ and $z _ { j }$ as the $f ( z _ { i } , z _ { j } )$ . Popular aggregation functions include concatenation, mean and Hadamard product, etc. In the following, we will use GAE to denote a general class of GNN-based link prediction methods, without differentiating the specific choices of GNN and $f$ . ",
+        "bbox": [
+            173,
+            291,
+            825,
+            390
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 GAE CAN LEARN STRUCTURAL NODE REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            410,
+            611,
+            422
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Following (Srinivasan & Ribeiro, 2020; Li et al., 2020), we first define most expressive structural representations for nodes and links. Then we relate them to GAE-learned node embeddings and show that GAE is not capable of learning structural link representations. ",
+        "bbox": [
+            173,
+            435,
+            825,
+            478
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 6. Given an invariant function $\\Gamma ( \\cdot )$ , $\\Gamma ( S , \\pmb { \\mathsf { A } } )$ is a most expressive structural representation for $( S , \\pmb { \\mathsf { A } } )$ if $\\forall ( S , \\pmb { \\mathsf { A } } , S ^ { \\prime } , \\pmb { \\mathsf { A } } ^ { \\prime } )$ , $\\Gamma ( S , \\pmb { \\mathsf { A } } ) = \\Gamma ( S ^ { \\prime } , \\pmb { \\mathsf { A } } ^ { \\prime } ) \\Leftrightarrow ( S , \\pmb { \\mathsf { A } } ) \\simeq ( S ^ { \\prime } , \\pmb { \\mathsf { A } } ^ { \\prime } ) .$ . ",
+        "bbox": [
+            174,
+            482,
+            823,
+            515
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For simplicity, we will briefly use “structural representation” to denote most expressive structural representation in the rest of the paper. We will omit $\\pmb { \\mathsf { A } }$ if it is clear from context. We call $\\Gamma ( i , \\pmb { \\mathsf { A } } )$ a structural node representation for $i$ , and call $\\Gamma ( \\{ i , j \\} , \\mathbf { A } )$ a structural link representation for $( i , j )$ . ",
+        "bbox": [
+            173,
+            525,
+            825,
+            569
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The above definition indicates that two node sets have the same structural representations if and only if they are isomorphic to each other. In the same graph $\\pmb { \\mathsf { A } }$ , structural representations uniquely mark the structural roles of nodes or node sets. This is in contrast to positional node embeddings such as DeepWalk (Perozzi et al., 2014) and matrix factorization (Mnih & Salakhutdinov, 2008), where two isomorphic nodes can have different node embeddings (Ribeiro et al., 2017). ",
+        "bbox": [
+            174,
+            574,
+            825,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "So why do we need to define structural representations? From a node classification point of view, it is because two isomorphic nodes in a network are perfectly symmetric to each other, and should be indistinguishable using any labeling functions on graphs (i.e., they should have the same ground truth $y$ ). Learning a structural node representation can guarantee that isomorphic nodes are always classified into the same class. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            720
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Then, a natural question to ask is, do GNNs learn structural node representations? The answer is no. Recall that $( { \\dot { i } } , \\mathbf { A } ) \\simeq ( j , \\mathbf { A } ^ { \\prime } ) \\Rightarrow \\mathbf { A } \\simeq \\mathbf { A } ^ { \\prime }$ . If a GNN can learn structural node representations, we can always use it for graph isomorphism test by checking whether there exist two nodes in two graphs sharing the same structural node representation. In fact, existing GNNs’ graph discriminating power is bounded by the Weisfeiler-Lehman (WL) test (Morris et al., 2019; Maron et al., 2019), which provably fails to distinguish certain non-isomorphic graphs (Cai et al., 1992). Despite this, GNNs/WL are still powerful enough to learn representations that can distinguish almost all nonisomorphic nodes and graphs (Babai & Kucera, 1979). ",
+        "bbox": [
+            173,
+            727,
+            825,
+            840
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For easy analysis, we assume there exists a node-most-expressive GNN that can output structural node representations thus able to distinguish all non-isomorphic nodes. Despite this, the techniques we will present are not limited to node-most-expressive GNNs, but also benefit practical GNNs. ",
+        "bbox": [
+            174,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 7. A GNN is node-most-expressive if $\\forall ( i , \\mathsf { \\pmb A } , j , \\mathsf { \\pmb A } ^ { \\prime } )$ , $\\mathrm { G N N } ( i , \\pmb { \\mathsf { A } } ) = \\mathrm { G N N } ( j , \\pmb { \\mathsf { A } } ^ { \\prime } ) \\Leftrightarrow$ $( i , \\mathsf { \\pmb A } ) \\simeq ( j , \\mathsf { \\pmb A } ^ { \\prime } )$ . ",
+        "bbox": [
+            174,
+            892,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recall that GAE first uses a GNN to compute node embeddings. Therefore, GAE with a node-mostexpressive GNN is able to leverage structural node representations for link prediction. ",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 GAE CANNOT LEARN STRUCTURAL LINK REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            148,
+            637,
+            162
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The next question to ask is whether GAE learns structural link representations. That is, does the aggregation of structural node representations of $i$ and $j$ result in a structural link representation of $( i , j ) ^ { \\prime }$ ? The answer is no, as shown in previous works (Srinivasan & Ribeiro, 2020; Zhang & Chen, 2020). We have also illustrated it in the introduction. In Figure 1, we have two isomorphic nodes $v _ { 2 }$ and $v _ { 3 }$ , thus $v _ { 2 }$ and $v _ { 3 }$ will have the same structural node representation. By aggregating structural node representations as link representations, GAE will assign $( v _ { 1 } , v _ { 2 } )$ and $( v _ { 1 } , v _ { 3 } )$ the same link representation and predict them to have equal probabilities of forming a link. However, $( v _ { 1 } , v _ { 2 } )$ and $( v _ { 1 } , v _ { 3 } )$ apparently have different structural link representations, which indicates that ",
+        "bbox": [
+            174,
+            172,
+            825,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1. Even with a node-most-expressive GNN, GAE cannot learn structural link representations. ",
+        "bbox": [
+            176,
+            287,
+            823,
+            315
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The root cause of this problem is that GAE learns representations for the source and target nodes individually, without considering their relative positions and associations. For example, although $v _ { 2 }$ and $v _ { 3 }$ are perfectly symmetric in the graph, when considering the source node $v _ { 1 }$ to predict link from, $v _ { 2 }$ and $v _ { 3 }$ ’s positions w.r.t. $v _ { 1 }$ are no longer symmetric. ",
+        "bbox": [
+            173,
+            325,
+            825,
+            381
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 HOW TO LEARN STRUCTURAL LINK REPRESENTATIONS? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            401,
+            671,
+            416
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss how to enable GNNs to learn structural link representations with a simple labeling trick, and show that SEAL is a valid example to learn structural link representations. ",
+        "bbox": [
+            173,
+            430,
+            823,
+            459
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 LABELING TRICK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            476,
+            334,
+            489
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first introduce the labeling trick. ",
+        "bbox": [
+            176,
+            501,
+            411,
+            516
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 8. (Labeling trick) Given $( S , \\pmb { \\mathsf { A } } )$ , we stack a diagonal labeling matrix $\\pmb { I } ^ { ( S ) } \\in \\mathbb { R } ^ { n \\times n }$ in the third dimension of $\\pmb { \\mathsf { A } }$ to get a new $\\tilde { \\textbf { A } } \\in \\mathbb { R } ^ { n \\times n \\times ( k + 1 ) }$ , where $\\pmb { I }$ satisfies: $\\forall \\pi \\ \\in \\ \\Pi _ { n }$ , (1) $\\pmb { I } ^ { ( S ) } = \\pi ( \\pmb { I } ^ { ( S ^ { \\prime } ) } ) \\Rightarrow S = \\pi ( S ^ { \\prime } )$ , and (2) $S = \\pi ( S ^ { \\prime } ) , \\pmb { \\mathrm { A } } = \\pi ( \\pmb { \\mathrm { A } } ^ { \\prime } ) \\Rightarrow \\pmb { I } ^ { ( S ) } = \\pi ( \\pmb { I } ^ { ( S ^ { \\prime } ) } )$ . A simplest labeling trick is to let $I _ { i i } ^ { ( S ) } = 1$ if $i \\in S$ otherwise $O$ . ",
+        "bbox": [
+            174,
+            517,
+            825,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that the notation $\\tilde { \\pmb { A } }$ should actually depend on $S$ . For convenience, we omit such dependence on $S$ and infer it from the context. The first condition in Definition 8 requires the labeling matrix to identify the target node set $S$ ; and the second condition requires the labeling trick to be permutation equivariant, i.e., when $( S , A )$ and $( S ^ { \\prime } , A ^ { \\prime } )$ are isomorphic under $\\pi$ , the corresponding nodes $i = \\pi ( j )$ always have the same label. Essentially, the labeling trick distinguishes nodes in $S$ from the rest nodes. It can be as simple as only giving label 1 to nodes in $S$ and otherwise 0. Next, we show that with the labeling trick, a node-most-expressive GNN can learn structural link representations. ",
+        "bbox": [
+            173,
+            593,
+            825,
+            693
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. If a GNN is node-most-expressive, then with an injective set aggregation function AGG in Definition 5, $\\mathrm { G N N } ( S , { \\tilde { \\mathbf { A } } } ) = \\mathrm { G N N } ( S ^ { \\prime } , { \\tilde { \\mathbf { A } } } ^ { \\prime } ) \\Leftrightarrow ( S , \\mathbf { A } ) \\simeq ( S ^ { \\prime } , \\mathbf { A } ^ { \\prime } )$ for any $S , \\pmb { \\mathsf { A } } , S ^ { \\prime } , \\pmb { \\mathsf { A } } ^ { \\prime }$ . ",
+        "bbox": [
+            173,
+            694,
+            826,
+            728
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We include all the proofs in the appendix. Theorem 1 implies that $\\mathbf { G N N } ( S , \\tilde { \\mathbf { A } } )$ is a structural representation for $( S , \\pmb { \\mathsf { A } } )$ . Recall Definition 5 defines $\\mathrm { G N N } ( S , \\tilde { \\mathbf { A } } ) = \\mathrm { A G G } ( \\{ \\mathrm { G N N } ( i , \\tilde { \\mathbf { A } } ) | i \\in S \\} )$ ). The above theorem indicates that although directly aggregating structural node representations learned from the original graph $\\pmb { \\mathsf { A } }$ does not lead to structural link representations, an injective aggregation over the structural node representations learned from the labeled graph $\\tilde { \\pmb { A } }$ does lead to structural link representations. How intuitively is it possible? Let’s return to the example in Figure 1. When we want to predict link $( v _ { 1 } , v _ { 2 } )$ , we can mark $v _ { 1 } , v _ { 2 }$ with a different label from the rest nodes, as shown by the different color in Figure 2 left. With the source and target nodes labeled, when the GNN is computing $v _ { 2 }$ ’s embedding, it is also “aware” of the source node $v _ { 1 }$ , instead of the previous agnostic way that treats $v _ { 1 }$ the same as other nodes. And when we want to predict link $( v _ { 1 } , v _ { 3 } )$ , we can again mark $v _ { 1 } , v _ { 3 }$ with a different label, as shown in Figure 2 right. This way, $v _ { 2 }$ and $v _ { 3 }$ ’s structural node representations are no longer the same in the two differently labeled graphs because of their different relative positions w.r.t. $v _ { 1 }$ , and we are able to give different predictions to $( v _ { 1 } , v _ { 2 } )$ and $( v _ { 1 } , v _ { 3 } )$ . ",
+        "bbox": [
+            173,
+            737,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/0c80af1e196f06c0d917383391b3bcd048f7a9aab2dfb11f64f4175ed75c2d87.jpg",
+        "image_caption": [
+            "Figure 2: When we predict $( v _ { 1 } , v _ { 2 } )$ , we will label these two nodes differently from the rest, so that a GNN is aware of the target link when computing $v _ { 1 }$ and $v _ { 2 }$ ’s embeddings. Similarly, when predicting $( v _ { 1 } , v _ { 3 } )$ , nodes $v _ { 1 } , v _ { 3 }$ will be labeled differently. The aggregated embedding of $v _ { 1 } , v _ { 2 }$ in the left graph will be different from the aggregated embedding of $v _ { 1 } , v _ { 3 }$ in the right graph, enabling GNNs to predict $( v _ { 1 } , v _ { 2 } )$ and $( v _ { 1 } , v _ { 3 } )$ differently. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            308,
+            97,
+            687,
+            166
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 SEAL CAN LEARN STRUCTURAL LINK REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            261,
+            614,
+            275
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will review SEAL (Zhang & Chen, 2018; Li et al., 2020), and show that SEAL exactly uses a valid labeling trick that is able to learn structural link representations. ",
+        "bbox": [
+            174,
+            287,
+            825,
+            318
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "SEAL first extracts an enclosing subgraph ( $h$ -hop ego-network) around the link to predict. ",
+        "bbox": [
+            171,
+            324,
+            764,
+            339
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition 9. (Enclosing subgraph) Given $( S , \\pmb { \\mathsf { A } } )$ , the $h$ -hop enclosing subgraph ${ \\pmb { \\mathsf { A } } } _ { S } ^ { ( h ) }$ of $S$ is the subgraph induced from A by $\\cup _ { i \\in S } \\{ j | d ( j , i ) \\leq h \\}$ , where $d ( j , i )$ is the shortest path distance between nodes $j$ and $i$ . ",
+        "bbox": [
+            174,
+            347,
+            825,
+            390
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Then, SEAL applies a Double Radius Node Labeling (DRNL) to give an integer label to each node within the enclosing subgraph. DRNL assigns different labels to nodes with different distances w.r.t. both the source and target nodes, where the source and target nodes are always labeled 1, and nodes farther away from the source and target nodes get larger labels (starting from 2). For example, nodes with distances 1 and 1 to the source and target nodes will get label 2, and nodes with distances 1 and 2 to the source and target nodes will get label 3. So on and so forth. Finally the labeled enclosing subgraph is fed to a GNN to learn the link representation and output the probability of link existence. ",
+        "bbox": [
+            174,
+            404,
+            825,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It can be easily proved that DRNL satisfies the definition of the labeling trick, because node distances are invariant under permutation. DRNL not only differentiates the source and target nodes from the rest, but also differentiates nodes of different distances to the source and target nodes. The DRNL-labeled graphs also satisfy Theorem 1 and thus can enable a node-most-expressive GNN to learn structural link representations. Moreover, SEAL’s distance-based node labeling scheme is formalized into distance encoding, or $D E$ , in (Li et al., 2020), which theoretically shows that encoding distances between nodes can increase the representation power of normal GNNs. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            607
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "SEAL only uses a subgraph ${ \\pmb { \\mathsf { A } } } _ { S } ^ { ( h ) }$ within $h$ hops from the source and target nodes instead of using the whole graph. This is for practical concerns (just like GAE typically uses less than 3 message passing layers in practice), and will be discussed in detail in Section 5. When $h  \\infty$ , SEAL can also leverage the entire graph and learn structural representations for $( S , \\pmb { \\mathsf { A } } )$ : ",
+        "bbox": [
+            174,
+            613,
+            825,
+            672
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proposition 2. When $h  \\infty$ , SEAL can learn structural link representations with a node-mostexpressive GNN. ",
+        "bbox": [
+            173,
+            679,
+            821,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that although we show a node-most-expressive GNN combining with the labeling trick is able to learn structural link representations, even without a node-most-expressive GNN, the labeling trick can still benefit most link representation learning tasks. For example, in Figure 2, as long as a normal GNN can give different embeddings to $v _ { 2 }$ and $v _ { 3 }$ in the left and right graphs (which is easy for most GNNs), we can still differentiate link $( v _ { 1 } , v _ { 2 } )$ from link $( v _ { 1 } , v _ { 3 } )$ . And this is not possible for GAE. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            805
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Despite the power, the labeling trick introduces extra computational complexity. The reason is that for every link $( i , j )$ to predict, we need to relabel the graph according to $( i , j )$ . The same node $i$ will be labeled differently depending on the target link, and will be given a different node embedding by the GNN when it appears in different links’ labeled graphs. This is different from GAE, where we do not relabel the graph and each node only has a single embedding vector. For a graph with $n$ nodes and $m$ links to predict, GAE needs to apply the GNN ${ \\mathcal { O } } ( n )$ times to compute an embedding for each node, while SEAL needs to apply the GNN $\\mathcal { O } ( m )$ times for all links. When $m \\gg n$ , SEAL has worse time complexity than GAE, which is a trade-off for learning structural link representations. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the previous analysis, we have assumed there exists a node-most-expressive GNN that can discriminate non-isomorphic nodes. Although a practical GNN can also discriminate almost all nonisomorphic nodes, there is little research discussing how to reach this discriminating power. In this section, we analyze GNNs for link prediction from a more practical point of view. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            195
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Practical GNNs usually simulate the 1-dimensional Weisfeiler-Lehman (1-WL) test (Weisfeiler & Lehman, 1968) to iteratively update each node’s hidden state by aggregating its neighbors’ states (we call them 1-WL-GNN). One most powerful 1-WL-GNN is the Graph Isomorphism Network (GIN) (Xu et al., 2018), which achieves theoretically the same discriminating power as 1-WL. ",
+        "bbox": [
+            174,
+            202,
+            823,
+            258
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Although showing 1-WL-GNN’s maximum discriminating power, previous GNN research has not discussed how many message passing layers are required to reach this theoretical power. We therefore introduce the following lemma. ",
+        "bbox": [
+            176,
+            265,
+            821,
+            306
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1. Given a graph with n nodes, a most powerful 1-WL-GNN takes up to ${ \\mathcal { O } } ( n )$ message passing layers to discriminate all non-isomorphic nodes that 1-WL can discriminate. ",
+        "bbox": [
+            173,
+            315,
+            823,
+            344
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1 suggests that 1-WL-GNN needs a number of message passing layers of the same order as the number of nodes in the graph to reach its maximum discriminating power. However, practical GNNs usually only use a small number of message passing layers (such as 1 or 2) while still achieving good performance. This perhaps suggests that in practice, we do not necessarily need to find nodes/links that are exactly isomorphic to each other. Instead, nodes/links which are locally isomorphic could even more strongly suggest they should be classified into the same class. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            444
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Definition 10. (Local $h$ -isomorphism) $\\forall ( S , \\pmb { \\mathsf { A } } , S ^ { \\prime } , \\pmb { \\mathsf { A } } ^ { \\prime } )$ , $( S , \\pmb { \\mathsf { A } } )$ and $( S ^ { \\prime } , { \\pmb { \\mathsf { A } } } ^ { \\prime } )$ are locally $h$ -isomorphic to each other if $\\mathbf { \\Sigma } ( S , \\mathbf { A } _ { S } ^ { ( h ) } ) \\simeq ( S ^ { \\prime } , \\mathbf { A ^ { \\prime } } _ { S ^ { \\prime } } ^ { ( h ) } )$ . ",
+        "bbox": [
+            174,
+            452,
+            825,
+            487
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For two sets $S , S ^ { \\prime }$ , if their tuples with their $h$ -hop enclosing subgraphs $( S , \\pmb { \\mathsf { A } } _ { S } ^ { ( h ) } )$ and $( S ^ { \\prime } , \\pmb { A } _ { S ^ { \\prime } } ^ { \\prime ( h ) } )$ are isomorphic, then we say they are locally -isomorphic. We argue that this is a more useful definition than isomorphism, because isomorphism requires the entire graph looks identical from two sets’ separate views, which is often too strict in practice. If we use the strict definition of isomorphism, we may fail to identify a lot of nodes/links that actually have very similar neighborhood structures. In fact, Babai & Kucera (1979) prove that at least $\\left( n - \\log n \\right)$ nodes in almost all $n$ -node graphs are non-isomorphic to each other. Therefore, it is less meaningful to only assign the same representations to nodes/links when they are strictly isomorphic, and GNNs targeting on isomorphismdiscriminating tend to overfit. In comparison, local $h$ -isomorphism only cares about whether the $h$ -hop neighborhoods are isomorphic, which is more realistic and allows better generalizability. ",
+        "bbox": [
+            173,
+            506,
+            825,
+            647
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With local $h$ -isomorphism, all our previous conclusions using the standard isomorphism definition still apply. For example, GAE with a node-most-expressive GNN can be used to identify locally $h$ -isomorphic nodes, but cannot discriminate locally $h$ -non-isomorphic links. And a node-mostexpressive GNN with the labeling trick (SEAL) can identify locally $h$ -isomorphic node sets, etc. To enable a GNN to focus on local $h$ -isomorphism-discriminating, all we need to do is to set a boundary between the $h$ -hop enclosing subgraph and the rest of the graph, and apply the GNN only to the extracted subgraph within the boundary (possibly use more than $h$ message passing layers). ",
+        "bbox": [
+            173,
+            654,
+            825,
+            751
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, we want to answer a question: in what chance node local $h$ -isomorphism also indicates link local $h$ -isomorphism? If in a graph, two nodes being locally $h$ -isomorphic almost always indicates their links with a third node are locally $h$ -isomorphic, then learning structural link representations with SEAL may no longer be necessary, and using GAE to learn structural node representations may already be enough. In other words, we are interested in how often examples like Figure 1 appear in graphs. Fortunately, we have the following theorem, which shows that there are enough links where only identifying locally $h$ -isomorphic nodes is not enough. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. In any graphs with n nodes and without node/edge features, if the degree of each node in the graph is between 1 and $\\mathcal { O } ( \\log ^ { \\frac { 1 - \\epsilon } { 2 h } } n )$ for any constant $\\epsilon > 0$ , then there exists $\\omega ( n ^ { 2 \\epsilon } )$ many pairs of nodes $u , v$ such that u and $v$ are locally $h$ -isomorphic while there exists another node $w$ such that $( u , w )$ and $( v , w )$ are not locally $h$ -isomorphic. ",
+        "bbox": [
+            174,
+            863,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9c734125f34c026da8a21798398f970b1e10d043c1530619dd035f475b06afad.jpg",
+        "table_caption": [
+            "Table 1: Statistics and evaluation metrics of OGB link prediction datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>#Nodes</td><td>#Edges</td><td>Avg. node deg.</td><td>Density</td><td>Split ratio</td><td>Metric</td></tr><tr><td>ogbl-ppa</td><td>576,289</td><td>30,326,273</td><td>73.7</td><td>0.018%</td><td>70/20/10</td><td>Hits @100</td></tr><tr><td>ogbl-collab</td><td>235,868</td><td>1,285,465</td><td>8.2</td><td>0.0046%</td><td>92/4/4</td><td>Hits@50</td></tr><tr><td>ogbl-ddi</td><td>4,267</td><td>1,334,889</td><td>500.5</td><td>14.67%</td><td>80/10/10</td><td>Hits @20</td></tr><tr><td>ogbl-citation</td><td>2,927,963</td><td>30,561,187</td><td>20.7</td><td>0.00036%</td><td>98/1/1</td><td>MRR</td></tr></table>",
+        "bbox": [
+            225,
+            132,
+            774,
+            199
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            229,
+            341,
+            246
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "There are emerging interests in studying the expressive power of graph neural networks recently. Xu et al. (2018) and Morris et al. (2019) first show that the discriminating power of GNNs performing neighbor aggregation is bounded by the 1-WL test. Many works have since been proposed to increase the power of GNNs by simulating higher-order WL tests (Morris et al., 2019; Maron et al., 2019; Chen et al., 2019). However, most previous works focus on improving GNN’s graph representation power. Little work has been done to analyze GNN’s node/link representation power. Srinivasan & Ribeiro (2020) first formally studied the difference between structural representations of nodes and links. Although showing that structural node representations alone cannot perform link prediction, their way of learning structural link representations is to give up GNNs and instead use Monte Carlo samples of node embeddings learned by network embedding methods. In this paper, we show that GNNs combined with a simple labeling trick can as well learn structural link representations, which reassures using GNNs for link prediction. ",
+        "bbox": [
+            174,
+            262,
+            825,
+            428
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Many works have implicitly assumed that if a model can learn node embeddings well, then combining the pairwise node embeddings can also lead to good link representations (Grover & Leskovec, 2016; Kipf & Welling, 2016b; Hamilton et al., 2017). However, we argue in this paper that by considering the source and target nodes explicitly with the labeling trick, we can aggregate better link representations from node embeddings. Li et al. (2020) studied one particular form of the labeling trick based on distance, and proved that distance encoding can improve 1-WL-GNNs’ expressive power, enabling them to distinguish almost all $( S , \\pmb { \\mathsf { A } } )$ tuples sampled from r-regular graphs. In this paper, we do not focus on improving 1-WL-GNNs’ expressive power, but focus on how to enable a sufficiently expressive GNN to learn structural link representations in any graphs. We also provide a general definition of the labeling trick, and argue that a labeling trick as simple as only giving the source and target nodes 1 and other nodes 0 suffices to enable structural link representation learning. ",
+        "bbox": [
+            173,
+            435,
+            825,
+            588
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            609,
+            326,
+            625
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we compare SEAL, GAE methods, and network embedding methods on the Open Graph Benchmark (OGB) (Hu et al., 2020) datasets. We use all the four link prediction datasets in OGB: ogbl-ppa, ogbl-collab, ogbl-ddi, and ogbl-citation. These datasets adopt realistic train/validation/test splitting methods, such as by resource cost in laboratory (ogbl-ppa), by time (ogbl-collab and ogbl-citation), and by drug target in the body (ogbl-ddi). They are also large-scale (up to 2.9M nodes and $3 0 . 6 \\mathbf { M }$ edges), open-sourced, and have standard evaluation metrics, thus providing an ideal place to benchmark an algorithm’s realistic link prediction power. The evaluation metrics include Hits $@ K$ and MRR. Hits $@ K$ counts the ratio of positive edges ranked at the K-th place or above against all the negative edges. MRR (Mean Reciprocal Rank) computes the reciprocal rank of the true target node against 1,000 negative candidates, averaged over all the true source nodes. Both metrics are higher the better. The statistics are in Table 1. ",
+        "bbox": [
+            173,
+            641,
+            825,
+            794
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Baselines. We consider the following representative models. Except SEAL, all models first compute node embeddings from the original graph and use the Hadamard product between pairwise node embeddings as link representations. The link representations are fed to an MLP for final prediction. ",
+        "bbox": [
+            174,
+            801,
+            821,
+            843
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• MLP: Input node features are directly used as the node embeddings.   \n• Node2vec (Perozzi et al., 2014; Grover & Leskovec, 2016): The node embeddings are the concatenation of node features and Node2vec embeddings.   \n• MF: Use free-parameter node embeddings trained end-to-end as the node embeddings.   \n• GraphSAGE (Hamilton et al., 2017): A GAE method with GraphSAGE as the GNN. • GCN (Kipf & Welling, 2016b): A GAE method with GCN as the GNN.   \n• GCN+LRGA (Puny et al., 2020): A GAE method with LRGA-module-enhanced GCN.   \n• SEAL (Zhang & Chen, 2018): Learn link representations from labeled subgraphs via a GNN. ",
+        "bbox": [
+            181,
+            848,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/0039c705db64ed5aed0a53ae50484b7c321283e6b3947952e279eff2e9468db7.jpg",
+        "table_caption": [
+            "Table 2: Results for ogbl-ppa, ogbl-collab, ogbl-ddi and ogbl-citation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">ogbl-ppa Hits @100 (%)</td><td colspan=\"2\">ogbl-collab Hits @50 (%)</td><td colspan=\"2\">ogbl-ddi Hits @20 (%)</td><td colspan=\"2\">ogbl-citation MRR (%)</td></tr><tr><td>Method</td><td>Validation</td><td>Test</td><td>Validation</td><td>Test</td><td>Validation</td><td>Test</td><td>Validation</td><td>Test</td></tr><tr><td>MLP</td><td>0.46±0.00</td><td>0.46±0.00</td><td>24.02±1.45</td><td>19.27±1.29</td><td></td><td></td><td>28.98±0.14</td><td>29.04±0.13</td></tr><tr><td>Node2vec</td><td>22.53±0.88</td><td>22.26±0.88</td><td>57.03±0.52</td><td>48.88±0.54</td><td>32.92±1.21</td><td>23.26±2.09</td><td>59.44±0.11</td><td>59.64±0.11</td></tr><tr><td>MF</td><td>32.28±4.28</td><td>32.29±0.94</td><td>48.96±0.29</td><td>38.86±0.29</td><td>33.70±2.64</td><td>13.68±4.75</td><td>53.11±5.65</td><td>53.16±5.65</td></tr><tr><td>GraphSAGE</td><td>17.24±2.64</td><td>16.55±2.40</td><td>56.88±0.77</td><td>48.10±0.81</td><td>62.62±0.37</td><td>53.90±4.74</td><td>82.17±0.86</td><td>82.28±0.84</td></tr><tr><td>GCN</td><td>18.45±1.40</td><td>18.67±1.32</td><td>52.63±1.15</td><td>44.75±1.07</td><td>55.50±2.08</td><td>37.07±5.07</td><td>84.49±1.08</td><td>84.56±1.10</td></tr><tr><td>GCN+LRGA</td><td>25.75±2.82</td><td>26.12±2.35</td><td>60.88±0.59</td><td>52.21±0.72</td><td>66.75±0.58</td><td>62.30±9.12</td><td>65.05±0.22</td><td>65.05±0.22</td></tr><tr><td>SEAL</td><td>51.25±2.52</td><td>48.80±3.16</td><td>63.89±0.49</td><td>53.71±0.47</td><td>28.49±2.69</td><td>30.56±3.86</td><td>85.09±0.88</td><td>85.27±0.91</td></tr></table>",
+        "bbox": [
+            181,
+            131,
+            818,
+            251
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            181,
+            281,
+            813,
+            325
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "All the GAE methods’ GNNs have 3 message passing layers with 256 hidden dimensions, with a tuned dropout ratio in $\\{ 0 , 0 . 5 \\}$ . The GNN in SEAL follows the original paper, which has 3 GCN layers with 32 hidden dimensions each, with a tuned subgraph hop $h$ in $\\{ 1 , 2 \\}$ . The ogbl-ddi graph contains no node features, so MLP is omitted, and the GAE methods here use free-parameter node embeddings as the GNN input node features and trained them together with the GNN parameters. For SEAL, the DRNL node labels are input to an embedding layer and then concatenated with the node features (if any) as the GNN input. More details are in Appendix D. ",
+        "bbox": [
+            173,
+            330,
+            825,
+            428
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results and discussion. We compare the baselines’ link prediction performance on ogbl-ppa, ogbl-collab, ogbl-ddi, and ogbl-citation. Among them, ogbl-ppa is a proteinprotein association graph where the task is to predict biologically meaningful associations between proteins. ogbl-collab is an author collaboration graph, where the task is to predict future collaborations. ogbl-ddi is a drug-drug interaction network, where each edge represents an interaction between drugs which indicates the join effect of taking the two drugs together is considerably different from their independent effects. ogbl-citation is a paper citation network, where the task is to predict missing citations. We present the ten-time average results in Table 2. The results show that SEAL achieves the best performance on 3 out of 4 datasets. It outperforms GAE and network embedding methods, sometimes by surprisingly large margins. For example, in the challenging ogbl-ppa graph, SEAL achieves an $\\operatorname { H i t s } @ 1 0 0$ of 48.80, which is over $50 \\%$ higher than the second-best baseline MF which only has an Hits $@ 1 0 0$ of 32.29. In comparison, all GAE methods achieve Hits $@ 1 0 0$ lower than 30. SEAL has $8 7 \\% . 1 9 5 \\%$ improvement over GAE methods in this dataset, which demonstrates the superiority of learning structural link representations over structural node representations for link prediction. SEAL also improves the state-of-the-art results for ogbl-collab and ogbl-citation in both validation and test performance. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            656
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Nevertheless, we observe that SEAL does not perform well on ogbl-ddi. ogbl-ddi is considerably denser than the other graphs. It only has 4,267 nodes, but has 1,334,889 edges, which results in an average node degree of 500.5 and density of $1 4 . 6 7 \\%$ . Interestingly, although SEAL is able to beat MF and Node2vec, it falls behind GAE methods with free-parameter node embeddings. One possible reason is that the nodes in ogbl-ddi are so densely connected that a practical GNN with limited expressive power is hard to inductively learn any meaningful structural patterns. In comparison, the free-parameter node embeddings make GAE methods transductive and no longer focus on learning structural patterns, but focus on optimizing node embeddings. An interesting topic is thus how to improve structural representation learning on dense graphs, which we leave for future work. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            789
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            809,
+            328,
+            824
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have revisited the topic of using graph neural networks for link prediction. We reviewed two popular classes of methods, GAE and SEAL. We first showed that GAE methods cannot learn structural link representations by aggregating individually learned node embeddings. We further showed that combining with a simple labeling trick, a node-most-expressive GNN can learn structural link representations, and SEAL is such an example. Experiments on 4 large-scale OGB datasets demonstrate the superiority of learning structural link representations with SEAL. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lada A Adamic and Eytan Adar. Friends and neighbors on the web. Social networks, 25(3):211–230, 2003. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Laszl ´ o Babai and Ludik Kucera. Canonical labelling of graphs in linear average time. In ´ 20th Annual Symposium on Foundations of Computer Science (sfcs 1979), pp. 39–46. IEEE, 1979. ",
+        "bbox": [
+            174,
+            162,
+            821,
+            193
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Albert-Laszl ´ o Barab ´ asi and R ´ eka Albert. Emergence of scaling in random networks. ´ science, 286 (5439):509–512, 1999. ",
+        "bbox": [
+            174,
+            199,
+            823,
+            229
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "James Bennett, Stan Lanning, et al. The netflix prize. In Proceedings of KDD cup and workshop, volume 2007, pp. 35. New York, 2007. ",
+        "bbox": [
+            173,
+            237,
+            823,
+            267
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. arXiv preprint arXiv:1312.6203, 2013. ",
+        "bbox": [
+            173,
+            275,
+            825,
+            304
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jin-Yi Cai, Martin Furer, and Neil Immerman. An optimal lower bound on the number of variables ¨ for graph identification. Combinatorica, 12(4):389–410, 1992. ",
+        "bbox": [
+            173,
+            313,
+            823,
+            342
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ines Chami, Zhitao Ying, Christopher Re, and Jure Leskovec. Hyperbolic graph convolutional neural ´ networks. In Advances in neural information processing systems, pp. 4868–4879, 2019. ",
+        "bbox": [
+            174,
+            349,
+            823,
+            380
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhengdao Chen, Soledad Villar, Lei Chen, and Joan Bruna. On the equivalence between graph isomorphism testing and function approximation with gnns. In Advances in Neural Information Processing Systems, pp. 15894–15902, 2019. ",
+        "bbox": [
+            173,
+            386,
+            823,
+            430
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hanjun Dai, Bo Dai, and Le Song. Discriminative embeddings of latent variable models for structured data. In Proceedings of The 33rd International Conference on Machine Learning, pp. 2702– 2711, 2016. ",
+        "bbox": [
+            173,
+            438,
+            823,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alan´ Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in neural information processing systems, pp. 2224–2232, 2015. ",
+        "bbox": [
+            174,
+            489,
+            821,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthias Fey and Jan Eric Lenssen. Fast graph representation learning with pytorch geometric. arXiv preprint arXiv:1903.02428, 2019. ",
+        "bbox": [
+            169,
+            540,
+            821,
+            570
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1263–1272. JMLR. org, 2017. ",
+        "bbox": [
+            173,
+            577,
+            821,
+            622
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 855–864. ACM, 2016. ",
+        "bbox": [
+            174,
+            628,
+            823,
+            672
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, pp. 1025–1035, 2017. ",
+        "bbox": [
+            171,
+            680,
+            823,
+            710
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. arXiv preprint arXiv:2005.00687, 2020. ",
+        "bbox": [
+            174,
+            717,
+            823,
+            761
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Leo Katz. A new status index derived from sociometric analysis. Psychometrika, 18(1):39–43, 1953. ",
+        "bbox": [
+            173,
+            768,
+            821,
+            797
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016a. ",
+        "bbox": [
+            174,
+            806,
+            820,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Variational graph auto-encoders. arXiv preprint arXiv:1611.07308, 2016b. ",
+        "bbox": [
+            173,
+            843,
+            821,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pan Li, Yanbang Wang, Hongwei Wang, and Jure Leskovec. Distance encoding–design provably more powerful gnns for structural representation learning. arXiv preprint arXiv:2009.00142, 2020. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Liben-Nowell and Jon Kleinberg. The link-prediction problem for social networks. Journal of the American society for information science and technology, 58(7):1019–1031, 2007. ",
+        "bbox": [
+            176,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Haggai Maron, Heli Ben-Hamu, Hadar Serviansky, and Yaron Lipman. Provably powerful graph networks. In Advances in Neural Information Processing Systems, pp. 2156–2167, 2019. ",
+        "bbox": [
+            174,
+            178,
+            820,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andriy Mnih and Ruslan R Salakhutdinov. Probabilistic matrix factorization. In Advances in neural information processing systems, pp. 1257–1264, 2008. ",
+        "bbox": [
+            173,
+            215,
+            823,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christopher Morris, Martin Ritzert, Matthias Fey, William L Hamilton, Jan Eric Lenssen, Gaurav Rattan, and Martin Grohe. Weisfeiler and leman go neural: Higher-order graph neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 4602–4609, 2019. ",
+        "bbox": [
+            173,
+            252,
+            825,
+            309
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Maximilian Nickel, Kevin Murphy, Volker Tresp, and Evgeniy Gabrilovich. A review of relational machine learning for knowledge graphs. arXiv preprint arXiv:1503.00759, 2015. ",
+        "bbox": [
+            171,
+            318,
+            823,
+            348
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mathias Niepert, Mohamed Ahmed, and Konstantin Kutzkov. Learning convolutional neural networks for graphs. In Proceedings of the 33rd annual international conference on machine learning. ACM, 2016. ",
+        "bbox": [
+            176,
+            356,
+            821,
+            398
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 701–710. ACM, 2014. ",
+        "bbox": [
+            174,
+            407,
+            821,
+            450
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Omri Puny, Heli Ben-Hamu, and Yaron Lipman. From graph low-rank global attention to 2-fwl approximation. arXiv preprint arXiv:2006.07846, 2020. ",
+        "bbox": [
+            173,
+            458,
+            821,
+            488
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yanjun Qi, Ziv Bar-Joseph, and Judith Klein-Seetharaman. Evaluation of different biological data and computational classification methods for use in protein interaction prediction. Proteins: Structure, Function, and Bioinformatics, 63(3):490–500, 2006. ",
+        "bbox": [
+            176,
+            496,
+            823,
+            539
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Leonardo FR Ribeiro, Pedro HP Saverese, and Daniel R Figueiredo. struc2vec: Learning node representations from structural identity. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 385–394. ACM, 2017. ",
+        "bbox": [
+            174,
+            546,
+            821,
+            590
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2009. ",
+        "bbox": [
+            174,
+            598,
+            823,
+            628
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Balasubramaniam Srinivasan and Bruno Ribeiro. On the equivalence between positional node embeddings and structural graph representations. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } }$ SJxzFySKwH. ",
+        "bbox": [
+            174,
+            636,
+            823,
+            679
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Boris Weisfeiler and AA Lehman. A reduction of a graph to a canonical form and an algebra arising during this reduction. Nauchno-Technicheskaya Informatsia, 2(9):12–16, 1968. ",
+        "bbox": [
+            174,
+            688,
+            820,
+            717
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv:1810.00826, 2018. ",
+        "bbox": [
+            174,
+            724,
+            821,
+            755
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jiaxuan You, Rex Ying, and Jure Leskovec. Position-aware graph neural networks. arXiv preprint arXiv:1906.04817, 2019. ",
+        "bbox": [
+            173,
+            762,
+            823,
+            791
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Muhan Zhang and Yixin Chen. Link prediction based on graph neural networks. In Advances in Neural Information Processing Systems, pp. 5165–5175, 2018. ",
+        "bbox": [
+            171,
+            799,
+            823,
+            830
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Muhan Zhang and Yixin Chen. Inductive matrix completion based on graph neural networks. In International Conference on Learning Representations, 2020. URL https://openreview. net/forum?id $=$ ByxxgCEYDS. ",
+        "bbox": [
+            173,
+            838,
+            823,
+            881
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. In AAAI, pp. 4438–4445, 2018. ",
+        "bbox": [
+            171,
+            888,
+            823,
+            919
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A PROOF OF THEOREM 1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            398,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Recall Definition 5 defines: ",
+        "bbox": [
+            174,
+            132,
+            354,
+            147
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ff64231fcaae988a352ca85dcf69a28de9d2fecb8e249ebd4e8d35a34b8df917.jpg",
+        "text": "$$\n\\mathrm { G N N } ( S , \\tilde { \\mathbf { A } } ) = \\mathrm { A G G } ( \\{ \\mathrm { G N N } ( i , \\tilde { \\mathbf { A } } ) | i \\in S \\} ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            148,
+            638,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thus, we only need to show $\\mathrm { A G G } ( \\{ \\mathrm { G N N } ( i , \\tilde { \\mathbf { A } } ) | i \\in S \\} ) = \\mathrm { A G G } ( \\{ \\mathrm { G N N } ( i , \\tilde { \\mathbf { A } } ^ { \\prime } ) | i \\in S ^ { \\prime } \\} )$ iff $( S , \\pmb { \\mathsf { A } } ) \\simeq$ $( S ^ { \\prime } , { \\pmb { \\mathsf { A } } } ^ { \\prime } )$ . ",
+        "bbox": [
+            174,
+            175,
+            823,
+            209
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "To prove the first direction, we notice that with an injective AGG, ",
+        "bbox": [
+            173,
+            214,
+            604,
+            229
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7335d5e3cd09c6fec7ca64b6181f648b0b5d17aabab0c56206da1591fd843ef4.jpg",
+        "text": "$$\n\\begin{array} { r l } & { ~ \\mathrm { A G G } ( \\{ \\mathrm { G N N } ( i , \\tilde { \\mathbf { A } } ) | i \\in S \\} ) = \\mathrm { A G G } ( \\{ \\mathrm { G N N } ( i , \\tilde { \\mathbf { A } } ^ { \\prime } ) | i \\in S ^ { \\prime } \\} ) } \\\\ & { \\implies \\exists v _ { 1 } \\in S , v _ { 2 } \\in S ^ { \\prime } , \\mathrm { ~ s u c h ~ t h a t ~ G N N } ( v _ { 1 } , \\tilde { \\mathbf { A } } ) = \\mathrm { G N N } ( v _ { 2 } , \\tilde { \\mathbf { A } } ^ { \\prime } ) } \\\\ & { \\implies ( v _ { 1 } , \\tilde { \\mathbf { A } } ) \\simeq \\left( v _ { 2 } , \\tilde { \\mathbf { A } } ^ { \\prime } \\right) \\quad ( \\mathrm { b e c a u s e ~ G N N ~ i s ~ n o d e - m o s t - e x p r e s s i v e } , } \\\\ & { \\implies \\exists \\pi \\in \\Pi _ { n } , \\mathrm { ~ s u c h ~ t h a t ~ } v _ { 1 } = \\pi ( v _ { 2 } ) , \\tilde { \\mathbf { A } } = \\pi ( \\tilde { \\mathbf { A } } ^ { \\prime } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            234,
+            710,
+            325
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Remember $\\tilde { \\pmb { A } }$ is constructed by stacking $\\pmb { \\mathsf { A } }$ and $\\pmb { I } ^ { ( S ) }$ in the third dimension, where $\\pmb { I } ^ { ( S ) }$ is a diagonal matrix satisfying: $\\forall \\pi \\in \\Pi _ { n }$ , (1) $\\pmb { I } ^ { ( S ) } = \\pi ( \\pmb { I } ^ { ( S ^ { \\prime } ) } ) \\Rightarrow S = \\pi ( S ^ { \\prime } )$ , and (2) $S = \\pi ( S ^ { \\prime } ) , \\pmb { \\mathbb { A } } = \\pi ( \\pmb { \\mathbb { A } } ^ { \\prime } ) \\Rightarrow$ $\\pmb { I } ^ { ( S ) } = \\pi ( \\pmb { I } ^ { ( S ^ { \\prime } ) } )$ . With $\\tilde { \\pmb { \\mathsf { A } } } = \\pi ( \\tilde { \\pmb { \\mathsf { A } } } ^ { \\prime } )$ , we have both ",
+        "bbox": [
+            176,
+            337,
+            823,
+            387
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c64d29d7de4ab43671c8146f169c0dbb22e5c48e366aa0c0874a94d251f01b80.jpg",
+        "text": "$$\n\\mathbf { A } = \\pi ( \\mathbf { A } ^ { \\prime } ) , I ^ { ( S ) } = \\pi ( I ^ { ( S ^ { \\prime } ) } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            392,
+            598,
+            412
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Because $\\pmb { I } ^ { ( S ) } = \\pi ( \\pmb { I } ^ { ( S ^ { \\prime } ) } ) \\Rightarrow S = \\pi ( S ^ { \\prime } )$ , we have ",
+        "bbox": [
+            173,
+            417,
+            501,
+            435
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b4c5143eca23d61a32c2316fcb8bc179b3649d04720d50a485a4a5684a05b249.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad \\mathrm { A G G } ( \\{ \\mathrm { G N N } ( i , \\tilde { \\mathbf { A } } ) | i \\in S \\} ) = \\mathrm { A G G } ( \\{ \\mathrm { G N N } ( i , \\tilde { \\mathbf { A } } ^ { \\prime } ) | i \\in S ^ { \\prime } \\} ) } \\\\ & { \\implies \\exists \\pi \\in \\Pi _ { n } , \\mathrm { ~ s u c h ~ t h a t ~ } S = \\pi ( S ^ { \\prime } ) , \\mathbf { A } = \\pi ( \\mathbf { A } ^ { \\prime } ) } \\\\ & { \\implies ( S , \\mathbf { A } ) \\simeq ( S ^ { \\prime } , \\mathbf { A } ^ { \\prime } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            439,
+            714,
+            502
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Now we prove the second direction. We have: ",
+        "bbox": [
+            174,
+            512,
+            473,
+            526
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/53ef1b143ffba64087d599e0891769ce52f7c97cda70d45e423aceac808b509a.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\qquad ( S , \\boldsymbol { \\mathsf { A } } ) \\simeq ( S ^ { \\prime } , \\boldsymbol { \\mathsf { A } } ^ { \\prime } ) } \\\\ & { \\Longrightarrow \\exists \\pi \\in \\Pi _ { n } , \\mathrm { ~ s u c h ~ t h a t } S = \\pi ( S ^ { \\prime } ) , \\boldsymbol { \\mathsf { A } } = \\pi ( \\boldsymbol { \\mathsf { A } } ^ { \\prime } ) } \\\\ & { \\Longrightarrow \\exists \\pi \\in \\Pi _ { n } , \\mathrm { ~ s u c h ~ t h a t } S = \\pi ( S ^ { \\prime } ) , I ^ { ( S ) } = \\pi ( I ^ { ( S ^ { \\prime } ) } ) , \\boldsymbol { \\mathsf { A } } = \\pi ( \\boldsymbol { \\mathsf { A } } ^ { \\prime } ) } \\\\ & { \\Longrightarrow \\exists \\pi \\in \\Pi _ { n } , \\mathrm { ~ s u c h ~ t h a t } S = \\pi ( S ^ { \\prime } ) , \\tilde { \\boldsymbol { \\mathsf { A } } } = \\pi ( \\boldsymbol { \\mathsf { A } } ^ { \\prime } ) } \\\\ & { \\Longrightarrow \\forall v _ { 1 } \\in S , v _ { 2 } \\in S ^ { \\prime } , v _ { 1 } = \\pi ( v _ { 2 } ) , \\mathrm { ~ w e ~ h a v e ~ G N N } ( v _ { 1 } , \\tilde { \\boldsymbol { \\mathsf { A } } } ) = \\mathrm { G N N } ( v _ { 2 } , \\tilde { \\boldsymbol { \\mathsf { A } } } ^ { \\prime } ) } \\\\ & { \\Longrightarrow \\boldsymbol { \\mathsf { A } } \\mathrm { G G } ( \\{ \\mathrm { G N N } ( v _ { 1 } , \\tilde { \\boldsymbol { \\mathsf { A } } } ) | v _ { 1 } \\in S \\} ) = \\boldsymbol { \\mathsf { A } } \\mathrm { G G } ( \\{ \\mathrm { G N N } ( v _ { 2 } , \\tilde { \\boldsymbol { \\mathsf { A } } } ^ { \\prime } ) | v _ { 2 } \\in S ^ { \\prime } \\} ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            245,
+            529,
+            751,
+            661
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "which concludes the proof. ",
+        "bbox": [
+            174,
+            662,
+            352,
+            678
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B PROOF OF LEMMA 1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            696,
+            377,
+            713
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We first note that for a most powerful 1-WL-GNN, after a message passing layer, gives different embeddings to any two nodes that 1-WL gives different colors to after one iteration. So we only need to show how many iterations 1-WL takes to converge in any graph. ",
+        "bbox": [
+            176,
+            728,
+            823,
+            771
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Note that if two nodes are given different colors by 1-WL at some iteration (they are discriminated by 1-WL), their colors are always different in any future iteration. And if at some iteration, all nodes’ colors are the same as their colors in the last iteration, then 1-WL will stop (1-WL fails to discriminate any more nodes and has converged). Therefore, before termination, 1-WL will increase its total number of colors by at least 1 after every iteration. Because there are at most $n$ different final colors given an $n$ -node graph, 1-WL takes at most $n - 1 = { \\mathcal { O } } ( n )$ iterations before assigning all nodes different colors. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            875
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Now it suffices to show that there exists a $n$ -node graph that 1-WL takes ${ \\mathcal { O } } ( n )$ iterations to converge. Suppose there is a linked list of $n$ nodes (a path). Then by simple calculation, it takes $\\lceil n / 2 \\rceil$ iterations for 1-WL to converge, which concludes the proof. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C PROOF OF THEOREM 2 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            400,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Our proof has two steps. First, we would like to show that there are $\\omega ( n ^ { \\epsilon } )$ nodes that are locally $h$ -isomorphic to each other. Then, we prove that among these nodes, there are at least $\\omega ( n ^ { 2 \\epsilon } )$ pairs of nodes such that there exists another node constructing locally $h$ non-isomorphic links with either of the two nodes in each node pair. ",
+        "bbox": [
+            173,
+            132,
+            825,
+            190
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Step 1. Consider an arbitrary node $v$ and denote the subgraph induced by the nodes that are at most $h$ -hop away from $v$ as $G _ { v } ^ { ( h ) }$ (the $h$ -hop enclosing subgraph of $v$ ). As each node is with degree $d = \\mathcal { O } ( \\log ^ { \\frac { 1 - \\epsilon } { 2 h } } n )$ , then the number of nodes in $G _ { v } ^ { ( h ) }$ , denoted by $| V ( G _ { v } ^ { ( h ) } ) |$ , satisfies ",
+        "bbox": [
+            173,
+            195,
+            825,
+            247
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6ae864c85f2a1e7d240ba15416e43e76fd3b0239c001b3cb902d70253e664e5d.jpg",
+        "text": "$$\n| V ( G _ { v } ^ { ( h ) } ) | \\leq \\sum _ { i = 0 } ^ { h } d ^ { i } = \\mathcal { O } ( d ^ { h } ) = \\mathcal { O } ( \\log ^ { \\frac { 1 - \\epsilon } { 2 } } n ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            252,
+            651,
+            296
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We set the max $K = \\operatorname* { m a x } _ { v \\in V } | V ( G _ { v } ^ { ( h ) } ) |$ and thus $K = \\mathcal { O } ( \\log ^ { \\frac { 1 - \\epsilon } { 2 } } n )$ ",
+        "bbox": [
+            174,
+            303,
+            630,
+            323
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Now we expand subgraphs $G _ { v } ^ { ( h ) }$ to $\\bar { G } _ { v } ^ { ( h ) }$ by adding $K - | V ( G _ { v } ^ { ( h ) } ) |$ independent nodes for each node $v \\in V$ . Then, all $\\bar { G } _ { v } ^ { ( h ) }$ have the same number of nodes, which is $K$ , though they may not be connected graphs. ",
+        "bbox": [
+            173,
+            328,
+            825,
+            378
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Next, we consider the number of non-isomorphic graphs over $K$ nodes. Actually, the number of nonisomorphic graph structures over $K$ nodes is bounded by $2 ^ { \\binom { K } { 2 } } = \\exp ( \\mathcal { O } ( \\log ^ { 1 - \\epsilon } n ) ) = o ( n ^ { 1 - \\epsilon } )$ . ",
+        "bbox": [
+            174,
+            383,
+            818,
+            417
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Therefore, due to the pigeonhole principle, there exist $n / o ( n ^ { 1 - \\epsilon } ) = \\omega ( n ^ { \\epsilon } )$ many nodes $v$ whose $\\bar { G } _ { v } ^ { ( h ) }$ are isomorphic to each other. Denote the set of these nodes as $V _ { i s o }$ , which consist of nodes that are all locally $h$ -isomorphic to each other. Next, we focus on looking for other nodes to form locally $h$ -non-isomorphic links with nodes $V _ { i s o }$ . ",
+        "bbox": [
+            173,
+            422,
+            825,
+            484
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Step 2. Let us partition $V _ { i s o } = \\cup _ { i = 1 } ^ { q } V _ { i }$ so that for all nodes in $V _ { i }$ , they share the same first-hop neighbor sets. Then, consider any pair of nodes $u , v$ such that $u , v$ are from different $V _ { i }$ ’s. Then, we may pick one $u$ ’s first-hop neighbor $w$ that is not $v$ ’s first-hop neighbor. We know such $w$ exists because of the definition of $V _ { i }$ . As $w$ is $u$ ’s first-hop neighbor and is not $v$ ’s first-hop neighbor, $( u , w )$ and $( v , w )$ are not locally 1-isomorphic and thus not locally $h$ -isomorphic. Therefore, based on this partition, we know the number of node pairs $u , v$ such that there exists another node $w$ making $( u , w )$ and $( v , w )$ not locally $h$ -isomorphic is at least ",
+        "bbox": [
+            173,
+            489,
+            825,
+            589
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e66a4bdaadbb23415914953807d76f26ae482c36b63ed83163344db6cf89e93f.jpg",
+        "text": "$$\nY \\geq \\prod _ { \\substack { i , j = 1 , i \\neq j } } ^ { q } | V _ { i } | | V _ { j } | = \\frac { 1 } { 2 } \\left[ ( \\sum _ { i = 1 } ^ { q } | V _ { i } | ) ^ { 2 } - \\sum _ { i = 1 } ^ { q } | V _ { i } | ^ { 2 } \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            593,
+            678,
+            640
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Because of the definitions of the partition, $\\begin{array} { r } { \\sum _ { i = 1 } ^ { q } | V _ { i } | = | V _ { i s o } | = \\omega ( n ^ { \\epsilon } ) } \\end{array}$ and the size of each $V _ { i }$ satisfies ",
+        "bbox": [
+            173,
+            652,
+            825,
+            684
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ff035b4c09f27e166a63469f4a28fea62734591ec669ca6deb6bf86d52a85c39.jpg",
+        "text": "$$\n1 \\leq | V _ { i } | \\leq d _ { w } = \\mathcal { O } ( \\log ^ { \\frac { 1 - \\epsilon } { 2 h } } n ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            685,
+            601,
+            708
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "where $w$ is one of the common first-hop neighbors shared by all nodes in $V _ { i }$ and $d _ { w }$ is its degree. ",
+        "bbox": [
+            173,
+            713,
+            805,
+            728
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "By plugging in the range of $| V _ { i } |$ , Eq.12 leads to ",
+        "bbox": [
+            174,
+            734,
+            486,
+            751
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/38174872553649687cef0f351d174d9a9868908a2ff9db0214ab5ed2d672e972.jpg",
+        "text": "$$\nY \\ge \\frac { 1 } { 2 } ( \\omega ( n ^ { 2 \\epsilon } ) - \\omega ( n ^ { \\epsilon } ) \\mathcal { O } ( \\log ^ { \\frac { 1 - \\epsilon } { 2 h } } n ) ) = \\omega ( n ^ { 2 \\epsilon } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            756,
+            660,
+            786
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "which concludes the proof. ",
+        "bbox": [
+            174,
+            791,
+            352,
+            806
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D MORE DETAILS ABOUT BASELINES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            827,
+            500,
+            843
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We include baselines achieving top performances on the OGB Link Prediction Leaderboard1. All the methods have their open-sourced code and paper available from the leaderboard. We adopt the numbers published on the leaderboard if available, otherwise we run the method ourselves using the open-sourced code. For the baseline GCN+LRGA, its default hyperparameters result in out of GPU memory on ogbl-citation, even we use an NVIDIA V100 GPU with 32GB memory. Thus, we have to reduce its hidden dimension to 16 and matrix rank to 10. It is possible that it can achieve better performance with a larger hidden dimension and larger matrix rank using a GPU with a larger memory. Despite this, GCN+LRGA generally performs second to best among all methods. ",
+        "bbox": [
+            174,
+            857,
+            825,
+            900
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We implemented SEAL using the PyTorch Geometric (Fey & Lenssen, 2019) package. Following the original paper (Zhang & Chen, 2018), we adopt a SortPooling layer (Zhang et al., 2018) after the GCN layers to readout the subgraph. For all datasets, SEAL only used a fixed $1 \\%$ to $10 \\%$ of all the available training edges as the positive training links, and sampled an equal number of negative training links randomly. SEAL showed excellent performance even without using the full training data, which indicates its strong inductive learning ability. Due to using different labeled subgraphs for different links, SEAL generally has longer running time than GAE methods. On the largest ogbl-citation graph, SEAL takes about 7 hours to finishing its training of 10 epochs, and takes another 28 hours to evaluate the validation and test MRR each. For ogbl-ppa, SEAL takes about 20 hours to train for 20 epochs and takes about 4 hours for evaluation. The other two datasets are finished within hours. We will release all our code for reproducing the experimental results. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            333
+        ],
+        "page_idx": 12
+    }
+]

parse/train/BJLmN8xRW/BJLmN8xRW.md

@@ -0,0 +1,169 @@
+# CHARACTER LEVEL BASED DETECTION OF DGA DOMAIN NAMES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Recently several different deep learning architectures have been proposed that take a string of characters as the raw input signal and automatically derive features for text classification. Few studies are available that compare the effectiveness of these approaches for character based text classification with each other. In this paper we perform such an empirical comparison for the important cybersecurity problem of DGA detection: classifying domain names as either benign vs. produced by malware (i.e., by a Domain Generation Algorithm). Training and evaluating on a dataset with 2M domain names shows that there is surprisingly little difference between various convolutional neural network (CNN) and recurrent neural network (RNN) based architectures in terms of accuracy, prompting a preference for the simpler architectures, since they are faster to train and less prone to overfitting.
+
+# 1 INTRODUCTION
+
+Malware is software that infects computers in order to perform unauthorized malicious activities. In order to successfully achieve its goals, the malware needs to be able to connect to a command and control (C&C) center. To this end, both the controller behind the C&C center (hereafter called botmaster) and the malware on the infected machines can run a Domain Generation Algorithm (DGA) that generates hundreds or even thousands of domains automatically. The malware then attempts at resolving each one of these domains with its local DNS server. The botmaster will have registered one or a few of these automatically generated domains. For these domains that have been actually registered, the malware will obtain a valid IP address and will be able to communicate with the C&C center.
+
+The binary text classification task that we address in this paper is: given a domain name string as input, classify it as either malicious, i.e. generated by a DGA, or as benign. Deep neural networks have recently appeared in the literature on DGA detection Woodbridge et al. (2016); Saxe & Berlin (2017); Yu et al. (2017). They significantly outperform traditional machine learning methods in accuracy, at the price of increasing the complexity of training the model and requiring larger datasets. Independent of the work on deep networks for DGA detection, other deep learning approaches for character based text classification have recently been proposed, including deep neural network architectures designed for processing and classification of tweets (Dhingra et al. (2016); Vosoughi et al. (2016)) as well as general natural language text (Zhang et al. (2015)). No systematic study is available that compares the predictive accuracy of all these different character based deep learning architectures, leaving one to wonder which one works best for DGA detection.
+
+To answer this open question, in this paper we compare the performance of five different deep learning architectures for character based text classification (see Table 1) for the problem of detecting DGAs. They all rely on character-level embeddings, and they all use a deep learning architecture based on convolutional neural network (CNN) layers, recurrent neural network (RNN) layers, or a combination of both. Our most important finding is that for DGA detection, which can be thought of as classification of short character strings, despite of vast differences in the deep network architectures, there is remarkably little difference among the methods in terms of accuracy and false positive rates, while they all comfortably outperform a random forest trained on human engineered features. This finding is of practical value for the design of deep neural network based classifiers for short text classification in industry and academia: it provides evidence that one can select an architecture that is faster to train, without loss of accuracy. In the context of DGA detection, optimizing the training time is of particular importance, as the models need to be retrained on a regular basis to stay current with respect to new, emerging malware.
+
+Table 1: High level overview of recent deep learning approaches for character based text classification   
+
+<table><tr><td rowspan=1 colspan=1>Name</td><td rowspan=1 colspan=1>Architecture</td><td rowspan=1 colspan=1>Reference</td></tr><tr><td rowspan=1 colspan=1>Endgame</td><td rowspan=1 colspan=1>single LSTMlayer</td><td rowspan=1 colspan=1>Woodbridge et al. (2016)</td></tr><tr><td rowspan=1 colspan=1>Invincea</td><td rowspan=1 colspan=1>parallel CNN layers</td><td rowspan=1 colspan=1>Saxe&amp;Berlin (2017)</td></tr><tr><td rowspan=1 colspan=1>CMU</td><td rowspan=1 colspan=1>forward LSTM layer+ backward LSTMlayer</td><td rowspan=1 colspan=1>Dhingra et al. (2016)</td></tr><tr><td rowspan=1 colspan=1>MIT</td><td rowspan=1 colspan=1> stacked CNN layers + single LSTM layer</td><td rowspan=1 colspan=1>Vosoughi et al. (2016)</td></tr><tr><td rowspan=1 colspan=1>NYU</td><td rowspan=1 colspan=1>stacked CNNlayers</td><td rowspan=1 colspan=1>Zhang et al. (2015)</td></tr></table>
+
+# 2 BACKGROUND
+
+Malware controllers, or botmasters, use malware for all kinds of unauthorized malicious activities. These activities range from stealing information, to exploiting the victims’ computing resources to mine bitcoin. They can also include launching a distributed denial of service attack from the victims’s computers or encrypting the victims hard drive (ransomware). In order to successfully achieve its goals, it is vital that the malware be able to connect to a command and control (C&C) center. This communication can serve many purposes. The malware can use it to send stolen information (such as passwords or access credentials) to the malware designer behind the C&C center, it can use this communication channel to receive instructions or even to update itself to a newer version.
+
+Initially, botmasters established such a communication channel to the C&C center by hard-coding an IP address inside the malware. This approach has obvious shortcomings from the botmasters’ perspective: once the malware is reversed engineered, the IP address is discovered and shut down. Over time, malware designers came up with a much more effective strategy: Domain Generation Algorithms (DGAs). Domain Generation Algorithms work by having the malware accessing some available source of randomness and inputting it into an algorithm that generates hundreds or even thousands of domains automatically. The malware then attempts at resolving each one of these domains with its local DNS server (a DNS server runs a protocol that translates domain names into IP addresses; it is a vital piece of the Internet). The botmaster will have registered one or a few of these automatically generated domains. For these domains that have been actually registered, the malware will obtain a valid IP address and will be able to communicate with the C&C center. For all the other domains that were automatically generated but not registered, the malware obtains a message stating that these domains could not have been resolved and ignores them.
+
+DGAs make blacklisting of domains extremely difficult, since by changing the initial randomness (while keeping the same algorithm) the malware can potentially generate completely different domains. This technique has been used by high-profile malware such as Conficker, Stuxnet (the malware designed to attack Iran nuclear facilities) and Flame. Catching domain names generated by malware has become a central topic in information security, leading to a recent interest in detecting DGA domains using machine learning techniques. Models that classify domain names as benign or malicious based solely on the domain name string are of particular interest for their generality, as context information beyond the domain name string might be unavailable or expensive to acquire. Traditional machine learning methods for DGA detection based on the domain name string rely on extraction of predefined, human engineered lexical features, see e.g. Antonakakis et al. (2012); Schiavoni et al. (2014). Whenever human engineered features are used, it is obvious that this opens the door for an adversary to carefully craft its DGA to avoid detection by using the aforementioned features. This makes maintaining such machine learning systems labor intensive. Recently proposed deep learning techniques for detecting DGAs learn features automatically, thereby offering the potential to bypass the human effort of feature engineering (Woodbridge et al. (2016); Saxe & Berlin (2017); Yu et al. (2017)). In addition these deep learning approaches outperform the traditional machine learning techniques with human engineered features in terms of accuracy and false positive rates. The choice of deep network architecture in these recent works appears fairly arbitrary, and it is unclear whether they would perform better or worse than other deep neural networks approaches for text classification that have been introduced recently, in particular character-level methods for processing and classification of tweets (Dhingra et al. (2016); Vosoughi et al. (2016)) and for general natural language text (Zhang et al. (2015)). In this paper, we provide the first comparative study of all these different methods, showing that, despite of vast differences in the architectures, they can be easily tuned to result in the same predictive accuracy.
+
+The problem of adversarial examples, i.e. instances that have intentionally been designed to cause the model to make a mistake, are a well known problem in machine learning. The scenario sketched above — in which a malware designer exploits knowledge about the lexical features used by a random forest to craft his DGA to avoid detection — is a prime example of this. Deep neural networks are famously not immune to adversarial examples either, and generative adversarial networks (GANs) can be trained to generate them automatically (see e.g. Goodfellow et al. (2014a;b)). Specifically in the context of DGA detection, Anderson et al. (2016) have used a character-based generative adversarial network (GAN) to augment training sets in order to harden other machine learning models (like a random forest) against yet-to-be-observed DGAs. It is highly unlikely for attackers to use GANs themselves, because DGA algorithms must be light enough to be embedded inside malware code. Furthermore, generating domain names that look like a benign domain is not enough for an effective DGA. Ideally, every domain produced by a DGA must not have been registered yet or must have a low likelihood of being registered already – if a domain produced by a DGA has already been taken, it is useless for the botmaster. Combining all these requirements is essential for a serious study of adversarial generated domains and outside the scope of this paper.
+
+# 3 METHODS
+
+We compare five different deep learning methods for short string classification, when applied to the problem of DGA detection specifically. For each of the methods, we start from the original proposals as can be found in the references in Table 1 and only make modifications when they improve the predictive accuracy for the classification of domain names. Below we give an overview of the methods and the adaptations made. A Keras1 code snippet for each method is included in Appendix A.
+
+The strings that we give as input to all classifiers consist of a second level domain (SLD) and a top level domain (TLD), separated by a dot, as in e.g. wikipedia.org. Following Woodbridge et al. (2016), we set the maximum length at 75 characters, padded with zeros on the left for domains whose length is less than 75.2 We convert each domain name string to lower case, since domain names are case insensitive, and encode it as an ASCII code sequence of length 128, effectively representing each domain name string as a 75 by 128 matrix in which each character corresponds to a column.
+
+# 3.1 RNN BASED ARCHITECTURES
+
+Endgame Model Long short-term memory networks (LSTMs), a special kind of recurrent neural networks (RNNs) have recently attracted a lot of attention because of their successful application to problems that involve processing of sequences (Hochreiter & Schmidhuber (1997)). Since domain names can be thought of as sequences of characters, LSTMs are a natural kind of classifiers to apply. The LSTM network proposed by Woodbridge et al. (2016) was designed specifically for DGA detection, so we stay very close to the original model. The network is comprised of an embedding layer, an LSTM layer (128 LSTM cells with default Tanh activation), and a single node output layer with sigmoid activation. Instead of using RMSProp as the optimization algorithm, as was done in Woodbridge et al. (2016), we switched to Adam (Kingma & Ba (2014)) because it resulted in better loss convergence results (see Section 4). The Endgame model includes dropout, a technique to improve model performance and overcome over-fitting by randomly excluding nodes during training, which serves to break up complex co-adaptations in the network Srivastava et al. (2014). This is confined to the training phase; all nodes are active during testing and deployment.
+
+The role of the embedding layer is to learn to represent each character that can occur in a domain name by a 128-dimensional numerical vector. This vector is different from the original 128- dimensional ASCII encoding. The embedding maps semantically similar characters to similar vectors, where the notion of similarity is implicitly derived (learned) based on the classification task at hand. As will become clear in the remainder of this section, all five deep neural network architectures under study start with such an embedding layer. To allow for a fair comparison, we have made the parameter choices for the embedding layer, such as the dimensionality of the embedding space, identical for all five models. In addition, for comparison purposes, in Section 4 we also present the results of a “baseline neural network model” consisting only of an embedding layer as its hidden layer.
+
+CMU Model Bidirectional RNNs extend regular RNNs by processing the input string in two ways. In a forward layer, the input sequence is processed from the left to the right, as in a traditional RNN, while in a backward layer, the processing happens from the right to the left. The output from the forward and the backward layer is then combined and passed on to further layers. Bidirectional LSTMs for character level text processing have been proposed in Ling et al. (2015), and, following up on that, very similar bidirectional GRUs (gated recurrent units) have been applied in a “Tweet2Vec” model for tweet classification (predicting hashtags of tweets) by Dhingra et al. (2016). We use an adaptation of the latter; see Listing 2 in Appendix A. Including dropout or replacing LSTM by GRU did not cause a significant change in predictive accuracy, although the latter did result in a decrease of training runtime.
+
+# 3.2 CNN BASED ARCHITECTURES
+
+NYU Model Convolutional neural networks (CNNs) are known for their ability to process input data with a grid like topology, such as images consisting of a grid of pixels. To the best of our knowledge, Zhang et al. (2015) were the first to apply 1-dimensional or “temporal” CNNs successfully to text classification at character level. Their proposed deep network architecture, which is intended to process full-blown natural language text such as news articles or reviews, includes 6 stacked CNN layers, with each subsequent layer consuming the output from the previous layer. In contrast to natural language text, domain names are very short and they do not have an internal grammatical structure, naturally resulting the original architectures from Zhang et al. (2015) to overfit on our data. We therefore reduced the number of stacked CNN layers to two, and decreased the size and the number of filters on the CNN layers (see Listing 3).
+
+Invincea Model Saxe & Berlin (2017) proposed a CNN based classifier that takes generic short character strings as its input and learns to detect whether they are indicators of malicious behavior. The short character strings can be e.g. URLs, file paths, or registry keys. The fundamental difference between the Invincea model versus the NYU model described above, is that in the Invincea model the CNN layers are parallel instead of stacked, and that pooling always happens over the entire domain name instead of within a small pooling window. That means that the Invincea model is only detecting the presence or absence of patterns in the domain names, and does not retain any information on where exactly in the domain name string these patterns occur. In the Invincea model, the embedding layer is followed by a convolutional layer with 1024 filters, namely 256 filters for each of the sizes 2, 3, 4, and 5. Each of these filters learns to detect the soft presence of an interesting soft $n$ -gram (with $n = 2 , 3 , 4 , 5$ ). The output of the convolutional layer is consumed by two dense hidden layers, each with 1024 nodes, before reaching a single node output layer with sigmoid activation. Out of all the models that we compared, this one has the most extensive architecture.
+
+# 3.3 HYBRID CNN/RNN BASED ARCHITECTURE
+
+MIT Model The MIT model proposed by Vosoughi et al. (2016) is an extension of the NYU model, where the stacked CNN layers are followed by an LSTM layer. Similarly as with the NYU model, the use of multiple stacked CNN layers (which worked well for tweets in Vosoughi et al. (2016)) resulted in the models to overfit on our data. For this reason, we reduced the MIT model architecture to the minimum that preserves its spirit: one CNN layer followed by one LSTM layer.
+
+![](images/85063668b9a10fc7a667cd524993b7ec538cda6f99609e6ed9697650223202bf.jpg)  
+Figure 1: Training and validation loss curves. The vertical axis in Figure (f) has a different scale than the other figures, related to the fact that the “Embedding only” baseline model has a much higher loss than the other models.
+
+# 4 RESULTS AND LEARNED REPRESENTATIONS
+
+We trained and evaluated the models on a dataset with 1 million DGA domain names from Bambenek3 (positive examples) and the top 1 million domain names from Alexa4 (negative examples). Alexa ranks websites based on their popularity in terms of number of page views and number of unique visitors. It only retains the websites’ SLD and TLD, aggregating across any subdomains. For example, according to Alexa, the five highest ranked domain names in terms of popularity on 2017-10-26 are google.com, youtube.com, facebook.com baidu.com, and wikipedia.org. For our experiments, we assume that the top 1 million domain names in this ranking are benign domain names, although it is possible that the bottom of the ranking may contain some noise.
+
+In addition to these benign domain names, we collected 1 million DGA domain names from the Bambenek Consulting feeds for 3 different days, namely Jun 24, Jul 22, Jul 23, 2017. These feeds contain DGA domain names from specific malware families that were observed in real traffic on those days. Such domain names can be collected by reverse engineering a known malware family, generating lists of domain names with the reverse engineered malware, and checking which of these domain names also occur in real traffic. Note that our goal in this paper is the development of a neural network classifier that can detect DGAs without the need to reverse engineer malware families. An important advantage of such a classifier is that it can also be used against new and previously unknown malware families.
+
+Table 2: Results on test data from July 2017. Accuracy, TPR, FPR are w.r.t. a threshold that gives a FPR of 0.001 on the validation data.   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=2>Architecture</td><td rowspan=1 colspan=1>Acc</td><td rowspan=1 colspan=1>TPR</td><td rowspan=1 colspan=1>FPR</td><td rowspan=1 colspan=1>AUC@1%</td></tr><tr><td rowspan=1 colspan=1>RF</td><td rowspan=1 colspan=2>Lexical features</td><td rowspan=1 colspan=1>91.51%</td><td rowspan=1 colspan=1>83.15%</td><td rowspan=1 colspan=1>0.00128</td><td rowspan=1 colspan=1>84.77%</td></tr><tr><td rowspan=1 colspan=1>MLP</td><td rowspan=1 colspan=2>Lexical features</td><td rowspan=1 colspan=1>73.74%</td><td rowspan=1 colspan=1>47.61%</td><td rowspan=1 colspan=1>0.00091</td><td rowspan=1 colspan=1>58.81%</td></tr><tr><td rowspan=1 colspan=1>Embedding</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>84.29%</td><td rowspan=1 colspan=1>68.69%</td><td rowspan=1 colspan=1>0.00108</td><td rowspan=1 colspan=1>80.88%</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>LSTM</td><td rowspan=1 colspan=1>CNN</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Endgame</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>98.72%</td><td rowspan=1 colspan=1>97.55%</td><td rowspan=1 colspan=1>0.00102</td><td rowspan=1 colspan=1>98.03%</td></tr><tr><td rowspan=1 colspan=1>Invincea</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>98.95%</td><td rowspan=1 colspan=1>98.01%</td><td rowspan=1 colspan=1>0.00109</td><td rowspan=1 colspan=1>97.47%</td></tr><tr><td rowspan=1 colspan=1>CMU</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>98.54%</td><td rowspan=1 colspan=1>97.18%</td><td rowspan=1 colspan=1>0.00108</td><td rowspan=1 colspan=1>98.25%</td></tr><tr><td rowspan=1 colspan=1>MIT</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>98.70%</td><td rowspan=1 colspan=1>97.49%</td><td rowspan=1 colspan=1>0.00099</td><td rowspan=1 colspan=1>97.55%</td></tr><tr><td rowspan=1 colspan=1>NYU</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>98.58%</td><td rowspan=1 colspan=1>97.27%</td><td rowspan=1 colspan=1>0.00116</td><td rowspan=1 colspan=1>97.93%</td></tr></table>
+
+We randomly split the data into $80 \%$ for training, $10 \%$ for validation, and $10 \%$ for testing. Figure 1 shows the training and validation loss curves for each of the models described in Section 3. The displayed epochs indicate where we stopped the training to obtain the models used to produce the final results in Table 2 and 5. The training loss is higher than the validation loss in the pictures in Figure 1 because the loss against the training data is computed in an average way across batches (the batch size is 100) while dropout is being applied, whereas performance on the validation set is determined at the end of each epoch with dropout disabled. Figure 1(f) displays the loss curves for training a simple neural network consisting of only an embedding layer. We include the performance of this network in our results as a baseline.
+
+The accuracy of each of the trained models when applied to the test data is recorded in Table 2. In addition to accuracy, this table includes the true positive rate (TPR) and false positive rate (FPR) for each of the models. Recall that $\mathrm { T P R } = \mathrm { T P } / ( \mathrm { T P } { + } \mathrm { F N } )$ and $\mathrm { F P R } = \mathrm { F P } / ( \mathrm { F P + T N } )$ where TP, FP, TN, and FN are the number of true positives, false positives, true negatives, and false negatives respectively. A low false positive rate is very important in deployed DGA detection systems, because blocking legitimate traffic is highly undesirable. All classifiers in Table 2 output a probability that a given instance belongs to the positive class, so we can tune a threshold probability at which to consider a prediction positive. For each model, we choose this threshold such that the model trained over the training data has a 0.001 FPR over the validation data. Then we report the accuracy, TPR and FPR obtained with this classification threshold over the test data. Finally, we also report AUC $@1 \%$ FPR, which is the integral of the ROC curve from $\mathrm { { F P R } = 0 }$ to $\mathrm { { F P R } = 0 . 0 1 }$ on the test data.
+
+For comparison purposes, Table 2 also contains results for a Random Forest (RF) and a Multilayer Perceptron (MLP) trained on the following 11 features, extracted from each domain name string (see Yu et al. (2014; 2016)): ent (normalized entropy of characters); nl2 (median of 2-gram); nl3 (median of 3-gram); naz (symbol character ratio); hex (hex character ratio); vwl (vowel character ratio); len (domain label length); gni (gini index of characters); cer (classification error of characters); tld (top level domain hash); dgt (first character digit). The Random Forest consists of 100 trees. The MLP has a single hidden layer with 128 nodes; see Listing 7 in Appendix A. Like the deep networks in this paper, this MLP was trained with batch size 100. The values of the 11 features are normalized so that they are all on the same scale before presenting them to the MLP.
+
+As expected, the FPR of all classifiers is around 0.001. There is a clear variation in the TPR that the classifiers achieve against that small FPR. While the Random Forest is only able to “catch” $83 \%$ of the malicious domain names, all the deep neural network architectures achieve a recall of 97- $98 \%$ . The baseline neural network consisting of only an embedding layer as its hidden layer clearly performs the worst with a TPR of less than $69 \%$ , highlighting that it is advantageous to extend the network architecture with one or more LSTM or CNN layers. Interestingly, there is little to no variation among the five deep neural network architectures in terms of TPR.
+
+Table 3 contains examples of domain names that were randomly selected among those misclassified by either the Random Forest or by all five deep neural networks. Inspecting the column of the benign domain names, i.e. the Alexa domain names, it is interesting to note that most of those misclassified by the deep neural networks (bottom left in the table) come across as gibberish that a human annotator would likely also classify as malicious. As also evident from the top right of Table 3, the deep neural networks have become very good at considering such gibberish-looking domain names to be malicious, even though they were never explicitly told to do so (unlike the Random Forest, which explicitly includes a normalized entropy of characters feature). The fact that the malicious domain names at the bottom right of Table 3 were missed by the deep neural networks might be due to our deliberate choice to tune the classification threshold to achieve a very low FPR. This makes all the classifiers hold back from labeling a domain name as malicious if they are not almost completely certain. As explained above, a low FPR is very important in deployed DGA detection systems, as blocking legitimate traffic is highly undesirable. Note that if a deployed DGA detection system would rely on the Random Forest classifier, it would block all domain names from the first row in Table 3, whereas, if it would rely on any of the deep neural network classifiers, it would block all domain names from the second row in Table 3. The domain names from the first column would have been unjustly blocked. For those negatively affected by this, it would be easier to “understand” (and perhaps forgive) the decisions made by the deep neural network classifiers, as they are more in line with decisions that a human would make when confronted with these domain name strings.
+
+Table 3: Examples of domain names that were either misclassified by the Random Forest or by the deep neural networks. For the malicious domain names, the name of the malware family is shown between parentheses.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>benign</td><td rowspan=1 colspan=1>malicious</td></tr><tr><td rowspan=1 colspan=1>misclassifiedby RF&amp;correctlyclassifiedby all fivedeep networks</td><td rowspan=1 colspan=1>kosmetikosdnr.ltjobrankingcommittee.comnaturalandhealthytips.compokemonrubysapphire.comturkcehdpornoizle.combollywoodparksdubai.com</td><td rowspan=1 colspan=1>mowvcssclilpomqi.com (murofet)ntearasildeafeninguvuc.com (banjori)raklloblmuppono.info (cryptolocker)5alolch3wvn5olcc.org (chinad)ldjucxqhivnaperisusb.ga (necurs)daeontibyxgask.cc (ranbyus)</td></tr><tr><td rowspan=1 colspan=1>misclassifiedby all fivedeep networks &amp;correctlyclassified by RF</td><td rowspan=1 colspan=1>rfembassy.kz 4553t5pugtt1qslvsnmpc0tpfz5fo.xyz9odyefocculgririlemjijbab.topa5rtngpo9840oyd.commydwnldsghtfv.com</td><td rowspan=1 colspan=1>doycsnramt.com (qakbot)gypjuytopleh.com (ramnit)zamdazhocs.com (nymaim)mxdsbbnxmogo.online (tinba)pelkbazgro.info (pykspa)</td></tr></table>
+
+The results in Table 2 are for DGA domain names that appeared at the same time in real traffic as the training data used to construct the classifiers, namely July 2017. To evaluate how well the trained models hold up against DGA domain names that appear at a later point, we collected an additional 100K DGA domain names from the Bambenek Consulting feeds for Dec 6, Dec 9, and Dec 10, 2017. Table 4 contains results for this “prospective” dataset. The only difference between the experimental setup for Table 2 and Table 4 are the 100K DGA domain names used in the test set. The training dataset, the validation dataset, and the 100K Alexa domain names used in the test set are kept the same. As can be seen when comparing the results in Table 2 and Table 4, the to be expected drop in TPR is minor.
+
+As Table 5 shows there is a substantial distinction among the different models in terms of complexity (number of parameters that have to be learned during the training process) and required training time per epoch. The platform used for training is an AWS virtual machine with access to multiple GPUs. Both the number of epochs needed to train a network, and the number of seconds required per epoch, are contributing factors to the overall training runtime. The NYU model took less than 8 minutes to train, while the CMU model took as much as 10 hours. The last column in Table 5 shows the time needed to classify 200K domain names with an already trained model. The ranking of the deep networks in terms of this “scoring time” coincides with the ranking in terms of training time. Given that all deep networks achieve a similar accuracy (TPR), the NYU model with it short training and scoring time comes out as the winner.
+
+Table 4: Results on test data from December 2017. Accuracy, TPR, FPR are w.r.t. a threshold that gives a FPR of 0.001 on the validation data.   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=2>Architecture</td><td rowspan=1 colspan=1>Acc</td><td rowspan=1 colspan=1>TPR</td><td rowspan=1 colspan=1>FPR</td><td rowspan=1 colspan=1>AUC@1%</td></tr><tr><td rowspan=1 colspan=1>RF</td><td rowspan=1 colspan=2>Lexical features</td><td rowspan=1 colspan=1>91.57%</td><td rowspan=1 colspan=1>83.26%</td><td rowspan=1 colspan=1>0.00128</td><td rowspan=1 colspan=1>84.47%</td></tr><tr><td rowspan=1 colspan=1>MLP</td><td rowspan=1 colspan=2>Lexical features</td><td rowspan=1 colspan=1>78.87%</td><td rowspan=1 colspan=1>57.86%</td><td rowspan=1 colspan=1>0.00091</td><td rowspan=1 colspan=1>67.23%</td></tr><tr><td rowspan=1 colspan=1>Embedding</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>86.75%</td><td rowspan=1 colspan=1>73.61%</td><td rowspan=1 colspan=1>0.00108</td><td rowspan=1 colspan=1>82.93%</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>LSTM</td><td rowspan=1 colspan=1>CNN</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Endgame</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>98.22%</td><td rowspan=1 colspan=1>96.54%</td><td rowspan=1 colspan=1>0.00102</td><td rowspan=1 colspan=1>97.53%</td></tr><tr><td rowspan=1 colspan=1>Invincea</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>98.44%</td><td rowspan=1 colspan=1>97.00%</td><td rowspan=1 colspan=1>0.00109</td><td rowspan=1 colspan=1>97.07%</td></tr><tr><td rowspan=1 colspan=1>CMU</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>98.06%</td><td rowspan=1 colspan=1>96.23%</td><td rowspan=1 colspan=1>0.00108</td><td rowspan=1 colspan=1>97.46%</td></tr><tr><td rowspan=1 colspan=1>MIT</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>98.21%</td><td rowspan=1 colspan=1>96.52%</td><td rowspan=1 colspan=1>0.00099</td><td rowspan=1 colspan=1>97.52%</td></tr><tr><td rowspan=1 colspan=1>NYU</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>98.12%</td><td rowspan=1 colspan=1>96.35%</td><td rowspan=1 colspan=1>0.00116</td><td rowspan=1 colspan=1>97.10%</td></tr></table>
+
+Table 5: Comparison of complexity and efficiency of classifiers for DGA detection. The complexity refers to the number of parameters that have to be learned in the deep learning architectures. The training time is reported in terms of seconds needed for an epoch times the number of epochs. The scoring time is the time in seconds needed to label 200K domain names by an already trained model.   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=2>Architecture</td><td rowspan=1 colspan=1>Complexity</td><td rowspan=1 colspan=1>Training&#x27;Time</td><td rowspan=1 colspan=1>Scoring time</td></tr><tr><td rowspan=1 colspan=1>RF</td><td rowspan=1 colspan=2>Lexical features</td><td rowspan=1 colspan=1>100 trees</td><td rowspan=1 colspan=1>1,800s</td><td rowspan=1 colspan=1>5s</td></tr><tr><td rowspan=1 colspan=1>MLP</td><td rowspan=1 colspan=2>Lexical features</td><td rowspan=1 colspan=1>1,665 par</td><td rowspan=1 colspan=1>10s× 40=  400s</td><td rowspan=1 colspan=1>1s</td></tr><tr><td rowspan=1 colspan=1>Embedding</td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1>25,985 par</td><td rowspan=1 colspan=1>15s × 40=  600s</td><td rowspan=1 colspan=1>3s</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>LSTM</td><td rowspan=1 colspan=1>CNN</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Endgame</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>148,097 par</td><td rowspan=1 colspan=1>430s × 10= 4,300s</td><td rowspan=1 colspan=1>13s</td></tr><tr><td rowspan=1 colspan=1>Invincea</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>2,576,385 par</td><td rowspan=1 colspan=1>105s × 40= 4,200s</td><td rowspan=1 colspan=1>7s</td></tr><tr><td rowspan=1 colspan=1>CMU</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>115,329 par</td><td rowspan=1 colspan=1>1200s ×30= 36,000s</td><td rowspan=1 colspan=1>26s</td></tr><tr><td rowspan=1 colspan=1>MIT</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>115,137 par</td><td rowspan=1 colspan=1>800s ×15=  12,000s</td><td rowspan=1 colspan=1>10s</td></tr><tr><td rowspan=1 colspan=1>NYU</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>254,337 par</td><td rowspan=1 colspan=1>45s ×10= 450s</td><td rowspan=1 colspan=1>5s</td></tr></table>
+
+# 5 CONCLUSION
+
+DGA detection, i.e. the classification task of distinguishing between benign domain names and those generated by malware (Domain Generation Algorithms), has become a central topic in information security. In this paper we have compared five different deep neural network architectures that perform this classification task based purely on the domain name string, given as a raw input signal at character level. All five models, i.e. two RNN based architectures, two CNN based architectures, and one hybrid RNN/CNN architecture perform equally well, catching around $9 7 . 9 8 \%$ of malicious domain names against a false positive rate of 0.001. This roughly means that for every 970 malicious domain names that the deep networks catch, they flag only one benign domain name erroneously as malicious. A Random Forest based on human defined linguistic features achieves a recall of only $83 \%$ against the same 0.001 false positive rate when trained and tested on the same data that was used for the deep networks. The use of a deep neural network that automatically learns features is attractive in a cybersecurity setting because it is a lot harder to craft malware to avoid detection by a system that relies on automatically learned features instead of on human engineered features. An interesting direction for future work is to test the trained deep networks more extensively on domain names generated by new and previously unseen malware families.
+
+# REFERENCES
+
+Hyrum S Anderson, Jonathan Woodbridge, and Bobby Filar. Deepdga: Adversarially-tuned domain generation and detection. In Proceedings of the 2016 ACM Workshop on Artificial Intelligence and Security, pp. 13–21, 2016.
+
+Manos Antonakakis, Roberto Perdisci, Yacin Nadji, Nikolaos Vasiloglou II, Saeed Abu-Nimeh, Wenke Lee, and David Dagon. From throw-away traffic to bots: Detecting the rise of DGA-based malware. In USENIX Security Symposium, volume 12, 2012.
+
+Bhuwan Dhingra, Zhong Zhou, Dylan Fitzpatrick, Michael Muehl, and William Cohen. Tweet2vec: Character-based distributed representations for social media. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics, volume 2, pp. 269–274, 2016.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014a.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014b.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 9(8): 1735–1780, 1997.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. preprint arXiv:1412.6980, 2014.
+
+Wang Ling, Tiago Lu´ıs, Lu´ıs Marujo, Ramon Fernandez Astudillo, Silvio Amir, Chris Dyer, Alan W ´ Black, and Isabel Trancoso. Finding function in form: Compositional character models for open vocabulary word representation. arXiv preprint arXiv:1508.02096, 2015.
+
+Joshua Saxe and Konstantin Berlin. eXpose: A character-level convolutional neural network with embeddings for detecting malicious urls, file paths and registry keys. arXiv preprint arXiv:1702.08568, 2017.
+
+Stefano Schiavoni, Federico Maggi, Lorenzo Cavallaro, and Stefano Zanero. Phoenix: DGA-based botnet tracking and intelligence. In International Conference on Detection of Intrusions and Malware, and Vulnerability Assessment, pp. 192–211, 2014.
+
+Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+Soroush Vosoughi, Prashanth Vijayaraghavan, and Deb Roy. Tweet2vec: Learning tweet embeddings using character-level cnn-lstm encoder-decoder. In Proceedings of the 39th International ACM SIGIR conference on Research and Development in Information Retrieval, pp. 1041–1044, 2016.
+
+Jonathan Woodbridge, Hyrum S Anderson, Anjum Ahuja, and Daniel Grant. Predicting domain generation algorithms with long short-term memory networks. preprint arXiv:1611.00791, 2016.
+
+Bin Yu, Les Smith, and Mark Threefoot. Semi-supervised time series modeling for real-time flux domain detection on passive DNS traffic. In Proc. of the 10th International Conference on Machine Learning and Data Mining, pp. 258–271, 2014.
+
+Bin Yu, Les Smith, Mark Threefoot, and Femi Olumofin. Behavior analysis based DNS tunneling detection with big data technologies. In Proc. of the International Conference on Internet of Things and Big Data, pp. 284–290, 2016.
+
+Bin Yu, Daniel Gray, Jie Pan, Martine De Cock, and Anderson Nascimento. Inline dga detection with deep networks. In Proceedings of Data Mining for Cyber Security (DMCS2017), workshop at ICDM2017 (IEEE International Conference on Data Mining), 2017.
+
+Xiang Zhang, Junbo Zhao, and Yann LeCun. Character-level convolutional networks for text classification. In Advances in Neural Information Processing Systems, volume 28, pp. 649–657, 2015.
+
+# A KERAS CODE FOR DEEP NETWORKS
+
+main input $=$ Input (shape $: =$ (75, ) , dtype $z '$ int32 ’, name $\mathbf { \equiv }$ ’main input’)   
+embedding $=$ Embedding(input dim ${ \tt 1 2 8 }$ , output dim ${ \tt 1 2 8 }$ , input length $= 7 5$ )(main input )   
+lstm $=$ LSTM(128, return sequence $\vDash$ False) (embedding)   
+drop $=$ Dropout(0.5) ( lstm )   
+output $=$ Dense(1, activation $= ^ { \mathrm { i } }$ ’sigmoid’) (drop)   
+model $=$ Model(inputs $\mathbf { \sigma } =$ main input, outputs $=$ output)   
+model.compile( ${ \mathrm { l o s s } } = { \ ' }$ binary crossentropy ’, optimizer $= ^ { \ ' }$ adam’)   
+main input $=$ Input (shape=(75, ) , dtype=’int32 ’, name $u = { \mathrm { i } }$ ’main input’)   
+embedding $=$ Embedding(input dim ${ \tt 1 2 8 }$ , output dim ${ \tt 1 2 8 }$ , input length $= 7 5$ )(main input )   
+bi lstm $=$ Bidirectional ( layer =LSTM(64, return sequence $\mathrm {  ~ \sigma ~ } \mathrm {  ~ \sigma ~ } \mathrm {  ~ \sigma ~ } \mathrm {  ~ \sigma ~ }$ False) , merge mode=’concat’)(embedding)   
+output $=$ Dense(1, activation $= ^ { \overrightarrow { { \mathbf { \Gamma } } } }$ ’sigmoid’) ( bi lstm )   
+model $=$ Model(inputs main input, outputs $=$ output)   
+model.compile( ${ \mathrm { l o s s } } = { \ ' }$ binary crossentropy ’, optimizer $= ^ { \ ' }$ adam’)   
+main input $=$ Input (shape $: = 1$ (75, ) , dtype $= ^ { \ ' }$ int32 ’, name $z '$ ’main input’)   
+embedding $=$ Embedding(input dim ${ \tt 1 2 8 }$ , output dim ${ \tt 1 2 8 }$ , input length $= 7 5$ )(main input )   
+conv1 $=$ Conv1D( filters ${ } = 1 2 8$ , kernel size $^ { = 3 }$ , padding $= ^ { \ast }$ ’same’, strides $^ { = 1 }$ )(embedding)   
+thresh1 $=$ ThresholdedReLU(1e−6)(conv1)   
+max pool1 $=$ MaxPooling1D(pool size $^ { = 2 }$ , padding=’same’)(thresh1 )   
+conv $\ ? =$ Conv1D( filters ${ } = 1 2 8$ , kernel size $^ { = 2 }$ , padding $= ^ { \overrightarrow { } }$ ’same’, strides $^ { = 1 }$ )(max pool1)   
+thresh2 $=$ ThresholdedReLU(1e−6)(conv2)   
+max pool2 $=$ MaxPooling1D(pool size $^ { = 2 }$ , padding=’same’)(thresh2 )   
+flatten $=$ Flatten () (max pool2)   
+fc $=$ Dense(64)( flatten )   
+thresh fc $=$ ThresholdedReLU(1e−6)(fc)   
+drop $=$ Dropout(0.5) ( thresh fc )   
+output $=$ Dense(1, activation $= ^ { \overrightarrow { { \mathbf { \Gamma } } } }$ ’sigmoid’) (drop)   
+model $=$ Model(inputs=main input, outputs $=$ output)   
+model.compile( ${ \mathrm { l o s s } } = { \ ' }$ binary crossentropy ’, optimizer $= ^ { \ ' }$ adam’)
+
+def getconvmodel( self , kernel size , filters ) : model $=$ Sequential () model.add( Conv1D( filters $=$ filters , input shape $=$ (128, 128), kernel size $=$ kernel size , padding=’same’, activation $= ^ { \ ' }$ relu ’, strides $\mathbf { \tau } = 1 \dot { }$ )) model.add(Lambda(lambda x: K.sum(x, axi $^ { - 1 }$ ), output shape $=$ ( filters , ) ) ) model.add(Dropout(0.5) ) return model
+
+middle $=$ Dropout(0.5) (middle)
+
+<table><tr><td rowspan=1 colspan=1>output = Dense(1,activation =&#x27;sigmoid&#x27;)(middle)model = Model(inputs=main_input, outputs =output)model.compile(loss=&#x27;binary_crossentropy’，optimizer=&#x27;adam&#x27;)</td></tr><tr><td rowspan=1 colspan=1>Listing 4: Invincea CNN model with parallel CNN layers,adapted from Saxe &amp; Berlin (2017)</td></tr><tr><td rowspan=1 colspan=1>main_input = Input(shape=(75,），dtype=&#x27; int32’，name=&#x27;main_input&#x27;)embedding =Embedding(input_dim=128,output_dim=128,input_length=75)(main_input)conv = Conv1D(filters =128,kernel_size =3，padding=&#x27;same&#x27;，activation =&#x27;relu’,strides=1)(embedding)max_pool = MaxPooling1D(pool_size=2, padding=&#x27;same&#x27;)(conv)encode = LSTM(64, return_sequences=False)(max-pool)output = Dense(1， activation =&#x27;sigmoid&#x27;)(encode)model= Model(inputs=main_input， outputs =output)model.compile(loss=’ binary_crossentropy’， optimizer=&#x27;adam&#x27;)</td></tr><tr><td rowspan=1 colspan=1>Listing 5: MIT model with a stacked CNN and LSTM layer,adapted from Vosoughi et al. (2016)</td></tr><tr><td rowspan=1 colspan=1>main_input = Input(shape=(75,)，dtype=&#x27; int32’，name=&#x27;main_input&#x27;)embedding =Embedding(input_dim=128,output_dim=128,input_length=75)(main_input)flatten = Flatten ((embedding)output = Dense(1， activation =&#x27;sigmoid&#x27;)( flatten ）model = Model(inputs=main_input， outputs =output)print (model.summaryO)model.compile(loss=&#x27; binary_crossentropy’，optimizer=&#x27;adam&#x27;)</td></tr><tr><td rowspan=1 colspan=1>Listing 6: Baseline Model with only Embedding Layer</td></tr><tr><td rowspan=1 colspan=1>main_input = Input(shape=(11,)，name=&#x27;main_input&#x27;)dense = Dense(128,activation =&#x27;relu &#x27;)(main_input)output = Dense(1， activation =&#x27;sigmoid&#x27;)(dense)model = Model(inputs=main_input， outputs =output)print (model.summaryO)model.compile(loss=&#x27;binary_crossentropy’，optimizer=&#x27;adam&#x27;)</td></tr></table>

parse/train/RQfcckT1M_4/RQfcckT1M_4.md

@@ -0,0 +1,289 @@
+# Self-Supervised Learning Disentangled Group Representation as Feature
+
+Tan Wang1 Zhongqi Yue1,3 Jianqiang Huang1,3 Qianru Sun2 Hanwang Zhang1 1Nanyang Technological University 2Singapore Management University 3Damo Academy, Alibaba Group {tan317,yuez0003,hanwangzhang}@ntu.edu.sg jianqiang.jqh@gmail.com qianrusun@smu.edu.sg
+
+# Abstract
+
+A good visual representation is an inference map from observations (images) to features (vectors) that faithfully reflects the hidden modularized generative factors (semantics). In this paper, we formulate the notion of “good” representation from a group-theoretic view using Higgins’ definition of disentangled representation [40], and show that existing Self-Supervised Learning (SSL) only disentangles simple augmentation features such as rotation and colorization, thus unable to modularize the remaining semantics. To break the limitation, we propose an iterative SSL algorithm: Iterative Partition-based Invariant Risk Minimization (IP-IRM), which successfully grounds the abstract semantics and the group acting on them into concrete contrastive learning. At each iteration, IP-IRM first partitions the training samples into two subsets that correspond to an entangled group element. Then, it minimizes a subset-invariant contrastive loss, where the invariance guarantees to disentangle the group element. We prove that IP-IRM converges to a fully disentangled representation and show its effectiveness on various benchmarks. Codes are available at https://github.com/Wangt-CN/IP-IRM.
+
+# 1 Introduction
+
+Deep learning is all about learning feature representations [5]. Compared to the conventional end-to-end supervised learning, Self-Supervised Learning (SSL) first learns a generic feature representation (e.g., a network backbone) by training with unsupervised pretext tasks such as the prevailing contrastive objective [36, 16], and then the above stage-1 feature is expected to serve various stage-2 applications with proper fine-tuning. SSL for visual representation is so fascinating that it is the first time that we can obtain “good” visual features for free, just like the trending pre-training in NLP community [26, 8]. However, most SSL works only care how much stage-2 performance an SSL feature can improve, but overlook what feature SSL is learning, why it can be learned, what cannot be learned, what the gap between SSL and Supervised Learning (SL) is, and when SSL can surpass SL?
+
+![](images/c09c68e3a9b29274dd39164ae5dd8d3b9b29d4f593e95a2d4e980e72cba9449f.jpg)  
+Figure 1: Disentangled representation is an equivariant map between the semantic space $\mathcal { U }$ and the vector space $\mathcal { X }$ , which is decomposed into “color” and “digit”.
+
+The crux of answering those questions is to formally understand what a feature representation is and what a good one is. We postulate the classic world model of visual generation and feature representation [1, 69] as in Figure 1. Let $\mathcal { U }$ be a set of (unseen) semantics, e.g., attributes such as “digit” and “color”. There is a set of independent and causal mechanisms [66] $\varphi : \mathcal { U } \to \mathcal { T }$ , generating images from semantics, e.g., writing a digit $ { { } ^ { 6 } } 0 ^ { 9 }$ when thinking of $\mathbf { \vec { \nabla } } _ { 0 } , \mathbf { \vec { \mathbf { \phi } } } _ { }$ [74]. A visual representation is the inference process $\phi : \mathcal { T }  \mathcal { X }$ that maps image pixels to vector space features, e.g., a neural network. We define semantic representation as the functional composition $f : \mathcal { U } \to \mathcal { T } \to \mathcal { X }$ . In this paper, we are only interested in the parameterization of the inference process for feature extraction, but not the generation process, i.e., we assume $\forall I \in \mathcal { T }$ , $\exists u \in \mathcal { U }$ , such that $I = \varphi ( u )$ is fixed as the observation of each image sample. Therefore, we consider semantic and visual representations the same as feature representation, or simply representation, and we slightly abuse ${ \dot { \phi } } ( I ) : = f \left( \varphi ^ { - 1 } ( I ) \right)$ , i.e., $\phi$ and $f$ share the same trainable parameters. We call the vector $\mathbf { x } = \phi ( I )$ as feature, where $\mathbf { x } \in \mathcal { X }$ .
+
+![](images/ebfb7e755e05b382aa1a1291d0d35552c8ff9d1adc92bfba383d35ddeea7ad26.jpg)  
+Figure 2: (a) The heat map visualizes feature dimensions related to augmentations (aug. related) and unrelated to augmentations (aug. unrelated), whose respective classification accuracy is shown in the bar chart below. Dashed bar denotes the accuracy using full feature dimensions. Experiment was performed on STL10 [22] with representation learnt with SimCLR [16] and our IP-IRM. (b) Visualization of CNN activations [77] of 4 filters on layer 29 and 18 of VGG [75] trained on ImageNet100 [81]. The filters were chosen by first clustering the aug. unrelated filters with $k$ -means $k = 4$ ) and then selecting the filters corresponding to the cluster centers.
+
+# We propose to use Higgins’ definition of disentangled representation [40] to define what is “good”.
+
+Definition 1. (Disentangled Representation) Let $\mathcal { G }$ be the group acting on $\mathcal { U }$ , i.e., $g \cdot u \in \mathcal { U } \times \mathcal { U }$ transforms $u \in \mathcal { U }$ , e.g., a “turn green” group element changing the semantic from “red” to “green”. Suppose there is a direct product decomposition1 $\mathcal { G } = g _ { 1 } \times . . . \times g _ { m }$ and ${ \mathcal { U } } = { \mathcal { U } } _ { 1 } \times \ldots \times { \mathcal { U } } _ { m }$ , where $g _ { i }$ acts on $\mathcal { U } _ { i }$ respectively. A feature representation is disentangled if there exists a group $\mathcal { G }$ acting on $\mathcal { X }$ such that:
+
+1. Equivariant: $\forall g \in \mathcal { G } , \forall u \in \mathcal { U }$ , $f ( g \cdot u ) = g \cdot f ( u )$ , e.g., the feature of the changed semantic: “red” to “green” in $\mathcal { U }$ , is equivalent to directly change the color vector in $\mathcal { X }$ from “red” to “green”.   
+2. Decomposable: there is a decomposition ${ \mathcal { X } } = { \mathcal { X } } _ { 1 } \times \ldots \times { \mathcal { X } } _ { m } ,$ , such that each $\mathcal { X } _ { i }$ is fixed by the action of all $g _ { j } , j \neq i$ and affected only by $g _ { i }$ , e.g., changing the “color” semantic in $\mathcal { U }$ does not affect the “digit” vector in $\mathcal { X }$ .
+
+Compared to the previous definition of feature representation which is a static mapping, the disentangled representation in Definition 1 is dynamic as it explicitly incorporate group representation [35], which is a homomorphism from group to group actions on a space, e.g., $\mathcal { G }  \mathcal { X } \times \mathcal { X }$ , and it is common to use the feature space $\mathcal { X }$ as a shorthand—this is where our title stands.
+
+Definition 1 defines “good” features in the common views: 1) Robustness: a good feature should be invariant to the change of environmental semantics, such as external interventions [45, 87] or domain shifts [32]. By the above definition, a change is always retained in a subspace $\mathcal { X } _ { i }$ , while others are not affected. Hence, the subsequent classifier will focus on the invariant features and ignore the ever-changing $\mathcal { X } _ { i }$ . 2) Zero-shot Generalization: even if a new combination of semantics is unseen in training, each semantic has been learned as features. So, the metrics of each $\mathcal { X } _ { i }$ trained by seen samples remain valid for unseen samples [95].
+
+Are the existing SSL methods learning disentangled representations? No. We show in Section 4 that they can only disentangle representations according to the hand-crafted augmentations, e.g., color jitter and rotation. For example, in Figure 2 (a), even if we only use the augmentation-related feature, the classification accuracy of a standard SSL (SimCLR [16]) does not lose much as compared to the full feature use. Figure 2 (b) visualizes that the CNN features in each layer are indeed entangled (e.g., tyre, motor, and background in the motorcycle image). In contrast, our approach IP-IRM, to be introduced below, disentangles more useful features beyond augmentations.
+
+In this paper, we propose Iterative Partition-based Invariant Risk Minimization (IP-IRM [­ai"p@:m]) that guarantees to learn disentangled representations in an SSL fashion. We present the algorithm in Section 3, followed by the theoretical justifications in Section 4. In a nutshell, at each iteration, IP-IRM first partitions the training data into two disjoint subsets, each of which is an orbit of the already disentangled group, and the cross-orbit group corresponds to an entangled group element $g _ { i }$ Then, we adopt the Invariant Risk Minimization (IRM) [2] to implement a partition-based SSL, which disentangles the representation $\mathcal { X } _ { i }$ w.r.t. $g _ { i }$ . Iterating the above two steps eventually converges to a fully disentangled representation w.r.t. $\textstyle \prod _ { i = 1 } ^ { m } g _ { i }$ . In Section 5, we show promising experimental results on various feature disentanglement and SSL benchmarks.
+
+# 2 Related Work
+
+Self-Supervised Learning. SSL aims to learn representations from unlabeled data with hand-crafted pretext tasks [28, 63, 33]. Recently, Contrastive learning [65, 61, 38, 80, 16] prevails in most state-ofthe-art methods. The key is to map positive samples closer, while pushing apart negative ones in the feature space. Specifically, the positive samples are from the augmented views [82, 3, 94, 42] of each instance and the negative ones are other instances. Along this direction, follow-up methods are mainly four-fold: 1) Memory-bank [90, 61, 36, 18]: storing the prototypes of all the instances computed previously into a memory bank to benefit from a large number of negative samples. 2) Using siamese network [7] to avoid representation collapse [34, 19, 83]. 3) Assigning clusters to samples to integrate inter-instance similarity into contrastive learning [11, 12, 13, 88, 56]. 4) Seeking hard negative samples with adversarial training or better sampling strategies [73, 20, 44, 48]. In contrast, our proposed IP-IRM jumps out of the above frame and introduces the disentangled representation into SSL with group theory to show the limitations of existing SSL and how to break through them.
+
+Disentangled Representation. This notion dates back to [4], and henceforward becomes a highlevel goal of separating the factors of variations in the data [84, 79, 86, 58]. Several works aim to provide a more precise description [27, 29, 72] by adopting an information-theoretic view [17, 27] and measuring the properties of a disentangled representation explicitly [29, 72]. We adopt the recent group-theoretic definition from Higgins et al. [40], which not only unifies the existing, but also resolves the previous controversial points [78, 59]. Although supervised learning of disentangled representation is a well-studied field [100, 43, 10, 70, 49], unsupervised disentanglement based on GAN [17, 64, 57, 71] or VAE [39, 15, 99, 50] is still believed to be theoretically challenging [59]. Thanks to the Higgins’ definition, we prove that the proposed IP-IRM converges with full-semantic disentanglement using group representation theory. Notably, IP-IRM learns a disentangled representation with an inference process, without using generative models as in all the existing unsupervised methods, making IP-IRM applicable even on large-scale datasets.
+
+Group Representation Learning. A group representation has two elements [47, 35]: 1) a homomorphism (e.g., a mapping function) from the group to its group action acting on a vector space, and 2) the vector space. Usually, when there is no ambiguity, we can use either element as the definition. Most existing works focus on learning the first element. They first define the group of interest, such as spherical rotations [24] or image scaling [89, 76], and then learn the parameters of the group actions [23, 46, 68]. In contrast, we focus on the second element; more specifically, we are interested in learning a map between two vector spaces: image pixel space and feature vector space. Our representation learning is flexible because it delays the group action learning to downstream tasks on demand. For example, in a classification task, a classifier can be seen as a group action that is invariant to class-agnostic groups but equivariant to class-specific groups (see Section 4).
+
+# 3 IP-IRM Algorithm
+
+Notations. Our goal is to learn the feature extractor $\phi$ in a self-supervised fashion. We define a partition matrix $\bar { \mathbf { P } } \in \{ 0 , 1 \} ^ { N \times 2 }$ that partitions $N$ training images into 2 disjoint subsets. $P _ { i , k } = 1$ if the $i$ -th image belongs to the $k$ -th subset and 0 otherwise. Suppose we have a pretext task loss
+
+function $\mathcal { L } ( \phi , \theta = 1 , k , \mathbf { P } )$ defined on the samples in the $k$ -th subset, where $\theta = 1$ is a “dummy” parameter used to evaluate the invariance of the SSL loss across the subsets (later discussed in Step 1). For example, $\mathcal { L }$ can be defined as:
+
+$$
+\mathcal { L } ( \phi , \theta = 1 , k , \mathbf { P } ) = \sum _ { \mathbf { x } \in \mathcal { X } _ { k } } - \log \frac { \exp \left( \mathbf { x } ^ { T } \mathbf { x } ^ { * } \cdot \theta \right) } { \sum _ { \mathbf { x ^ { \prime } } \in \mathcal { X } _ { k } \cup \mathcal { X } ^ { * } \setminus \mathbf { x } } \exp \left( \mathbf { x } ^ { T } \mathbf { x } ^ { \prime } \cdot \theta \right) } ,
+$$
+
+where $\mathcal { X } _ { k } = \phi ( \{ I _ { i } | P _ { i , k } = 1 \} )$ , and $\mathbf { x } ^ { * } \in \mathcal { X } ^ { * }$ is the augmented view feature of $\mathbf { x } \in \mathcal { X } _ { k }$ .
+
+Input. $N$ training images. Randomly initialized $\phi$ . A partition matrix $\mathbf { P }$ initialized such that the first column of $\mathbf { P }$ is 1, i.e., all samples belong to the first subset. Set $\mathcal { P } = \{ \bf P \}$ .
+
+Output. Disentangled feature extractor $\phi$ .
+
+Step 1 [Update $\phi ]$ . We update $\phi$ by:
+
+$$
+\operatorname* { m i n } _ { \phi } \sum _ { \mathbf { P } \in \mathcal { P } } \sum _ { k = 1 } ^ { 2 } \left[ \mathcal { L } ( \phi , \theta = 1 , k , \mathbf { P } ) + \lambda _ { 1 } \left. \nabla _ { \theta = 1 } \mathcal { L } ( \phi , \theta = 1 , k , \mathbf { P } ) \right. ^ { 2 } \right] ,
+$$
+
+where $\lambda _ { 1 }$ is a hyper-parameter. The second term delineates how far the contrast in one subset is from a constant baseline $\theta = 1$ . The minimization of both of them encourages $\phi$ in different subsets close to the same baseline, i.e., invariance across the subsets. See IRM [2] for more details. In particular, the first iteration corresponds to the standard SSL with $\mathcal { X } _ { 1 }$ in Eq. (1) containing all training images.
+
+Step 2 [Update P]. We fix $\phi$ and find a new partition $\mathbf { P } ^ { * }$ by
+
+$$
+{ \bf P } ^ { * } = \arg \operatorname* { m a x } _ { { \bf P } } \sum _ { { \bf k } = 1 } ^ { 2 } \left[ \mathcal { L } ( \phi , \theta = 1 , k , { \bf P } ) + \lambda _ { 2 } \| \nabla _ { \theta = 1 } \mathcal { L } ( \phi , \theta = 1 , k , { \bf P } ) \| ^ { 2 } \right] ,
+$$
+
+where $\lambda _ { 2 }$ is a hyper-parameter. In practice, we use a continuous partition matrix in $\mathbb { R } ^ { N \times 2 }$ during optimization and then threshold it to $\{ 0 , 1 \} ^ { N \times 2 }$ .
+
+We update $\mathcal { P }  \mathcal { P } \cup \mathbf { P ^ { * } }$ and iterate the above two steps until convergence.
+
+# 4 Justification
+
+Recall that IP-IRM uses training sample partitions to learn the disentangled representations w.r.t. $\textstyle \prod _ { i = 1 } ^ { m } g _ { i }$ . As we have a $\mathcal { G }$ -equivariant feature map between the sample space $\mathcal { T }$ and feature space $\mathcal { X }$ (the equivariance is later guaranteed by Lemma 1), we slightly abuse the notation by using to denote both spaces. Also, we assume that $\mathcal { X }$ is a homogeneous space of $\mathcal { G }$ , i.e., any sample $\mathbf { x } ^ { \prime } \in \mathcal { X }$ can be transited from another sample $\mathbf { x }$ by a group action $g \cdot { \bf x }$ . Intuitively, $\mathcal { G }$ is all you need to describe the diversity of the training set. It is worth noting that $g$ is any group element in $\mathcal { G }$ while $g _ { i }$ is a Cartesian “building block” of $\mathcal { G }$ , e.g., $g$ can be decomposed by $( g _ { 1 } , g _ { 2 } , . . . , g _ { m } )$ .
+
+We show that partition and group are tightly connected by the concept of orbit. Given a sample $\mathbf { x } \in \mathcal { X }$ , its group orbit w.r.t. $\mathcal { G }$ is a sample set $\mathcal { G } ( \mathbf { x } ) = \{ g \cdot \mathbf { \dot { x } } \mid g \in \mathcal { G } \}$ . As shown in Figure 3 (a), if $\mathcal { G }$ is a set of attributes shared by classes, e.g., “color” and “pose ”, the orbit is the sample set of the class of $\mathbf { x }$ ; in Figure 3 (b), if $\mathcal { G }$ denotes augmentations, the orbit is the set of augmented images. In particular, we can see that the disjoint orbits in Figure 3 naturally form a partition. Formally, we have the following definition:
+
+Definition 2. (Orbit & Partition [47]) Given a subgroup $\mathcal { D } \subset \mathcal { G }$ , it partitions $\mathcal { X }$ into the disjoint subsets: $\{ \mathcal { D } ( c _ { 1 } \cdot \mathbf { x } ) , . . . , D ( c _ { k } \cdot \mathbf { x } ) \}$ , where $k$ is the number of cosets $\{ c _ { 1 } \mathcal { D } , . . . , c _ { k } \mathcal { D } \}$ , and the cosets form a factor group1 $\mathcal { G } / \mathcal { D } = \{ c _ { i } \} _ { i = 1 } ^ { k }$ . In particular, $c _ { i } \cdot \mathbf { x }$ can be considered as a sample of the i-th class, transited from any sample $\mathbf { x } \in \mathcal { X }$ .
+
+Interestingly, the partition offers a new perspective for the training data format in Supervised Learning (SL) and Self-Supervised Learning (SSL). In SL, as shown in Figure 3 (a), the data is labeled with $k$ classes, each of which is an orbit with $\mathcal { D } ( c _ { i } \cdot \mathbf { x } )$ training samples, whose variations are depicted by the class-sharing attribute group $\mathcal { D }$ . The cross-orbit group action, e.g., $c _ { \mathrm { d o g } } \cdot \mathbf { x }$ , can be read as “turn $\mathbf { x }$ into a dog” and such “turn” is always valid due to the assumption that $\mathcal { X }$ is a homogeneous space of $\mathcal { G }$ . In SSL, as shown in Figure 3 (b), each training sample $\mathbf { x }$ is augmented by the group $\mathcal { D }$ . So, $\mathcal { D } ( c _ { i } \cdot \mathbf { x } )$ consists of all the augmentations of the $i$ -th sample, where the cross-orbit group action $c _ { i } \cdot \mathbf { x }$ can be read as “turn $\mathbf { x }$ into the $i$ -th sample”.
+
+![](images/8042e6e44f14e109a8f8b996514bb1696a28987024774dc510c801d39646ea4f.jpg)  
+Figure 3: Each orbit only illustrates with 5 samples. (a) Orbit: the training samples of a class; $\mathcal { D }$ in-orbit actions: intra-class variations $\cdot {  } 2$ :standing, $2  3$ :blacken, $3 {  } 4$ :jumping, $4 {  } 5$ :whiten, $5 {  } 1$ :running); $\mathcal { G } / \mathcal { D }$ cross-orbit actions: inter-class variations. (b) Orbit: a sample and its augmented samples; $\mathcal { D }$ in-orbit actions: augmentations $1 \to 2$ :clock-wise rotation, $2  3$ :color jitter, $3 {  } 4$ :gray scale, $4 {  } 5$ :counterclockwise rotation, $5 {  } 1$ :color); $\mathcal { G } / \mathcal { D }$ cross-orbit actions: inter-sample variations. (c) Step 2 in IP-IRM discovers 2 orbits, where the cross-orbit action corresponds to a group action “green to red” or “red to green”, which is yet disentangled.
+
+Thanks to the orbit and partition view of training data, we are ready to revisit model generalization in a group-theoretic view by using invariance and equivariance—the two sides of the coin, whose name is disentanglement. For SL, we expect that a good feature is disentangled into a class-agnostic part and a class-specific part: the former (latter) is invariant (equivariant) to $\mathcal { G } / \mathcal { D }$ —cross-orbit traverse, but equivariant (invariant) to $\mathcal { D }$ —in-orbit traverse. By using such feature, a model can generalize to diverse testing samples (limited to $| \mathcal D |$ variations) by only keeping the class-specific feature. Formally, we prove that we can achieve such disentanglement by contrastive learning:
+
+Lemma 1. (Disentanglement by Contrastive Learning) Training loss $\begin{array} { r } { - \log \frac { \exp ( \mathbf { x } _ { i } ^ { T } \mathbf { x } _ { j } ) } { \sum _ { \mathbf { x } \in \mathcal { X } } \exp ( \mathbf { x } _ { j } ^ { T } \mathbf { x } ) } } \end{array}$ disentangles $\mathcal { X }$ w.r.t. $( \mathcal { G } / \mathcal { D } ) \times \mathcal { D }$ , where $\mathbf { x } _ { i }$ and $\mathbf { x } _ { j }$ are from the same orbit.
+
+We can draw the following interesting corollaries from Lemma 1 (details in Appendix):
+
+1. If we use all the samples in the denominator of the loss, we can approximate to $\mathcal { G }$ -equivariant features given limited training samples. This is because the loss minimization guarantees $\forall ( \mathbf { x } _ { i } , \mathbf { x } _ { j } ) { \overset { - } { \in } } { \mathcal { X } } \times { \mathcal { X } } , i \neq j  { \bar { \mathbf { x } } } _ { i } \neq { \bar { \mathbf { x } _ { j } } }$ , i.e., any pair corresponds to a group action.   
+2. Conventional cross-entropy loss in SL is a special case, if we define $\mathbf { x } \in \mathcal { X } = \{ \mathbf { x } _ { 1 } , . . . , \mathbf { x } _ { k } \}$ as $k$ classifier weights. So, SL does not guarantee the disentanglement of $\mathcal { G } / \mathcal { D }$ , which causes generalization error if the class domain of downstream task is different from SL pre-training, e.g., a subset of $\mathcal { G } / \mathcal { D }$ .   
+3. In contrastive learning based SSL, $\mathcal { D } =$ “augmentations” (recall Figure 2), and the number of augmentations $| \mathcal { D } _ { \mathrm { a u g } } |$ is generally much smaller compared to the class-wise sample diversity $| \mathcal { D } _ { \mathrm { S L } } |$ in SL. This enables the SL model to generalize to more diverse testing samples $( | \mathcal { D } _ { \mathrm { S L } } | )$ by filtering out the class-agnostic features (e.g., background) and focusing on the class-specific ones (e.g., foreground), which explains why SSL is worse than SL in downstream classification.   
+4. In SL, if the number of training samples per orbit is not enough, i.e., smaller than $\left| \mathcal { D } ( c _ { i } \cdot \mathbf { x } ) \right|$ , the disentanglement between $\mathcal { D }$ and $\mathcal { G } / \mathcal { D }$ cannot be guaranteed, such as the challenges in few-shot learning [96]. Fortunately, in SSL, the number is enough as we always include all the augmented samples in training. Moreover, we conjecture that $\mathcal { D } _ { \mathrm { a u g } }$ only contains simple cyclic group elements such as rotation and colorization, which are easier for representation learning.
+
+Lemma 1 does not guarantee the decomposability of each $d \in \mathcal { D }$ . Nonetheless, the downstream model can still generalize by keeping the class-specific features affected by $\mathcal { G } / \mathcal { D }$ . Therefore, the key to fill the gap or even let SSL surpass SL is to achieve the full disentanglement of $\mathcal { G } / \mathcal { D } _ { \mathrm { a u g } }$ .
+
+Table 1: Results on disentanglement metrics of existing unsupervised disentanglement methods, standard SSL (SimCLR [16]) and IP-IRM using CMNIST [2] and Shapes3D [50]. Note that IRS is based on intervening the semantics which requires access to the labels of all the semantics, and hence not applicable for CMNIST dataset. Results are averaged over 4 trails (mean $\pm$ std).   
+
+<table><tr><td></td><td>Method</td><td>DCI</td><td>IRS</td><td>MOD</td><td>EXP</td><td>LR</td><td>GBT</td><td>Average</td></tr><tr><td rowspan="6">CSINI</td><td>VAE [51]</td><td>0.948±0.004</td><td>1</td><td>0.664±0.121</td><td>0.968±0.007</td><td>0.824±0.019</td><td>0.948±0.004</td><td>0.849±0.057</td></tr><tr><td>β-VAE [41]</td><td>0.945±0.002</td><td>=</td><td>0.705±0.073</td><td>0.963±0.006</td><td>0.809±0.013</td><td>0.945±0.003</td><td>0.874±0.015</td></tr><tr><td>β-AnnealVAE [9]</td><td>0.911±0.002</td><td></td><td>0.790±0.075</td><td>0.965±0.007</td><td>0.821±0.022</td><td>0.911±0.002</td><td>0.880±0.016</td></tr><tr><td>β-TCVAE[15]</td><td>0.914±0.008</td><td></td><td>0.864±0.095</td><td>0.962±0.010</td><td>0.801±0.024</td><td>0.914±0.008</td><td>0.891±0.014</td></tr><tr><td>Factor-VAE [50]</td><td>0.916±0.004</td><td>=</td><td>0.893±0.056</td><td>0.947±0.011</td><td>0.770±0.025</td><td>0.916±0.005</td><td>0.888±0.014</td></tr><tr><td>SimCLR [16]</td><td>0.882±0.019</td><td></td><td>0.767±0.025</td><td>0.976±0.011</td><td>0.863±0.036</td><td>0.876±0.015</td><td>0.873±0.016</td></tr><tr><td rowspan="7">ssssder</td><td>IP-IRM (Ours)</td><td>0.917±0.008</td><td></td><td>0.785±0.031</td><td>0.990±0.002</td><td>0.921±0.009</td><td>0.916±0.007</td><td>0.906±0.011</td></tr><tr><td>VAE [51]</td><td>0.351±0.026</td><td>0.284±0.009</td><td>0.820±0.015</td><td>0.802±0.054</td><td>0.421±0.079</td><td>0.352±0.027</td><td>0.505±0.028</td></tr><tr><td>β-VAE [41]</td><td>0.369±0.021</td><td>0.283±0.012</td><td>0.782±0.034</td><td>0.807±0.018</td><td>0.427±0.025</td><td>0.368±0.023</td><td>0.506±0.011</td></tr><tr><td>β-AnnealVAE [9]</td><td>0.327±0.069</td><td>0.412±0.049</td><td>0.743±0.070</td><td>0.643±0.013</td><td>0.259±0.021</td><td>0.328±0.070</td><td>0.452±0.023</td></tr><tr><td>β-TCVAE[15]</td><td>0.470±0.035</td><td>0.291±0.023</td><td>0.777±0.031</td><td>0.821±0.054</td><td>0.439±0.084</td><td>0.469±0.034</td><td>0.545±0.032</td></tr><tr><td>Factor-VAE [50]</td><td>0.340±0.021</td><td>0.316±0.016</td><td>0.815±0.041</td><td>0.738±0.043</td><td>0.319±0.045</td><td>0.339±0.021</td><td>0.478±0.020</td></tr><tr><td>SimCLR[16]</td><td>0.535±0.016</td><td>0.439±0.030</td><td>0.678±0.050</td><td>0.949±0.005</td><td>0.733±0.055</td><td>0.536±0.015</td><td>0.645±0.026</td></tr><tr><td></td><td>IP-IRM (Ours)</td><td>0.565±0.023</td><td>0.420±0.014</td><td>0.766±0.036</td><td>0.959±0.007</td><td>0.757±0.025</td><td>0.565±0.023</td><td>0.672±0.017</td></tr></table>
+
+Theorem 1. The representation is fully disentangled w.r.t. $\mathcal { G } / \mathcal { D } _ { \mathrm { a u g } }$ if and only $\vert f \forall c _ { i } \in \mathcal { G } / \mathcal { D } _ { \mathrm { a u g } }$ , the contrastive loss in Eq. (1) is invariant to the 2 orbits of partition $\{ \mathcal { G } ^ { \prime } ( c _ { i } \cdot \mathbf { x } ) , \mathcal { G } ^ { \prime } ( c _ { i } ^ { - 1 } \cdot \mathbf { x } ) \}$ , where $\mathcal { G } ^ { \prime } = \mathcal { G } / c _ { i } = \mathcal { D } _ { \mathrm { a u g } } \times c _ { 1 } \times . . . \times c _ { i - 1 } \times c _ { i + 1 } \times . . . \times c _ { k }$ .
+
+The maximization in Step 2 is based on the contra-position of the sufficient condition of Theorem 1. Denote the currently disentangled group as $\mathcal { D }$ (initially $\mathcal { D } _ { \mathrm { a u g . } }$ ). If we can find a partition $\mathbf { P } ^ { * }$ to maximize the loss in Eq. (3), i.e., SSL loss is variant across the orbits, then $\exists h \in { \mathcal { G } } / { \mathcal { D } }$ such that the representation of $h$ is entangled, i.e., $\mathbf { P ^ { * } } = \{ { \mathcal { D } } ( h \cdot \mathbf { x } ) , { \mathcal { D } } ( h ^ { - 1 } \cdot \mathbf { x } ) \}$ . Figure 3 (c) illustrates a discovered partition about color. The minimization in Step 1 is based on the necessary condition of Theorem 1. Based on the discovered $\mathbf { P } ^ { * }$ , if we minimize Eq. (2), we can further disentangle $h$ and update $\mathcal { D }  \mathcal { D } \times h$ . Overall, IP-IRM converges as $\mathcal { G } / \mathcal { D } _ { \mathrm { a u g } }$ is finite. Note that an improved contrastive objective [92] can further disentangle each $d \in \mathcal { D } _ { \mathrm { a u g } }$ and achieve full disentanglement w.r.t. $\mathcal { G }$ .
+
+# 5 Experiments
+
+# 5.1 Unsupervised Disentanglement
+
+Datasets. We used two datasets. CMNIST [2] has 60,000 digit images with semantic labels of digits (0-9) and colors (red and green). These images differ in other semantics (e.g., slant and font) that are not labeled. Moreover, there is a strong correlation between digits and colors (most 0-4 in red and 5-9 in green), increasing the difficulty to disentangle them. Shapes3D [50] contains 480,000 images with 6 labelled semantics, i.e., size, type, azimuth, as well as floor, wall and object color. Note that we only considered the first three semantics for evaluation, as the standard augmentations in SSL will contaminate any color-related semantics.
+
+Settings. We adopted 6 representative disentanglement metrics: Disentangle Metric for Informativeness (DCI) [29], Interventional Robustness Score (IRS) [79], Explicitness Score (EXP) [72], Modularity Score (MOD) [72] and the accuracy of predicting the ground-truth semantic labels by two classification models called logistic regression (LR) and gradient boosted trees (GBT) [59]. Specifically, DCI and EXP measure the explicitness, i.e., the values of semantics can be decoded from the feature using a linear transformation. MOD and IRS measure the modularity, i.e., whether each feature dimension is equivariant to the shift of a single semantic. See Appendix for more detailed formula of the metrics. In evaluation, we trained CNN-based feature extractor backbones with comparable number of parameters for all the baselines and our IP-IRM. The full implementation details are in Appendix.
+
+Results. In Table 1, we compared the proposed IP-IRM to the standard SSL method SimCLR [16] as well as several generative disentanglement methods [51, 41, 9, 15, 50]. On both CMNIST and Shapes3D dataset, IP-IRM outperforms SimCLR regarding all metrics except for only IRS where the most relative gain is $8 . 8 \%$ for MOD. For this MOD, we notice that VAE performs better than our IP-IRM by 6 points, i.e., 0.82 v.s. 0.76 for Shapes3D. This is because VAE explicitly pursues a high modularity score through regularizing the dimension-wise independence in the feature space. However, this regularization is adversarial to discriminative objectives [14, 95]. Indeed, we can observe from the column of LR (i.e., the performance of downstream linear classification) that VAE methods have clearly poor performance especially on the more challenging dataset Shapes3D. We can draw the same conclusion from the results of GBT. Different from VAE methods, our IP-IRM is optimized towards disentanglement without such regularization, and is thus able to outperform the others in downstream tasks while obtaining a competitive value of modularity.
+
+![](images/11e807af754b56194a9890b41a2dbfb4addeb68432a0df0c278db14b1c249deb.jpg)  
+Figure 4: The t-SNE [85] visualizations of learned feature spaces using SimCLR [16] and IP-IRM on CMNIST [2] and STL10 [22]. For CMIST in (a), we annotate the digit and color near each cluster. We annotate only half of the feature points for SimCLR to avoid clutter. For STL10 in (b), we show the labels of the classes.
+
+![](images/ce626ce68e1a74ae33af9d91aa5685f2eae5fa3170328612135c6263e8433b26.jpg)  
+Figure 5: (a) Visualization of the obtained partitions $\mathbf { P } ^ { * }$ during training. Each partition has two subset and the displayed images are randomly sampled from each subset. (b) Visualization of the variance of each feature dimension when perturbing the semantic indicated on the left. The most equivariant dimensions are indicated by triangles and their corresponding indices.
+
+What do IP-IRM features look like? Figure 4 visualizes the features learned by SimCLR and our IP-IRM on two datasets: CMNIST in Figure 4 (a) and STL10 dataset in Figure 4 (b). In the following, we use Figure 4 (a) as the example, and can easily draw the similar conclusions from Figure 4 (b). On the left-hand side of Figure 4 (a), it is obvious that there is no clear boundary to distinguish the semantic of color in the SimCLR feature space. Besides, the features of the same digit semantic are scattered in two regions. On the right-hand side of (a), we have 3 observations for IP-IRM. 1) The features are well clustered and each cluster corresponds to a specific semantic of either digit or color. This validates the equivariant property of IP-IRM representation that it responds to any changes of the existing semantics, e.g., digit and color on this dataset. 2) The feature space has the symmetrical structure for each individual semantic, validating the decomposable property of IP-IRM representation. More specifically, i) mirroring a feature (w.r.t. “\*” in the figure center) indicates the change on the only semantic of color, regardless of the other semantic (digit); and ii) a counterclockwise rotation (denoted by black arrows from same-colored 1 to 7) indicates the change on the only semantic of digit. 3) IP-IRM reveals the true distribution (similarity) of different classes. For example, digits 3, 5, 8 sharing sub-parts (curved bottoms and turnings) have closer feature points in the IP-IRM feature space.
+
+How does IP-IRM disentangle features? 1) Discovered $\mathbf { P } ^ { * }$ : To visualize the discovered partitions $\mathbf { P } ^ { * }$ at each maximization step, we performed an experiment on a binary CMNIST (digit 0 and 1 in color red and green), and show the results in Figure 5 (a). Please kindly refer to Appendix for the full results on CMNIST. First, each partition tells apart a specific semantic into two subsets, e.g., in Partition #1, red and green digits are separated. Second, besides the obvious semantics—digit and color (labelled on the dataset), we can discover new semantics, e.g., the digit slant shown in Partition #3. 2) Disentangled Representation: In Figure 5 (b), we aim to visualize how equivariant each feature dimension is to the change of each semantic, i.e., a darker color shows that a dimension is more equivariant w.r.t. the semantic indicated on the left. We can see that SimCLR fails to learn the decomposable representation, e.g., the 8-th dimension captures azimuth, type and size in Shapes3D. In contrast, our IP-IRM achieves disentanglement by representing the semantics into interpretable dimensions, e.g., the 6-th and 7-th dimensions captures the size, the 4-th for type and the 2-nd and 9-th for azimuth on the Shapes3D. Overall, the results support the justification in Section 4, i.e., we discover a new semantic (affected by $h$ ) through the partition $\mathbf { P } ^ { * }$ at each iteration and IP-IRM eventually converges with a disentangled representation.
+
+# 5.2 Self-Supervised Learning
+
+Datasets and Settings. We conducted the SSL evaluations on 2 standard benchmarks following [88, 20, 48]. Cifar100 [54] contains 60,000 images in 100 classes and STL10 [22] has 113,000 images in 10 classes. We used SimCLR [16], DCL [20] and HCL [48] as baselines, and learned the representations for 400 and 1000 epochs. We evaluated both linear and $k$ -NN $k = 2 0 0$ ) accuracies for the downstream classification task. Implementation details are in appendix.
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">STL10</td><td colspan="2">Cifar100</td></tr><tr><td>k-NN</td><td>Linear</td><td>k-NN</td><td>Linear</td></tr><tr><td colspan="5">400 epoch training</td></tr><tr><td>SimCLR[16]</td><td>73.60</td><td>78.89</td><td>54.94</td><td>66.63</td></tr><tr><td>DCL [20]</td><td>78.82</td><td>82.56</td><td>57.29</td><td>68.59</td></tr><tr><td>HCL [48]</td><td>80.06</td><td>87.60</td><td>59.61</td><td>69.22</td></tr><tr><td>SimCLR+IP-IRM</td><td>79.66</td><td>84.44</td><td>59.10</td><td>69.55</td></tr><tr><td>DCL+IP-IRM</td><td>81.51</td><td>85.36</td><td>58.37</td><td>68.76</td></tr><tr><td>HCL+IP-IRM</td><td>84.29</td><td>87.81</td><td>60.05</td><td>69.95</td></tr><tr><td colspan="5">1,000 epoch training</td></tr><tr><td>SimCLR[16]</td><td>78.60</td><td>84.24</td><td>59.45</td><td>68.73</td></tr><tr><td>SimCLR† [55]</td><td>79.80</td><td>85.56</td><td>63.67</td><td>72.18</td></tr><tr><td>SimCLR+IP-IRM</td><td>85.08</td><td>89.91</td><td>65.82</td><td>73.99</td></tr><tr><td>Supervised*</td><td>=</td><td>=</td><td>=</td><td>73.72</td></tr><tr><td>Supervised*+MixUp [97]</td><td></td><td>=</td><td>=</td><td>74.19</td></tr></table>
+
+Table 2: Accuracy $( \% )$ of $k$ -NN and linear classifiers on STL10 [22] and Cifar100 [54] using the representations of SimCLR [16], DCL [20], HCL [48] and those after incorporating our IPIRM. ${ \bf S i m C L R } ^ { \dagger }$ denotes $\mathrm { S i m C L R }$ with MixUp regularization. Supervised∗ represents the supervised learning that keeps the same codebase, optimizer and parameters with SSL stage-2 fine-tuning while only adds the learning rate decay at 60 and 80 epoch.
+
+Results. We demonstrate our results and compare with baselines in Table 2. Incorporating IP-IRM to the 3 baselines brings consistent performance boosts to downstream classification models in all settings, e.g., improving the linear models by $5 . 5 5 \%$ on STL10 and $2 . 9 2 \%$ on Cifar100. In particular, we observe that IP-IRM brings huge performance gain with $k$ -NN classifiers, e.g., $4 . 2 3 \%$ using $\mathrm { H C L + I P }$ -IRM on STL10, i.e., the distance metrics in the IP-IRM feature space more faithfully reflects the class semantic differences. This validates that our algorithm further disentangles compared to the standard SSL Moreover, by extending the training process to 1,000 epochs with MixUp [55], SimCLR+IP-IRM achieves further performance boost on both datasets, e.g., $5 . 2 8 \%$ for $k$ -NN and $4 . 3 5 \%$ for linear classifier over SimCLR baseline on STL10 dataset.
+
+Notably, our SimCLR $^ +$ IP-IRM surpasses vanilla supervised learning on Cifar100 under the same evaluation setting. Still, the quality of disentanglement cannot be fully evaluated when the training and test samples are identically distributed—while the improved accuracy demonstrates that IP-IRM representation is more equivariant to class semantics, it does not reveal if the representation is decomposable. Hence we present an out-of-distribution (OOD) setting in Section 5.3 to further show this property.
+
+Is IP-IRM sensitive to the values of hyper-parameters? 1) $\lambda _ { 1 }$ and $\lambda _ { 2 }$ in $E q$ . (2) and $E q$ . (3). In Figure 6 (a), we observe that the best performance is achieved with $\lambda _ { 1 }$ and $\lambda _ { 2 }$ taking values from 0.2 to 0.5 on both datasets. All accuracies drop sharply if using $\lambda _ { 1 } = 1 . 0$ . The reason is that a higher $\lambda _ { 1 }$ forces the model to push the $\phi$ -induced similarity to fixed baseline $\theta = 1$ , rather than decrease the loss $\mathcal { L }$ on the pretext task, leading to poor convergence. 2) The number of epochs. In Figure 6 (b), we plot the Top-1 accuracies of using $k$ -NN classifiers along the 700-epoch training of two kinds of SSL representations—SimCLR and IP-IRM. It is obvious that IP-IRM converges faster and achieves a higher accuracy than SimCLR. It is worth to highlight that on the STL10, the accuracy of SimCLR starts to oscillate and grow slowly after the 150-th epoch, while ours keeps on improving. This is an empirical evidence that IP-IRM keeps on disentangling more and more semantics in the feature space, and has the potential of improvement through long-term training.
+
+![](images/6e313ee04be31d1bce4e305ed6fc591eaee685e9cc6f43f024de3331551073d3.jpg)  
+Figure 6: Our ablation study on the STL10 and Cifar100 datasets. (a) The Top-1 accuracy $( \% )$ of linear classifiers using different values of $\lambda _ { 1 }$ and $\lambda _ { 2 }$ (in Eq. (2) and Eq. (3)), by training for 200 epochs on two datasets. (b) The Top-1 accuracy $( \% )$ of $k$ -NN classifiers on two datasets, for which we trained the models for 700 epochs and updated $\mathbf { P }$ every 50 epochs.
+
+# 5.3 Potential on Large-Scale Data
+
+Datasets. We evaluated on the standard benchmark of supervised learning ImageNet ILSVRC2012 [25] which has in total 1,331,167 images in 1,000 classes. To further reveal if a representation is decomposable, we used NICO [37], which is a real-world image dataset designed for OOD evaluations. It contains 25,000 images in 19 classes, with a strong correlation between the foreground and background in the train split (e.g., most dogs on grass). We also studied the transferability of the learned representation following [30, 52]: FGVC Aircraft (Aircraft) [60], Caltech-101 (Caltech) [31], Stanford Cars (Cars) [93], Cifar10 [53], Cifar100 [53], DTD [21], Oxford 102 Flowers (Flowers) [62], Food-101 (Food) [6], Oxford-IIIT Pets (Pets) [67] and SUN397 (SUN) [91]. These datasets include coarse- to fine-grained classification tasks, and vary in the amount of training data (2,000-75,000 images) and classes (10-397 classes), representing a wide range of transfer learning settings.
+
+Settings. For the ImageNet, all the representations were trained for 200 epochs due to limited computing resources. We followed the common setting [80, 36], using a linear classifier, and report Top-1 classification accuracies. For NICO, we fixed the ImageNet pre-trained ResNet-50 backbone and fine-tuned the classifier. See appendix for more training details. For the transfer learning, we followed [30, 52] to report the classification accuracies on Cars, Cifar-10, Cifar-100, DTD, Food, SUN and the average per-class accuracies on Aircraft, Caltech, Flowers, Pets. We call them uniformly as Accuracy. We used the few-shot $n$ -way- $k$ -shot setting for model evaluation. Specifically, we randomly sampled 2,000 episodes from the test splits of above datasets. An episode contains $n$ classes, each with $k$ training samples and 15 testing samples, where we fine-tuned the linear classifier (backbone weights frozen) for 100 epochs on the training samples, and evaluated the classifier on the testing samples. We evaluated with $n = k = 5$ (results of $n = 5 , k = 2 0$ in Appendix).
+
+ImageNet and NICO. In Table 3 ImageNet accuracy, our IP-IRM achieves the best performance over all baseline models. Yet we believe that this does not show the full potential of IP-IRM, because ImageNet is a larger-scale dataset with many semantics, and it is hard to achieve a full disentanglement of all semantics within the limited 200 epochs. To evaluate the feature decomposability of IPIRM, we compared the performance on NICO with various SSL baselines in Table 3, where our approach significantly outperforms the baselines by $1 . 5 – 4 . 2 \%$ . This validates IP-IRM feature is more decomposable—if each semantic feature (e.g., background) is decomposed in some fixed dimensions and some classes vary with such semantic, then the classifier will recognize this as a non-discriminative variant feature and hence focus on other more discriminative features (i.e., foreground). In this way, even though some classes are confounded by those non-discriminative features (e.g., most of the “dog” images are with “grass” background), the fixed dimensions still help classifiers neglect those non-discriminative ones. We further visualized the CAM [98] on NICO in Figure 7, which indeed shows that IP-IRM helps the classifier focus on the foreground regions.
+
+Table 3: ImageNet and NICO Top-1 Accuracy $( \% )$ of linear classifiers trained on the representations learnt with different SSL methods.   
+
+<table><tr><td>Method</td><td>ImageNet</td><td>NICO</td></tr><tr><td>InsDis [90]</td><td>56.5</td><td>65.6</td></tr><tr><td>PCL [56]</td><td>61.5</td><td>72.6</td></tr><tr><td>PIRL [61]</td><td>63.6</td><td>69.1</td></tr><tr><td>MoCo-v1 [36]</td><td>60.6</td><td>69.3</td></tr><tr><td>SimCLR (repro.) [16]</td><td>63.1</td><td>64.5</td></tr><tr><td>MoCo-v2 (repro.)[18]</td><td>67.3</td><td>78.0</td></tr><tr><td>SimSiam (repro.) [19]</td><td>68.8</td><td>66.7</td></tr><tr><td>SimCLR+IP-IRM</td><td>64.8</td><td>66.7</td></tr><tr><td>MoCo-v2+IP-IRM</td><td>67.6</td><td>79.5</td></tr><tr><td>SimSiam+IP-IRM</td><td>69.1</td><td></td></tr><tr><td></td><td></td><td>70.9</td></tr></table>
+
+![](images/8cb4b43d8af9d6b806f49d27f5ecdc3ffcfd884dbb5a12581321f78cc008ea4f.jpg)  
+Figure 7: Visualization of CAM [98] on images from NICO [37] dataset using representations of the baseline MoCo-v2 [18] and our IP-IRM.
+
+<table><tr><td>Method</td><td>Aircraft</td><td>Caltech</td><td>Cars</td><td>Cifar10</td><td>Cifar100</td><td>DTD</td><td>Flowers</td><td>Food</td><td>Pets</td><td>SUN</td><td>Average</td></tr><tr><td>InsDis [90]</td><td>35.07</td><td>75.97</td><td>37.49</td><td>51.49</td><td>57.61</td><td>69.38</td><td>77.35</td><td>50.01</td><td>66.38</td><td>74.97</td><td>59.57</td></tr><tr><td>PCL [56]</td><td>36.86</td><td>90.72</td><td>39.68</td><td>59.26</td><td>60.78</td><td>69.53</td><td>67.50</td><td>57.06</td><td>88.31</td><td>84.51</td><td>65.42</td></tr><tr><td>PIRL [61]</td><td>36.70</td><td>78.63</td><td>39.21</td><td>49.85</td><td>55.23</td><td>70.43</td><td>78.37</td><td>51.61</td><td>69.40</td><td>76.64</td><td>60.61</td></tr><tr><td>MoCo-v1 [36]</td><td>35.31</td><td>79.60</td><td>36.35</td><td>46.96</td><td>51.62</td><td>68.76</td><td>75.42</td><td>49.77</td><td>68.32</td><td>74.77</td><td>58.69</td></tr><tr><td>MoCo-v2[18]</td><td>31.98</td><td>92.32</td><td>41.47</td><td>56.50</td><td>63.33</td><td>78.00</td><td>80.05</td><td>57.25</td><td>83.23</td><td>88.10</td><td>67.22</td></tr><tr><td>IP-IRM (Ours)</td><td>32.98</td><td>93.16</td><td> 42.87</td><td>60.73</td><td>68.54</td><td>79.30</td><td>82.68</td><td>59.61</td><td>85.23</td><td>89.38</td><td>69.44</td></tr></table>
+
+Table 4: Accuracy $( \% )$ of 5-way-5-shot few-shot evaluation using the image representation learned on ImageNet [25]. More detailed results are given in Appendix.
+
+Few-Shot Tasks. As shown in Table 4, our IP-IRM significantly improves the performance of 5-way-5-shot setting, e.g., we outperform the baseline MoCo-v2 by $2 . 2 \%$ . This is because IP-IRM can further disentangled $\mathcal { G } \backslash \mathcal { D } _ { \mathrm { a u g } }$ over SSL, which is essential for representations to generalize to different downstream class domains (recall Corollary 2 of Lemma 1). This is also in line with recent works [86] showing that a disentangled representation is especially beneficial in low-shot scenarios, and further demonstrates the importance of disentanglement in downstream tasks.
+
+# 6 Conclusion
+
+We presented an unsupervised disentangled representation learning method called Iterative Partitionbased Invariant Risk Minimization (IP-IRM), based on Self-Supervised Learning (SSL). IP-IRM iteratively partitions the dataset into semantic-related subsets, and learns a representation invariant across the subsets using SSL with an IRM loss. We show that with theoretical guarantee, IP-IRM converges with a disentangled representation under the group-theoretical view, which fundamentally surpasses the capabilities of existing SSL and fully-supervised learning. Our proposed theory is backed by strong empirical results in disentanglement metrics, SSL classification accuracy and transfer performance. IP-IRM achieves disentanglement without using generative models, making it widely applicable on large-scale visual tasks. As future directions, we will continue to explore the application of group theory in representation learning and seek additional forms of inductive bias for faster convergence.
+
+# Acknowledgments and Disclosure of Funding
+
+The authors would like to thank all reviewers for their constructive suggestions. This research is partly supported by the Alibaba-NTU Joint Research Institute, the A\*STAR under its AME YIRG Grant (Project No. A20E6c0101), and the Singapore Ministry of Education (MOE) Academic Research Fund (AcRF) Tier 2 grant.
+
+References [1] Philip W Anderson. More is different. Science, 1972. [2] Martin Arjovsky, Léon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization. arXiv preprint arXiv:1907.02893, 2019. [3] Philip Bachman, R Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. arXiv preprint arXiv:1906.00910, 2019. [4] Yoshua Bengio. Learning deep architectures for AI. Now Publishers Inc, 2009. [5] Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. IEEE transactions on pattern analysis and machine intelligence, 35(8):1798–1828, 2013. [6] Lukas Bossard, Matthieu Guillaumin, and Luc Van Gool. Food-101–mining discriminative components with random forests. In European conference on computer vision, 2014. [7] Jane Bromley, Isabelle Guyon, Yann LeCun, Eduard Säckinger, and Roopak Shah. Signature verification using a" siamese" time delay neural network. Advances in neural information processing systems, 6:737–744, 1993. [8] Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel Ziegler, Jeffrey Wu, Clemens Winter, Chris Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. In Advances in Neural Information Processing Systems, 2020. [9] Christopher P Burgess, Irina Higgins, Arka Pal, Loic Matthey, Nick Watters, Guillaume Desjardins, and Alexander Lerchner. Understanding disentangling in $\beta$ -vae. arXiv preprint arXiv:1804.03599, 2018.   
+[10] Ruichu Cai, Zijian Li, Pengfei Wei, Jie Qiao, Kun Zhang, and Zhifeng Hao. Learning disentangled semantic representation for domain adaptation. In IJCAI: proceedings of the conference, 2019.   
+[11] Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. In Proceedings of the European Conference on Computer Vision (ECCV), pages 132–149, 2018.   
+[12] Mathilde Caron, Piotr Bojanowski, Julien Mairal, and Armand Joulin. Unsupervised pretraining of image features on non-curated data. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 2959–2968, 2019.   
+[13] Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. arXiv preprint arXiv:2006.09882, 2020.   
+[14] Long Chen, Hanwang Zhang, Jun Xiao, Wei Liu, and Shih-Fu Chang. Zero-shot visual recognition using semantics-preserving adversarial embedding networks. In CVPR, 2018.   
+[15] Ricky TQ Chen, Xuechen Li, Roger Grosse, and David Duvenaud. Isolating sources of disentanglement in variational autoencoders. In Advances in neural information processing systems, 2018.   
+[16] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In International conference on machine learning, pages 1597–1607. PMLR, 2020.   
+[17] Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. In Advances in neural information processing systems, 2016.   
+[18] Xinlei Chen, Haoqi Fan, Ross Girshick, and Kaiming He. Improved baselines with momentum contrastive learning. arXiv preprint arXiv:2003.04297, 2020.   
+[19] Xinlei Chen and Kaiming He. Exploring simple siamese representation learning. arXiv preprint arXiv:2011.10566, 2020.   
+[20] Ching-Yao Chuang, Joshua Robinson, Lin Yen-Chen, Antonio Torralba, and Stefanie Jegelka. Debiased contrastive learning. arXiv preprint arXiv:2007.00224, 2020.   
+[21] Mircea Cimpoi, Subhransu Maji, Iasonas Kokkinos, Sammy Mohamed, and Andrea Vedaldi. Describing textures in the wild. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2014.   
+[22] Adam Coates, Andrew $\mathrm { N g }$ , and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pages 215–223. JMLR Workshop and Conference Proceedings, 2011.   
+[23] Taco Cohen and Max Welling. Learning the irreducible representations of commutative lie groups. In International Conference on Machine Learning, 2014.   
+[24] Taco S Cohen, Mario Geiger, Jonas Köhler, and Max Welling. Spherical cnns. In ICLR, 2018.   
+[25] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A largescale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pages 248–255. Ieee, 2009.   
+[26] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), 2019.   
+[27] Kien Do and Truyen Tran. Theory and evaluation metrics for learning disentangled representations. In International conference on learning representations, 2020.   
+[28] Carl Doersch, Abhinav Gupta, and Alexei A Efros. Unsupervised visual representation learning by context prediction. In Proceedings of the IEEE international conference on computer vision, pages 1422–1430, 2015.   
+[29] Cian Eastwood and Christopher KI Williams. A framework for the quantitative evaluation of disentangled representations. In International conference on learning representations, 2018.   
+[30] Linus Ericsson, Henry Gouk, and Timothy M. Hospedales. How Well Do Self-Supervised Models Transfer? In CVPR, 2021.   
+[31] Li Fei-Fei, Rob Fergus, and Pietro Perona. Learning generative visual models from few training examples: An incremental bayesian approach tested on 101 object categories. In 2004 conference on computer vision and pattern recognition workshop, 2004.   
+[32] Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, François Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. The Journal of Machine Learning Research, 2016.   
+[33] Spyros Gidaris, Praveer Singh, and Nikos Komodakis. Unsupervised representation learning by predicting image rotations. arXiv preprint arXiv:1803.07728, 2018.   
+[34] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020.   
+[35] W.F.J. Harris, W. Fulton, and J. Harris. Representation Theory: A First Course. 1991.   
+[36] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. arXiv preprint arXiv:1911.05722, 2019.
+
+[37] Yue He, Zheyan Shen, and Peng Cui. Towards non-iid image classification: A dataset and baselines. Pattern Recognition, 110:107383, 2021.
+
+[38] Olivier Henaff. Data-efficient image recognition with contrastive predictive coding. In International Conference on Machine Learning, pages 4182–4192. PMLR, 2020.
+
+[39] I. Higgins, Loïc Matthey, A. Pal, C. Burgess, Xavier Glorot, M. Botvinick, S. Mohamed, and Alexander Lerchner. beta-vae: Learning basic visual concepts with a constrained variational framework. In ICLR, 2017.
+
+[40] Irina Higgins, David Amos, David Pfau, Sebastien Racaniere, Loic Matthey, Danilo Rezende, and Alexander Lerchner. Towards a definition of disentangled representations. arXiv preprint arXiv:1812.02230, 2018.
+
+[41] Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-vae: Learning basic visual concepts with a constrained variational framework. International conference on learning representations, 2017.
+
+[42] R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Phil Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. arXiv preprint arXiv:1808.06670, 2018.
+
+[43] Jun-Ting Hsieh, Bingbin Liu, De-An Huang, Li Fei-Fei, and Juan Carlos Niebles. Learning to decompose and disentangle representations for video prediction. In Advances in neural information processing systems, 2018.
+
+[44] Qianjiang Hu, Xiao Wang, Wei Hu, and Guo-Jun Qi. Adco: Adversarial contrast for efficient learning of unsupervised representations from self-trained negative adversaries. arXiv preprint arXiv:2011.08435, 2020.
+
+[45] Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Logan Engstrom, Brandon Tran, and Aleksander Madry. Adversarial examples are not bugs, they are features. In Advances in Neural Information Processing Systems, 2019.
+
+[46] Andrew Jaegle, Stephen Phillips, Daphne Ippolito, and Kostas Daniilidis. Understanding image motion with group representations. 2018.
+
+[47] Thomas W. Judson. Abstract Algebra: Theory and Applications (The Prindle, Weber & Schmidt Series in Advanced Mathematics). Prindle Weber & Schmidt, 1994.
+
+[48] Yannis Kalantidis, Mert Bulent Sariyildiz, Noe Pion, Philippe Weinzaepfel, and Diane Larlus. Hard negative mixing for contrastive learning. arXiv preprint arXiv:2010.01028, 2020.
+
+[49] Theofanis Karaletsos, Serge Belongie, and Gunnar Rätsch. Bayesian representation learning with oracle constraints. International conference on learning representations, 2015.
+
+[50] Hyunjik Kim and Andriy Mnih. Disentangling by factorising. In International Conference on Machine Learning, 2018.
+
+[51] Diederik Kingma and Max Welling. Auto-encoding variational bayes. In ICLR, 2014.
+
+[52] Simon Kornblith, Jonathon Shlens, and Quoc V Le. Do better imagenet models transfer better? In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2019.
+
+[53] Alex Krizhevsky. Learning multiple layers of features from tiny images. 2012.
+
+[54] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.
+
+[55] Kibok Lee, Yian Zhu, Kihyuk Sohn, Chun-Liang Li, Jinwoo Shin, and Honglak Lee. i-mix: A domain-agnostic strategy for contrastive representation learning. In ICLR, 2021.
+
+[56] Junnan Li, Pan Zhou, Caiming Xiong, Richard Socher, and Steven CH Hoi. Prototypical contrastive learning of unsupervised representations. arXiv preprint arXiv:2005.04966, 2020.   
+[57] Zinan Lin, Kiran Thekumparampil, Giulia Fanti, and Sewoong Oh. Infogan-cr and modelcentrality: Self-supervised model training and selection for disentangling gans. In International Conference on Machine Learning, 2020.   
+[58] F. Locatello, M. Tschannen, S. Bauer, G. Rätsch, B. Schölkopf, and O. Bachem. Disentangling factors of variations using few labels. In 8th International Conference on Learning Representations (ICLR), 2020.   
+[59] Francesco Locatello, Stefan Bauer, Mario Lucic, Gunnar Raetsch, Sylvain Gelly, Bernhard Schölkopf, and Olivier Bachem. Challenging common assumptions in the unsupervised learning of disentangled representations. In international conference on machine learning, 2019.   
+[60] Subhransu Maji, Esa Rahtu, Juho Kannala, Matthew Blaschko, and Andrea Vedaldi. Finegrained visual classification of aircraft. arXiv preprint arXiv:1306.5151, 2013.   
+[61] Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 6707–6717, 2020.   
+[62] Maria-Elena Nilsback and Andrew Zisserman. Automated flower classification over a large number of classes. In 2008 Sixth Indian Conference on Computer Vision, Graphics & Image Processing, 2008.   
+[63] Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In European conference on computer vision, pages 69–84. Springer, 2016.   
+[64] Utkarsh Ojha, Krishna Kumar Singh, Cho-Jui Hsieh, and Yong Jae Lee. Elastic-infogan: Unsupervised disentangled representation learning in class-imbalanced data. In Advances in neural information processing systems, 2020.   
+[65] Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.   
+[66] Giambattista Parascandolo, Niki Kilbertus, Mateo Rojas-Carulla, and Bernhard Schölkopf. Learning independent causal mechanisms. In Proceedings of the 35th International Conference on Machine Learning, pages 4036–4044, 2018.   
+[67] Omkar M Parkhi, Andrea Vedaldi, Andrew Zisserman, and CV Jawahar. Cats and dogs. In 2012 IEEE conference on computer vision and pattern recognition, 2012.   
+[68] Robin Quessard, Thomas Barrett, and William Clements. Learning disentangled representations and group structure of dynamical environments. Advances in Neural Information Processing Systems, 2020.   
+[69] Rajesh PN Rao and Daniel L Ruderman. Learning lie groups for invariant visual perception. Advances in neural information processing systems, 1999.   
+[70] Scott Reed, Kihyuk Sohn, Yuting Zhang, and Honglak Lee. Learning to disentangle factors of variation with manifold interaction. In International conference on machine learning, 2014.   
+[71] Xuanchi Ren, Tao Yang, Yuwang Wang, and Wenjun Zeng. Do generative models know disentanglement? contrastive learning is all you need. arXiv preprint arXiv:2102.10543, 2021.   
+[72] Karl Ridgeway and Michael C Mozer. Learning deep disentangled embeddings with the f-statistic loss. In Advances in neural information processing systems, 2018.   
+[73] Joshua Robinson, Ching-Yao Chuang, Suvrit Sra, and Stefanie Jegelka. Contrastive learning with hard negative samples. arXiv preprint arXiv:2010.04592, 2020.   
+[74] Bernhard Schölkopf, Dominik Janzing, Jonas Peters, Eleni Sgouritsa, Kun Zhang, and Joris Mooij. On causal and anticausal learning. In Proceedings of the 29th International Conference on Machine Learning, 2012.   
+[75] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In 3rd International Conference on Learning Representations, 2015.   
+[76] Ivan Sosnovik, Michał Szmaja, and Arnold Smeulders. Scale-equivariant steerable networks. 2020.   
+[77] Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014.   
+[78] Raphael Suter, Djordje Miladinovic, Stefan Bauer, and Bernhard Schölkopf. Interventional robustness of deep latent variable models. arXiv, 2018.   
+[79] Raphael Suter, Djordje Miladinovic, Bernhard Schölkopf, and Stefan Bauer. Robustly disentangled causal mechanisms: Validating deep representations for interventional robustness. In International Conference on Machine Learning, 2019.   
+[80] Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019.   
+[81] Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. In Andrea Vedaldi, Horst Bischof, Thomas Brox, and Jan-Michael Frahm, editors, European conference on computer vision, 2020.   
+[82] Yonglong Tian, Chen Sun, Ben Poole, Dilip Krishnan, Cordelia Schmid, and Phillip Isola. What makes for good views for contrastive learning. arXiv preprint arXiv:2005.10243, 2020.   
+[83] Yuandong Tian, Xinlei Chen, and Surya Ganguli. Understanding self-supervised learning dynamics without contrastive pairs. arXiv preprint arXiv:2102.06810, 2021.   
+[84] Luan Tran, Xi Yin, and Xiaoming Liu. Disentangled representation learning gan for poseinvariant face recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017.   
+[85] Laurens Van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of machine learning research, 9(11), 2008.   
+[86] Sjoerd Van Steenkiste, Francesco Locatello, Jürgen Schmidhuber, and Olivier Bachem. Are disentangled representations helpful for abstract visual reasoning? In Advances in neural information processing systems, 2019.   
+[87] Tan Wang, Chang Zhou, Qianru Sun, and Hanwang Zhang. Causal attention for unbiased visual recognition. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2021.   
+[88] Xudong Wang, Ziwei Liu, and Stella X Yu. Unsupervised feature learning by cross-level discrimination between instances and groups. arXiv preprint arXiv:2008.03813, 2020.   
+[89] Daniel E Worrall and Max Welling. Deep scale-spaces: Equivariance over scale. In NeurIPS, 2019.   
+[90] Zhirong Wu, Yuanjun Xiong, Stella X Yu, and Dahua Lin. Unsupervised feature learning via non-parametric instance discrimination. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3733–3742, 2018.   
+[91] Jianxiong Xiao, James Hays, Krista A Ehinger, Aude Oliva, and Antonio Torralba. Sun database: Large-scale scene recognition from abbey to zoo. In 2010 IEEE computer society conference on computer vision and pattern recognition, 2010.   
+[92] Tete Xiao, Xiaolong Wang, Alexei A Efros, and Trevor Darrell. What should not be contrastive in contrastive learning. In International Conference on Learning Representations, 2021.   
+[93] Linjie Yang, Ping Luo, Chen Change Loy, and Xiaoou Tang. A large-scale car dataset for fine-grained categorization and verification. In 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2015.   
+[94] Mang Ye, Xu Zhang, Pong C Yuen, and Shih-Fu Chang. Unsupervised embedding learning via invariant and spreading instance feature. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 6210–6219, 2019.   
+[95] Zhongqi Yue, Tan Wang, Hanwang Zhang, Qianru Sun, and Xian-Sheng Hua. Counterfactual zero-shot and open-set visual recognition. In CVPR, 2021.   
+[96] Zhongqi Yue, Hanwang Zhang, Qianru Sun, and Xian-Sheng Hua. Interventional few-shot learning. In NeurIPS, 2020.   
+[97] Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In ICLR, 2018.   
+[98] Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2921–2929, 2016.   
+[99] Yizhe Zhu, Martin Renqiang Min, Asim Kadav, and Hans Peter Graf. S3vae: Self-supervised sequential vae for representation disentanglement and data generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2020.   
+[100] Zhenyao Zhu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Multi-view perceptron: a deep model for learning face identity and view representations. Advances in Neural Information Processing Systems 27 (NIPS 2014), 2014.

parse/train/RQfcckT1M_4/RQfcckT1M_4_content_list.json

@@ -0,0 +1,1255 @@
+[
+    {
+        "type": "text",
+        "text": "Self-Supervised Learning Disentangled Group Representation as Feature ",
+        "text_level": 1,
+        "bbox": [
+            222,
+            122,
+            777,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tan Wang1 Zhongqi Yue1,3 Jianqiang Huang1,3 Qianru Sun2 Hanwang Zhang1 1Nanyang Technological University 2Singapore Management University 3Damo Academy, Alibaba Group {tan317,yuez0003,hanwangzhang}@ntu.edu.sg jianqiang.jqh@gmail.com qianrusun@smu.edu.sg ",
+        "bbox": [
+            183,
+            224,
+            836,
+            282
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A good visual representation is an inference map from observations (images) to features (vectors) that faithfully reflects the hidden modularized generative factors (semantics). In this paper, we formulate the notion of “good” representation from a group-theoretic view using Higgins’ definition of disentangled representation [40], and show that existing Self-Supervised Learning (SSL) only disentangles simple augmentation features such as rotation and colorization, thus unable to modularize the remaining semantics. To break the limitation, we propose an iterative SSL algorithm: Iterative Partition-based Invariant Risk Minimization (IP-IRM), which successfully grounds the abstract semantics and the group acting on them into concrete contrastive learning. At each iteration, IP-IRM first partitions the training samples into two subsets that correspond to an entangled group element. Then, it minimizes a subset-invariant contrastive loss, where the invariance guarantees to disentangle the group element. We prove that IP-IRM converges to a fully disentangled representation and show its effectiveness on various benchmarks. Codes are available at https://github.com/Wangt-CN/IP-IRM. ",
+        "bbox": [
+            232,
+            349,
+            766,
+            558
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            584,
+            310,
+            602
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning is all about learning feature representations [5]. Compared to the conventional end-to-end supervised learning, Self-Supervised Learning (SSL) first learns a generic feature representation (e.g., a network backbone) by training with unsupervised pretext tasks such as the prevailing contrastive objective [36, 16], and then the above stage-1 feature is expected to serve various stage-2 applications with proper fine-tuning. SSL for visual representation is so fascinating that it is the first time that we can obtain “good” visual features for free, just like the trending pre-training in NLP community [26, 8]. However, most SSL works only care how much stage-2 performance an SSL feature can improve, but overlook what feature SSL is learning, why it can be learned, what cannot be learned, what the gap between SSL and Supervised Learning (SL) is, and when SSL can surpass SL? ",
+        "bbox": [
+            174,
+            617,
+            550,
+            837
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c09c68e3a9b29274dd39164ae5dd8d3b9b29d4f593e95a2d4e980e72cba9449f.jpg",
+        "image_caption": [
+            "Figure 1: Disentangled representation is an equivariant map between the semantic space $\\mathcal { U }$ and the vector space $\\mathcal { X }$ , which is decomposed into “color” and “digit”. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            576,
+            606,
+            807,
+            784
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The crux of answering those questions is to formally understand what a feature representation is and what a good one is. We postulate the classic world model of visual generation and feature representation [1, 69] as in Figure 1. Let $\\mathcal { U }$ be a set of (unseen) semantics, e.g., attributes such as “digit” and “color”. There is a set of independent and causal mechanisms [66] $\\varphi : \\mathcal { U } \\to \\mathcal { T }$ , generating images from semantics, e.g., writing a digit $ { { } ^ { 6 } } 0 ^ { 9 }$ when thinking of $\\mathbf { \\vec { \\nabla } } _ { 0 } , \\mathbf { \\vec { \\mathbf { \\phi } } } _ { }$ [74]. A visual representation is the inference process $\\phi : \\mathcal { T }  \\mathcal { X }$ that maps image pixels to vector space features, e.g., a neural network. We define semantic representation as the functional composition $f : \\mathcal { U } \\to \\mathcal { T } \\to \\mathcal { X }$ . In this paper, we are only interested in the parameterization of the inference process for feature extraction, but not the generation process, i.e., we assume $\\forall I \\in \\mathcal { T }$ , $\\exists u \\in \\mathcal { U }$ , such that $I = \\varphi ( u )$ is fixed as the observation of each image sample. Therefore, we consider semantic and visual representations the same as feature representation, or simply representation, and we slightly abuse ${ \\dot { \\phi } } ( I ) : = f \\left( \\varphi ^ { - 1 } ( I ) \\right)$ , i.e., $\\phi$ and $f$ share the same trainable parameters. We call the vector $\\mathbf { x } = \\phi ( I )$ as feature, where $\\mathbf { x } \\in \\mathcal { X }$ . ",
+        "bbox": [
+            174,
+            844,
+            550,
+            872
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            872,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/ebfb7e755e05b382aa1a1291d0d35552c8ff9d1adc92bfba383d35ddeea7ad26.jpg",
+        "image_caption": [
+            "Figure 2: (a) The heat map visualizes feature dimensions related to augmentations (aug. related) and unrelated to augmentations (aug. unrelated), whose respective classification accuracy is shown in the bar chart below. Dashed bar denotes the accuracy using full feature dimensions. Experiment was performed on STL10 [22] with representation learnt with SimCLR [16] and our IP-IRM. (b) Visualization of CNN activations [77] of 4 filters on layer 29 and 18 of VGG [75] trained on ImageNet100 [81]. The filters were chosen by first clustering the aug. unrelated filters with $k$ -means $k = 4$ ) and then selecting the filters corresponding to the cluster centers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            89,
+            815,
+            250
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            345,
+            825,
+            472
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose to use Higgins’ definition of disentangled representation [40] to define what is “good”. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            478,
+            823,
+            493
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Definition 1. (Disentangled Representation) Let $\\mathcal { G }$ be the group acting on $\\mathcal { U }$ , i.e., $g \\cdot u \\in \\mathcal { U } \\times \\mathcal { U }$ transforms $u \\in \\mathcal { U }$ , e.g., a “turn green” group element changing the semantic from “red” to “green”. Suppose there is a direct product decomposition1 $\\mathcal { G } = g _ { 1 } \\times . . . \\times g _ { m }$ and ${ \\mathcal { U } } = { \\mathcal { U } } _ { 1 } \\times \\ldots \\times { \\mathcal { U } } _ { m }$ , where $g _ { i }$ acts on $\\mathcal { U } _ { i }$ respectively. A feature representation is disentangled if there exists a group $\\mathcal { G }$ acting on $\\mathcal { X }$ such that: ",
+        "bbox": [
+            174,
+            498,
+            826,
+            568
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. Equivariant: $\\forall g \\in \\mathcal { G } , \\forall u \\in \\mathcal { U }$ , $f ( g \\cdot u ) = g \\cdot f ( u )$ , e.g., the feature of the changed semantic: “red” to “green” in $\\mathcal { U }$ , is equivalent to directly change the color vector in $\\mathcal { X }$ from “red” to “green”.   \n2. Decomposable: there is a decomposition ${ \\mathcal { X } } = { \\mathcal { X } } _ { 1 } \\times \\ldots \\times { \\mathcal { X } } _ { m } ,$ , such that each $\\mathcal { X } _ { i }$ is fixed by the action of all $g _ { j } , j \\neq i$ and affected only by $g _ { i }$ , e.g., changing the “color” semantic in $\\mathcal { U }$ does not affect the “digit” vector in $\\mathcal { X }$ . ",
+        "bbox": [
+            176,
+            579,
+            826,
+            655
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Compared to the previous definition of feature representation which is a static mapping, the disentangled representation in Definition 1 is dynamic as it explicitly incorporate group representation [35], which is a homomorphism from group to group actions on a space, e.g., $\\mathcal { G }  \\mathcal { X } \\times \\mathcal { X }$ , and it is common to use the feature space $\\mathcal { X }$ as a shorthand—this is where our title stands. ",
+        "bbox": [
+            173,
+            666,
+            826,
+            722
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 defines “good” features in the common views: 1) Robustness: a good feature should be invariant to the change of environmental semantics, such as external interventions [45, 87] or domain shifts [32]. By the above definition, a change is always retained in a subspace $\\mathcal { X } _ { i }$ , while others are not affected. Hence, the subsequent classifier will focus on the invariant features and ignore the ever-changing $\\mathcal { X } _ { i }$ . 2) Zero-shot Generalization: even if a new combination of semantics is unseen in training, each semantic has been learned as features. So, the metrics of each $\\mathcal { X } _ { i }$ trained by seen samples remain valid for unseen samples [95]. ",
+        "bbox": [
+            173,
+            728,
+            825,
+            825
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Are the existing SSL methods learning disentangled representations? No. We show in Section 4 that they can only disentangle representations according to the hand-crafted augmentations, e.g., color jitter and rotation. For example, in Figure 2 (a), even if we only use the augmentation-related feature, the classification accuracy of a standard SSL (SimCLR [16]) does not lose much as compared to the full feature use. Figure 2 (b) visualizes that the CNN features in each layer are indeed entangled (e.g., tyre, motor, and background in the motorcycle image). In contrast, our approach IP-IRM, to be introduced below, disentangles more useful features beyond augmentations. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose Iterative Partition-based Invariant Risk Minimization (IP-IRM [­ai\"p@:m]) that guarantees to learn disentangled representations in an SSL fashion. We present the algorithm in Section 3, followed by the theoretical justifications in Section 4. In a nutshell, at each iteration, IP-IRM first partitions the training data into two disjoint subsets, each of which is an orbit of the already disentangled group, and the cross-orbit group corresponds to an entangled group element $g _ { i }$ Then, we adopt the Invariant Risk Minimization (IRM) [2] to implement a partition-based SSL, which disentangles the representation $\\mathcal { X } _ { i }$ w.r.t. $g _ { i }$ . Iterating the above two steps eventually converges to a fully disentangled representation w.r.t. $\\textstyle \\prod _ { i = 1 } ^ { m } g _ { i }$ . In Section 5, we show promising experimental results on various feature disentanglement and SSL benchmarks. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            279
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            299,
+            321,
+            315
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Self-Supervised Learning. SSL aims to learn representations from unlabeled data with hand-crafted pretext tasks [28, 63, 33]. Recently, Contrastive learning [65, 61, 38, 80, 16] prevails in most state-ofthe-art methods. The key is to map positive samples closer, while pushing apart negative ones in the feature space. Specifically, the positive samples are from the augmented views [82, 3, 94, 42] of each instance and the negative ones are other instances. Along this direction, follow-up methods are mainly four-fold: 1) Memory-bank [90, 61, 36, 18]: storing the prototypes of all the instances computed previously into a memory bank to benefit from a large number of negative samples. 2) Using siamese network [7] to avoid representation collapse [34, 19, 83]. 3) Assigning clusters to samples to integrate inter-instance similarity into contrastive learning [11, 12, 13, 88, 56]. 4) Seeking hard negative samples with adversarial training or better sampling strategies [73, 20, 44, 48]. In contrast, our proposed IP-IRM jumps out of the above frame and introduces the disentangled representation into SSL with group theory to show the limitations of existing SSL and how to break through them. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            498
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Disentangled Representation. This notion dates back to [4], and henceforward becomes a highlevel goal of separating the factors of variations in the data [84, 79, 86, 58]. Several works aim to provide a more precise description [27, 29, 72] by adopting an information-theoretic view [17, 27] and measuring the properties of a disentangled representation explicitly [29, 72]. We adopt the recent group-theoretic definition from Higgins et al. [40], which not only unifies the existing, but also resolves the previous controversial points [78, 59]. Although supervised learning of disentangled representation is a well-studied field [100, 43, 10, 70, 49], unsupervised disentanglement based on GAN [17, 64, 57, 71] or VAE [39, 15, 99, 50] is still believed to be theoretically challenging [59]. Thanks to the Higgins’ definition, we prove that the proposed IP-IRM converges with full-semantic disentanglement using group representation theory. Notably, IP-IRM learns a disentangled representation with an inference process, without using generative models as in all the existing unsupervised methods, making IP-IRM applicable even on large-scale datasets. ",
+        "bbox": [
+            173,
+            505,
+            825,
+            670
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Group Representation Learning. A group representation has two elements [47, 35]: 1) a homomorphism (e.g., a mapping function) from the group to its group action acting on a vector space, and 2) the vector space. Usually, when there is no ambiguity, we can use either element as the definition. Most existing works focus on learning the first element. They first define the group of interest, such as spherical rotations [24] or image scaling [89, 76], and then learn the parameters of the group actions [23, 46, 68]. In contrast, we focus on the second element; more specifically, we are interested in learning a map between two vector spaces: image pixel space and feature vector space. Our representation learning is flexible because it delays the group action learning to downstream tasks on demand. For example, in a classification task, a classifier can be seen as a group action that is invariant to class-agnostic groups but equivariant to class-specific groups (see Section 4). ",
+        "bbox": [
+            174,
+            676,
+            826,
+            815
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 IP-IRM Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            835,
+            362,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Notations. Our goal is to learn the feature extractor $\\phi$ in a self-supervised fashion. We define a partition matrix $\\bar { \\mathbf { P } } \\in \\{ 0 , 1 \\} ^ { N \\times 2 }$ that partitions $N$ training images into 2 disjoint subsets. $P _ { i , k } = 1$ if the $i$ -th image belongs to the $k$ -th subset and 0 otherwise. Suppose we have a pretext task loss ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "function $\\mathcal { L } ( \\phi , \\theta = 1 , k , \\mathbf { P } )$ defined on the samples in the $k$ -th subset, where $\\theta = 1$ is a “dummy” parameter used to evaluate the invariance of the SSL loss across the subsets (later discussed in Step 1). For example, $\\mathcal { L }$ can be defined as: ",
+        "bbox": [
+            174,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d750ddea50449b37ec241e8e9128f59c13f99a7b786e766ad4033b0beaf21d25.jpg",
+        "text": "$$\n\\mathcal { L } ( \\phi , \\theta = 1 , k , \\mathbf { P } ) = \\sum _ { \\mathbf { x } \\in \\mathcal { X } _ { k } } - \\log \\frac { \\exp \\left( \\mathbf { x } ^ { T } \\mathbf { x } ^ { * } \\cdot \\theta \\right) } { \\sum _ { \\mathbf { x ^ { \\prime } } \\in \\mathcal { X } _ { k } \\cup \\mathcal { X } ^ { * } \\setminus \\mathbf { x } } \\exp \\left( \\mathbf { x } ^ { T } \\mathbf { x } ^ { \\prime } \\cdot \\theta \\right) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            140,
+            704,
+            183
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { X } _ { k } = \\phi ( \\{ I _ { i } | P _ { i , k } = 1 \\} )$ , and $\\mathbf { x } ^ { * } \\in \\mathcal { X } ^ { * }$ is the augmented view feature of $\\mathbf { x } \\in \\mathcal { X } _ { k }$ . ",
+        "bbox": [
+            173,
+            189,
+            745,
+            205
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input. $N$ training images. Randomly initialized $\\phi$ . A partition matrix $\\mathbf { P }$ initialized such that the first column of $\\mathbf { P }$ is 1, i.e., all samples belong to the first subset. Set $\\mathcal { P } = \\{ \\bf P \\}$ . ",
+        "bbox": [
+            173,
+            210,
+            826,
+            239
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Output. Disentangled feature extractor $\\phi$ . ",
+        "bbox": [
+            173,
+            244,
+            450,
+            260
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Step 1 [Update $\\phi ]$ . We update $\\phi$ by: ",
+        "bbox": [
+            174,
+            265,
+            416,
+            281
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/05d51a0a152a76091413dc80b96dfe0de0b4e698d02e0502f71acca071e58448.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\phi } \\sum _ { \\mathbf { P } \\in \\mathcal { P } } \\sum _ { k = 1 } ^ { 2 } \\left[ \\mathcal { L } ( \\phi , \\theta = 1 , k , \\mathbf { P } ) + \\lambda _ { 1 } \\left. \\nabla _ { \\theta = 1 } \\mathcal { L } ( \\phi , \\theta = 1 , k , \\mathbf { P } ) \\right. ^ { 2 } \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            286,
+            720,
+            332
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { 1 }$ is a hyper-parameter. The second term delineates how far the contrast in one subset is from a constant baseline $\\theta = 1$ . The minimization of both of them encourages $\\phi$ in different subsets close to the same baseline, i.e., invariance across the subsets. See IRM [2] for more details. In particular, the first iteration corresponds to the standard SSL with $\\mathcal { X } _ { 1 }$ in Eq. (1) containing all training images. ",
+        "bbox": [
+            174,
+            338,
+            826,
+            393
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Step 2 [Update P]. We fix $\\phi$ and find a new partition $\\mathbf { P } ^ { * }$ by ",
+        "bbox": [
+            173,
+            398,
+            571,
+            415
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a78482b6f1761b4c88c453c0618065b895adde1b0e84b83b068eb3f1db841223.jpg",
+        "text": "$$\n{ \\bf P } ^ { * } = \\arg \\operatorname* { m a x } _ { { \\bf P } } \\sum _ { { \\bf k } = 1 } ^ { 2 } \\left[ \\mathcal { L } ( \\phi , \\theta = 1 , k , { \\bf P } ) + \\lambda _ { 2 } \\| \\nabla _ { \\theta = 1 } \\mathcal { L } ( \\phi , \\theta = 1 , k , { \\bf P } ) \\| ^ { 2 } \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            421,
+            740,
+            465
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { 2 }$ is a hyper-parameter. In practice, we use a continuous partition matrix in $\\mathbb { R } ^ { N \\times 2 }$ during optimization and then threshold it to $\\{ 0 , 1 \\} ^ { N \\times 2 }$ . ",
+        "bbox": [
+            173,
+            473,
+            825,
+            502
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We update $\\mathcal { P }  \\mathcal { P } \\cup \\mathbf { P ^ { * } }$ and iterate the above two steps until convergence. ",
+        "bbox": [
+            174,
+            507,
+            665,
+            522
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Justification ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            541,
+            308,
+            559
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Recall that IP-IRM uses training sample partitions to learn the disentangled representations w.r.t. $\\textstyle \\prod _ { i = 1 } ^ { m } g _ { i }$ . As we have a $\\mathcal { G }$ -equivariant feature map between the sample space $\\mathcal { T }$ and feature space $\\mathcal { X }$ (the equivariance is later guaranteed by Lemma 1), we slightly abuse the notation by using to denote both spaces. Also, we assume that $\\mathcal { X }$ is a homogeneous space of $\\mathcal { G }$ , i.e., any sample $\\mathbf { x } ^ { \\prime } \\in \\mathcal { X }$ can be transited from another sample $\\mathbf { x }$ by a group action $g \\cdot { \\bf x }$ . Intuitively, $\\mathcal { G }$ is all you need to describe the diversity of the training set. It is worth noting that $g$ is any group element in $\\mathcal { G }$ while $g _ { i }$ is a Cartesian “building block” of $\\mathcal { G }$ , e.g., $g$ can be decomposed by $( g _ { 1 } , g _ { 2 } , . . . , g _ { m } )$ . ",
+        "bbox": [
+            173,
+            573,
+            825,
+            671
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We show that partition and group are tightly connected by the concept of orbit. Given a sample $\\mathbf { x } \\in \\mathcal { X }$ , its group orbit w.r.t. $\\mathcal { G }$ is a sample set $\\mathcal { G } ( \\mathbf { x } ) = \\{ g \\cdot \\mathbf { \\dot { x } } \\mid g \\in \\mathcal { G } \\}$ . As shown in Figure 3 (a), if $\\mathcal { G }$ is a set of attributes shared by classes, e.g., “color” and “pose ”, the orbit is the sample set of the class of $\\mathbf { x }$ ; in Figure 3 (b), if $\\mathcal { G }$ denotes augmentations, the orbit is the set of augmented images. In particular, we can see that the disjoint orbits in Figure 3 naturally form a partition. Formally, we have the following definition: ",
+        "bbox": [
+            173,
+            676,
+            825,
+            761
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 2. (Orbit & Partition [47]) Given a subgroup $\\mathcal { D } \\subset \\mathcal { G }$ , it partitions $\\mathcal { X }$ into the disjoint subsets: $\\{ \\mathcal { D } ( c _ { 1 } \\cdot \\mathbf { x } ) , . . . , D ( c _ { k } \\cdot \\mathbf { x } ) \\}$ , where $k$ is the number of cosets $\\{ c _ { 1 } \\mathcal { D } , . . . , c _ { k } \\mathcal { D } \\}$ , and the cosets form a factor group1 $\\mathcal { G } / \\mathcal { D } = \\{ c _ { i } \\} _ { i = 1 } ^ { k }$ . In particular, $c _ { i } \\cdot \\mathbf { x }$ can be considered as a sample of the i-th class, transited from any sample $\\mathbf { x } \\in \\mathcal { X }$ . ",
+        "bbox": [
+            173,
+            765,
+            825,
+            824
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, the partition offers a new perspective for the training data format in Supervised Learning (SL) and Self-Supervised Learning (SSL). In SL, as shown in Figure 3 (a), the data is labeled with $k$ classes, each of which is an orbit with $\\mathcal { D } ( c _ { i } \\cdot \\mathbf { x } )$ training samples, whose variations are depicted by the class-sharing attribute group $\\mathcal { D }$ . The cross-orbit group action, e.g., $c _ { \\mathrm { d o g } } \\cdot \\mathbf { x }$ , can be read as “turn $\\mathbf { x }$ into a dog” and such “turn” is always valid due to the assumption that $\\mathcal { X }$ is a homogeneous space of $\\mathcal { G }$ . In SSL, as shown in Figure 3 (b), each training sample $\\mathbf { x }$ is augmented by the group $\\mathcal { D }$ . So, $\\mathcal { D } ( c _ { i } \\cdot \\mathbf { x } )$ consists of all the augmentations of the $i$ -th sample, where the cross-orbit group action $c _ { i } \\cdot \\mathbf { x }$ can be read as “turn $\\mathbf { x }$ into the $i$ -th sample”. ",
+        "bbox": [
+            176,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/8042e6e44f14e109a8f8b996514bb1696a28987024774dc510c801d39646ea4f.jpg",
+        "image_caption": [
+            "Figure 3: Each orbit only illustrates with 5 samples. (a) Orbit: the training samples of a class; $\\mathcal { D }$ in-orbit actions: intra-class variations $\\cdot {  } 2$ :standing, $2  3$ :blacken, $3 {  } 4$ :jumping, $4 {  } 5$ :whiten, $5 {  } 1$ :running); $\\mathcal { G } / \\mathcal { D }$ cross-orbit actions: inter-class variations. (b) Orbit: a sample and its augmented samples; $\\mathcal { D }$ in-orbit actions: augmentations $1 \\to 2$ :clock-wise rotation, $2  3$ :color jitter, $3 {  } 4$ :gray scale, $4 {  } 5$ :counterclockwise rotation, $5 {  } 1$ :color); $\\mathcal { G } / \\mathcal { D }$ cross-orbit actions: inter-sample variations. (c) Step 2 in IP-IRM discovers 2 orbits, where the cross-orbit action corresponds to a group action “green to red” or “red to green”, which is yet disentangled. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            88,
+            818,
+            265
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            362,
+            825,
+            433
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thanks to the orbit and partition view of training data, we are ready to revisit model generalization in a group-theoretic view by using invariance and equivariance—the two sides of the coin, whose name is disentanglement. For SL, we expect that a good feature is disentangled into a class-agnostic part and a class-specific part: the former (latter) is invariant (equivariant) to $\\mathcal { G } / \\mathcal { D }$ —cross-orbit traverse, but equivariant (invariant) to $\\mathcal { D }$ —in-orbit traverse. By using such feature, a model can generalize to diverse testing samples (limited to $| \\mathcal D |$ variations) by only keeping the class-specific feature. Formally, we prove that we can achieve such disentanglement by contrastive learning: ",
+        "bbox": [
+            173,
+            438,
+            825,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1. (Disentanglement by Contrastive Learning) Training loss $\\begin{array} { r } { - \\log \\frac { \\exp ( \\mathbf { x } _ { i } ^ { T } \\mathbf { x } _ { j } ) } { \\sum _ { \\mathbf { x } \\in \\mathcal { X } } \\exp ( \\mathbf { x } _ { j } ^ { T } \\mathbf { x } ) } } \\end{array}$ disentangles $\\mathcal { X }$ w.r.t. $( \\mathcal { G } / \\mathcal { D } ) \\times \\mathcal { D }$ , where $\\mathbf { x } _ { i }$ and $\\mathbf { x } _ { j }$ are from the same orbit. ",
+        "bbox": [
+            173,
+            540,
+            823,
+            578
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We can draw the following interesting corollaries from Lemma 1 (details in Appendix): ",
+        "bbox": [
+            169,
+            587,
+            745,
+            602
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1. If we use all the samples in the denominator of the loss, we can approximate to $\\mathcal { G }$ -equivariant features given limited training samples. This is because the loss minimization guarantees $\\forall ( \\mathbf { x } _ { i } , \\mathbf { x } _ { j } ) { \\overset { - } { \\in } } { \\mathcal { X } } \\times { \\mathcal { X } } , i \\neq j  { \\bar { \\mathbf { x } } } _ { i } \\neq { \\bar { \\mathbf { x } _ { j } } }$ , i.e., any pair corresponds to a group action.   \n2. Conventional cross-entropy loss in SL is a special case, if we define $\\mathbf { x } \\in \\mathcal { X } = \\{ \\mathbf { x } _ { 1 } , . . . , \\mathbf { x } _ { k } \\}$ as $k$ classifier weights. So, SL does not guarantee the disentanglement of $\\mathcal { G } / \\mathcal { D }$ , which causes generalization error if the class domain of downstream task is different from SL pre-training, e.g., a subset of $\\mathcal { G } / \\mathcal { D }$ .   \n3. In contrastive learning based SSL, $\\mathcal { D } =$ “augmentations” (recall Figure 2), and the number of augmentations $| \\mathcal { D } _ { \\mathrm { a u g } } |$ is generally much smaller compared to the class-wise sample diversity $| \\mathcal { D } _ { \\mathrm { S L } } |$ in SL. This enables the SL model to generalize to more diverse testing samples $( | \\mathcal { D } _ { \\mathrm { S L } } | )$ by filtering out the class-agnostic features (e.g., background) and focusing on the class-specific ones (e.g., foreground), which explains why SSL is worse than SL in downstream classification.   \n4. In SL, if the number of training samples per orbit is not enough, i.e., smaller than $\\left| \\mathcal { D } ( c _ { i } \\cdot \\mathbf { x } ) \\right|$ , the disentanglement between $\\mathcal { D }$ and $\\mathcal { G } / \\mathcal { D }$ cannot be guaranteed, such as the challenges in few-shot learning [96]. Fortunately, in SSL, the number is enough as we always include all the augmented samples in training. Moreover, we conjecture that $\\mathcal { D } _ { \\mathrm { a u g } }$ only contains simple cyclic group elements such as rotation and colorization, which are easier for representation learning. ",
+        "bbox": [
+            174,
+            609,
+            826,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1 does not guarantee the decomposability of each $d \\in \\mathcal { D }$ . Nonetheless, the downstream model can still generalize by keeping the class-specific features affected by $\\mathcal { G } / \\mathcal { D }$ . Therefore, the key to fill the gap or even let SSL surpass SL is to achieve the full disentanglement of $\\mathcal { G } / \\mathcal { D } _ { \\mathrm { a u g } }$ . ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/57bf6ed7d70a00bfa4de4100932ddb1b0c95dfcd2a9850c8376c775aab93709f.jpg",
+        "table_caption": [
+            "Table 1: Results on disentanglement metrics of existing unsupervised disentanglement methods, standard SSL (SimCLR [16]) and IP-IRM using CMNIST [2] and Shapes3D [50]. Note that IRS is based on intervening the semantics which requires access to the labels of all the semantics, and hence not applicable for CMNIST dataset. Results are averaged over 4 trails (mean $\\pm$ std). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Method</td><td>DCI</td><td>IRS</td><td>MOD</td><td>EXP</td><td>LR</td><td>GBT</td><td>Average</td></tr><tr><td rowspan=\"6\">CSINI</td><td>VAE [51]</td><td>0.948±0.004</td><td>1</td><td>0.664±0.121</td><td>0.968±0.007</td><td>0.824±0.019</td><td>0.948±0.004</td><td>0.849±0.057</td></tr><tr><td>β-VAE [41]</td><td>0.945±0.002</td><td>=</td><td>0.705±0.073</td><td>0.963±0.006</td><td>0.809±0.013</td><td>0.945±0.003</td><td>0.874±0.015</td></tr><tr><td>β-AnnealVAE [9]</td><td>0.911±0.002</td><td></td><td>0.790±0.075</td><td>0.965±0.007</td><td>0.821±0.022</td><td>0.911±0.002</td><td>0.880±0.016</td></tr><tr><td>β-TCVAE[15]</td><td>0.914±0.008</td><td></td><td>0.864±0.095</td><td>0.962±0.010</td><td>0.801±0.024</td><td>0.914±0.008</td><td>0.891±0.014</td></tr><tr><td>Factor-VAE [50]</td><td>0.916±0.004</td><td>=</td><td>0.893±0.056</td><td>0.947±0.011</td><td>0.770±0.025</td><td>0.916±0.005</td><td>0.888±0.014</td></tr><tr><td>SimCLR [16]</td><td>0.882±0.019</td><td></td><td>0.767±0.025</td><td>0.976±0.011</td><td>0.863±0.036</td><td>0.876±0.015</td><td>0.873±0.016</td></tr><tr><td rowspan=\"7\">ssssder</td><td>IP-IRM (Ours)</td><td>0.917±0.008</td><td></td><td>0.785±0.031</td><td>0.990±0.002</td><td>0.921±0.009</td><td>0.916±0.007</td><td>0.906±0.011</td></tr><tr><td>VAE [51]</td><td>0.351±0.026</td><td>0.284±0.009</td><td>0.820±0.015</td><td>0.802±0.054</td><td>0.421±0.079</td><td>0.352±0.027</td><td>0.505±0.028</td></tr><tr><td>β-VAE [41]</td><td>0.369±0.021</td><td>0.283±0.012</td><td>0.782±0.034</td><td>0.807±0.018</td><td>0.427±0.025</td><td>0.368±0.023</td><td>0.506±0.011</td></tr><tr><td>β-AnnealVAE [9]</td><td>0.327±0.069</td><td>0.412±0.049</td><td>0.743±0.070</td><td>0.643±0.013</td><td>0.259±0.021</td><td>0.328±0.070</td><td>0.452±0.023</td></tr><tr><td>β-TCVAE[15]</td><td>0.470±0.035</td><td>0.291±0.023</td><td>0.777±0.031</td><td>0.821±0.054</td><td>0.439±0.084</td><td>0.469±0.034</td><td>0.545±0.032</td></tr><tr><td>Factor-VAE [50]</td><td>0.340±0.021</td><td>0.316±0.016</td><td>0.815±0.041</td><td>0.738±0.043</td><td>0.319±0.045</td><td>0.339±0.021</td><td>0.478±0.020</td></tr><tr><td>SimCLR[16]</td><td>0.535±0.016</td><td>0.439±0.030</td><td>0.678±0.050</td><td>0.949±0.005</td><td>0.733±0.055</td><td>0.536±0.015</td><td>0.645±0.026</td></tr><tr><td></td><td>IP-IRM (Ours)</td><td>0.565±0.023</td><td>0.420±0.014</td><td>0.766±0.036</td><td>0.959±0.007</td><td>0.757±0.025</td><td>0.565±0.023</td><td>0.672±0.017</td></tr></table>",
+        "bbox": [
+            183,
+            89,
+            820,
+            275
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. The representation is fully disentangled w.r.t. $\\mathcal { G } / \\mathcal { D } _ { \\mathrm { a u g } }$ if and only $\\vert f \\forall c _ { i } \\in \\mathcal { G } / \\mathcal { D } _ { \\mathrm { a u g } }$ , the contrastive loss in Eq. (1) is invariant to the 2 orbits of partition $\\{ \\mathcal { G } ^ { \\prime } ( c _ { i } \\cdot \\mathbf { x } ) , \\mathcal { G } ^ { \\prime } ( c _ { i } ^ { - 1 } \\cdot \\mathbf { x } ) \\}$ , where $\\mathcal { G } ^ { \\prime } = \\mathcal { G } / c _ { i } = \\mathcal { D } _ { \\mathrm { a u g } } \\times c _ { 1 } \\times . . . \\times c _ { i - 1 } \\times c _ { i + 1 } \\times . . . \\times c _ { k }$ . ",
+        "bbox": [
+            174,
+            345,
+            825,
+            392
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The maximization in Step 2 is based on the contra-position of the sufficient condition of Theorem 1. Denote the currently disentangled group as $\\mathcal { D }$ (initially $\\mathcal { D } _ { \\mathrm { a u g . } }$ ). If we can find a partition $\\mathbf { P } ^ { * }$ to maximize the loss in Eq. (3), i.e., SSL loss is variant across the orbits, then $\\exists h \\in { \\mathcal { G } } / { \\mathcal { D } }$ such that the representation of $h$ is entangled, i.e., $\\mathbf { P ^ { * } } = \\{ { \\mathcal { D } } ( h \\cdot \\mathbf { x } ) , { \\mathcal { D } } ( h ^ { - 1 } \\cdot \\mathbf { x } ) \\}$ . Figure 3 (c) illustrates a discovered partition about color. The minimization in Step 1 is based on the necessary condition of Theorem 1. Based on the discovered $\\mathbf { P } ^ { * }$ , if we minimize Eq. (2), we can further disentangle $h$ and update $\\mathcal { D }  \\mathcal { D } \\times h$ . Overall, IP-IRM converges as $\\mathcal { G } / \\mathcal { D } _ { \\mathrm { a u g } }$ is finite. Note that an improved contrastive objective [92] can further disentangle each $d \\in \\mathcal { D } _ { \\mathrm { a u g } }$ and achieve full disentanglement w.r.t. $\\mathcal { G }$ . ",
+        "bbox": [
+            174,
+            402,
+            825,
+            529
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            549,
+            312,
+            566
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 Unsupervised Disentanglement ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            580,
+            428,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We used two datasets. CMNIST [2] has 60,000 digit images with semantic labels of digits (0-9) and colors (red and green). These images differ in other semantics (e.g., slant and font) that are not labeled. Moreover, there is a strong correlation between digits and colors (most 0-4 in red and 5-9 in green), increasing the difficulty to disentangle them. Shapes3D [50] contains 480,000 images with 6 labelled semantics, i.e., size, type, azimuth, as well as floor, wall and object color. Note that we only considered the first three semantics for evaluation, as the standard augmentations in SSL will contaminate any color-related semantics. ",
+        "bbox": [
+            173,
+            607,
+            825,
+            704
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Settings. We adopted 6 representative disentanglement metrics: Disentangle Metric for Informativeness (DCI) [29], Interventional Robustness Score (IRS) [79], Explicitness Score (EXP) [72], Modularity Score (MOD) [72] and the accuracy of predicting the ground-truth semantic labels by two classification models called logistic regression (LR) and gradient boosted trees (GBT) [59]. Specifically, DCI and EXP measure the explicitness, i.e., the values of semantics can be decoded from the feature using a linear transformation. MOD and IRS measure the modularity, i.e., whether each feature dimension is equivariant to the shift of a single semantic. See Appendix for more detailed formula of the metrics. In evaluation, we trained CNN-based feature extractor backbones with comparable number of parameters for all the baselines and our IP-IRM. The full implementation details are in Appendix. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results. In Table 1, we compared the proposed IP-IRM to the standard SSL method SimCLR [16] as well as several generative disentanglement methods [51, 41, 9, 15, 50]. On both CMNIST and Shapes3D dataset, IP-IRM outperforms SimCLR regarding all metrics except for only IRS where the most relative gain is $8 . 8 \\%$ for MOD. For this MOD, we notice that VAE performs better than our IP-IRM by 6 points, i.e., 0.82 v.s. 0.76 for Shapes3D. This is because VAE explicitly pursues a high modularity score through regularizing the dimension-wise independence in the feature space. However, this regularization is adversarial to discriminative objectives [14, 95]. Indeed, we can observe from the column of LR (i.e., the performance of downstream linear classification) that VAE methods have clearly poor performance especially on the more challenging dataset Shapes3D. We can draw the same conclusion from the results of GBT. Different from VAE methods, our IP-IRM is optimized towards disentanglement without such regularization, and is thus able to outperform the others in downstream tasks while obtaining a competitive value of modularity. ",
+        "bbox": [
+            176,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/11e807af754b56194a9890b41a2dbfb4addeb68432a0df0c278db14b1c249deb.jpg",
+        "image_caption": [
+            "Figure 4: The t-SNE [85] visualizations of learned feature spaces using SimCLR [16] and IP-IRM on CMNIST [2] and STL10 [22]. For CMIST in (a), we annotate the digit and color near each cluster. We annotate only half of the feature points for SimCLR to avoid clutter. For STL10 in (b), we show the labels of the classes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            87,
+            823,
+            244
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ce626ce68e1a74ae33af9d91aa5685f2eae5fa3170328612135c6263e8433b26.jpg",
+        "image_caption": [
+            "Figure 5: (a) Visualization of the obtained partitions $\\mathbf { P } ^ { * }$ during training. Each partition has two subset and the displayed images are randomly sampled from each subset. (b) Visualization of the variance of each feature dimension when perturbing the semantic indicated on the left. The most equivariant dimensions are indicated by triangles and their corresponding indices. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            311,
+            821,
+            491
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            573,
+            825,
+            684
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "What do IP-IRM features look like? Figure 4 visualizes the features learned by SimCLR and our IP-IRM on two datasets: CMNIST in Figure 4 (a) and STL10 dataset in Figure 4 (b). In the following, we use Figure 4 (a) as the example, and can easily draw the similar conclusions from Figure 4 (b). On the left-hand side of Figure 4 (a), it is obvious that there is no clear boundary to distinguish the semantic of color in the SimCLR feature space. Besides, the features of the same digit semantic are scattered in two regions. On the right-hand side of (a), we have 3 observations for IP-IRM. 1) The features are well clustered and each cluster corresponds to a specific semantic of either digit or color. This validates the equivariant property of IP-IRM representation that it responds to any changes of the existing semantics, e.g., digit and color on this dataset. 2) The feature space has the symmetrical structure for each individual semantic, validating the decomposable property of IP-IRM representation. More specifically, i) mirroring a feature (w.r.t. “\\*” in the figure center) indicates the change on the only semantic of color, regardless of the other semantic (digit); and ii) a counterclockwise rotation (denoted by black arrows from same-colored 1 to 7) indicates the change on the only semantic of digit. 3) IP-IRM reveals the true distribution (similarity) of different classes. For example, digits 3, 5, 8 sharing sub-parts (curved bottoms and turnings) have closer feature points in the IP-IRM feature space. ",
+        "bbox": [
+            173,
+            690,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "How does IP-IRM disentangle features? 1) Discovered $\\mathbf { P } ^ { * }$ : To visualize the discovered partitions $\\mathbf { P } ^ { * }$ at each maximization step, we performed an experiment on a binary CMNIST (digit 0 and 1 in color red and green), and show the results in Figure 5 (a). Please kindly refer to Appendix for the full results on CMNIST. First, each partition tells apart a specific semantic into two subsets, e.g., in Partition #1, red and green digits are separated. Second, besides the obvious semantics—digit and color (labelled on the dataset), we can discover new semantics, e.g., the digit slant shown in Partition #3. 2) Disentangled Representation: In Figure 5 (b), we aim to visualize how equivariant each feature dimension is to the change of each semantic, i.e., a darker color shows that a dimension is more equivariant w.r.t. the semantic indicated on the left. We can see that SimCLR fails to learn the decomposable representation, e.g., the 8-th dimension captures azimuth, type and size in Shapes3D. In contrast, our IP-IRM achieves disentanglement by representing the semantics into interpretable dimensions, e.g., the 6-th and 7-th dimensions captures the size, the 4-th for type and the 2-nd and 9-th for azimuth on the Shapes3D. Overall, the results support the justification in Section 4, i.e., we discover a new semantic (affected by $h$ ) through the partition $\\mathbf { P } ^ { * }$ at each iteration and IP-IRM eventually converges with a disentangled representation. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            299
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Self-Supervised Learning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            319,
+            390,
+            333
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Datasets and Settings. We conducted the SSL evaluations on 2 standard benchmarks following [88, 20, 48]. Cifar100 [54] contains 60,000 images in 100 classes and STL10 [22] has 113,000 images in 10 classes. We used SimCLR [16], DCL [20] and HCL [48] as baselines, and learned the representations for 400 and 1000 epochs. We evaluated both linear and $k$ -NN $k = 2 0 0$ ) accuracies for the downstream classification task. Implementation details are in appendix. ",
+        "bbox": [
+            174,
+            345,
+            825,
+            415
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/07bf4a6ca9461b7d00d985c117434b84fff35328b7126309815a767c90e05624.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">STL10</td><td colspan=\"2\">Cifar100</td></tr><tr><td>k-NN</td><td>Linear</td><td>k-NN</td><td>Linear</td></tr><tr><td colspan=\"5\">400 epoch training</td></tr><tr><td>SimCLR[16]</td><td>73.60</td><td>78.89</td><td>54.94</td><td>66.63</td></tr><tr><td>DCL [20]</td><td>78.82</td><td>82.56</td><td>57.29</td><td>68.59</td></tr><tr><td>HCL [48]</td><td>80.06</td><td>87.60</td><td>59.61</td><td>69.22</td></tr><tr><td>SimCLR+IP-IRM</td><td>79.66</td><td>84.44</td><td>59.10</td><td>69.55</td></tr><tr><td>DCL+IP-IRM</td><td>81.51</td><td>85.36</td><td>58.37</td><td>68.76</td></tr><tr><td>HCL+IP-IRM</td><td>84.29</td><td>87.81</td><td>60.05</td><td>69.95</td></tr><tr><td colspan=\"5\">1,000 epoch training</td></tr><tr><td>SimCLR[16]</td><td>78.60</td><td>84.24</td><td>59.45</td><td>68.73</td></tr><tr><td>SimCLR† [55]</td><td>79.80</td><td>85.56</td><td>63.67</td><td>72.18</td></tr><tr><td>SimCLR+IP-IRM</td><td>85.08</td><td>89.91</td><td>65.82</td><td>73.99</td></tr><tr><td>Supervised*</td><td>=</td><td>=</td><td>=</td><td>73.72</td></tr><tr><td>Supervised*+MixUp [97]</td><td></td><td>=</td><td>=</td><td>74.19</td></tr></table>",
+        "bbox": [
+            189,
+            431,
+            553,
+            648
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Accuracy $( \\% )$ of $k$ -NN and linear classifiers on STL10 [22] and Cifar100 [54] using the representations of SimCLR [16], DCL [20], HCL [48] and those after incorporating our IPIRM. ${ \\bf S i m C L R } ^ { \\dagger }$ denotes $\\mathrm { S i m C L R }$ with MixUp regularization. Supervised∗ represents the supervised learning that keeps the same codebase, optimizer and parameters with SSL stage-2 fine-tuning while only adds the learning rate decay at 60 and 80 epoch. ",
+        "bbox": [
+            173,
+            652,
+            566,
+            742
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results. We demonstrate our results and compare with baselines in Table 2. Incorporating IP-IRM to the 3 baselines brings consistent performance boosts to downstream classification models in all settings, e.g., improving the linear models by $5 . 5 5 \\%$ on STL10 and $2 . 9 2 \\%$ on Cifar100. In particular, we observe that IP-IRM brings huge performance gain with $k$ -NN classifiers, e.g., $4 . 2 3 \\%$ using $\\mathrm { H C L + I P }$ -IRM on STL10, i.e., the distance metrics in the IP-IRM feature space more faithfully reflects the class semantic differences. This validates that our algorithm further disentangles compared to the standard SSL Moreover, by extending the training process to 1,000 epochs with MixUp [55], SimCLR+IP-IRM achieves further performance boost on both datasets, e.g., $5 . 2 8 \\%$ for $k$ -NN and $4 . 3 5 \\%$ for linear classifier over SimCLR baseline on STL10 dataset. ",
+        "bbox": [
+            578,
+            422,
+            823,
+            751
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Notably, our SimCLR $^ +$ IP-IRM surpasses vanilla supervised learning on Cifar100 under the same evaluation setting. Still, the quality of disentanglement cannot be fully evaluated when the training and test samples are identically distributed—while the improved accuracy demonstrates that IP-IRM representation is more equivariant to class semantics, it does not reveal if the representation is decomposable. Hence we present an out-of-distribution (OOD) setting in Section 5.3 to further show this property. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            835
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Is IP-IRM sensitive to the values of hyper-parameters? 1) $\\lambda _ { 1 }$ and $\\lambda _ { 2 }$ in $E q$ . (2) and $E q$ . (3). In Figure 6 (a), we observe that the best performance is achieved with $\\lambda _ { 1 }$ and $\\lambda _ { 2 }$ taking values from 0.2 to 0.5 on both datasets. All accuracies drop sharply if using $\\lambda _ { 1 } = 1 . 0$ . The reason is that a higher $\\lambda _ { 1 }$ forces the model to push the $\\phi$ -induced similarity to fixed baseline $\\theta = 1$ , rather than decrease the loss $\\mathcal { L }$ on the pretext task, leading to poor convergence. 2) The number of epochs. In Figure 6 (b), we plot the Top-1 accuracies of using $k$ -NN classifiers along the 700-epoch training of two kinds of SSL representations—SimCLR and IP-IRM. It is obvious that IP-IRM converges faster and achieves a higher accuracy than SimCLR. It is worth to highlight that on the STL10, the accuracy of SimCLR starts to oscillate and grow slowly after the 150-th epoch, while ours keeps on improving. This is an empirical evidence that IP-IRM keeps on disentangling more and more semantics in the feature space, and has the potential of improvement through long-term training. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6e313ee04be31d1bce4e305ed6fc591eaee685e9cc6f43f024de3331551073d3.jpg",
+        "image_caption": [
+            "Figure 6: Our ablation study on the STL10 and Cifar100 datasets. (a) The Top-1 accuracy $( \\% )$ of linear classifiers using different values of $\\lambda _ { 1 }$ and $\\lambda _ { 2 }$ (in Eq. (2) and Eq. (3)), by training for 200 epochs on two datasets. (b) The Top-1 accuracy $( \\% )$ of $k$ -NN classifiers on two datasets, for which we trained the models for 700 epochs and updated $\\mathbf { P }$ every 50 epochs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            88,
+            769,
+            272
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            353,
+            825,
+            436
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 Potential on Large-Scale Data ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            419,
+            472
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We evaluated on the standard benchmark of supervised learning ImageNet ILSVRC2012 [25] which has in total 1,331,167 images in 1,000 classes. To further reveal if a representation is decomposable, we used NICO [37], which is a real-world image dataset designed for OOD evaluations. It contains 25,000 images in 19 classes, with a strong correlation between the foreground and background in the train split (e.g., most dogs on grass). We also studied the transferability of the learned representation following [30, 52]: FGVC Aircraft (Aircraft) [60], Caltech-101 (Caltech) [31], Stanford Cars (Cars) [93], Cifar10 [53], Cifar100 [53], DTD [21], Oxford 102 Flowers (Flowers) [62], Food-101 (Food) [6], Oxford-IIIT Pets (Pets) [67] and SUN397 (SUN) [91]. These datasets include coarse- to fine-grained classification tasks, and vary in the amount of training data (2,000-75,000 images) and classes (10-397 classes), representing a wide range of transfer learning settings. ",
+        "bbox": [
+            173,
+            483,
+            826,
+            636
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Settings. For the ImageNet, all the representations were trained for 200 epochs due to limited computing resources. We followed the common setting [80, 36], using a linear classifier, and report Top-1 classification accuracies. For NICO, we fixed the ImageNet pre-trained ResNet-50 backbone and fine-tuned the classifier. See appendix for more training details. For the transfer learning, we followed [30, 52] to report the classification accuracies on Cars, Cifar-10, Cifar-100, DTD, Food, SUN and the average per-class accuracies on Aircraft, Caltech, Flowers, Pets. We call them uniformly as Accuracy. We used the few-shot $n$ -way- $k$ -shot setting for model evaluation. Specifically, we randomly sampled 2,000 episodes from the test splits of above datasets. An episode contains $n$ classes, each with $k$ training samples and 15 testing samples, where we fine-tuned the linear classifier (backbone weights frozen) for 100 epochs on the training samples, and evaluated the classifier on the testing samples. We evaluated with $n = k = 5$ (results of $n = 5 , k = 2 0$ in Appendix). ",
+        "bbox": [
+            173,
+            641,
+            825,
+            794
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ImageNet and NICO. In Table 3 ImageNet accuracy, our IP-IRM achieves the best performance over all baseline models. Yet we believe that this does not show the full potential of IP-IRM, because ImageNet is a larger-scale dataset with many semantics, and it is hard to achieve a full disentanglement of all semantics within the limited 200 epochs. To evaluate the feature decomposability of IPIRM, we compared the performance on NICO with various SSL baselines in Table 3, where our approach significantly outperforms the baselines by $1 . 5 – 4 . 2 \\%$ . This validates IP-IRM feature is more decomposable—if each semantic feature (e.g., background) is decomposed in some fixed dimensions and some classes vary with such semantic, then the classifier will recognize this as a non-discriminative variant feature and hence focus on other more discriminative features (i.e., foreground). In this way, even though some classes are confounded by those non-discriminative features (e.g., most of the “dog” images are with “grass” background), the fixed dimensions still help classifiers neglect those non-discriminative ones. We further visualized the CAM [98] on NICO in Figure 7, which indeed shows that IP-IRM helps the classifier focus on the foreground regions. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/f465bd989c44d36d0217b1061b2efb4ffc7e81acacce09e6530559b82d3d47d6.jpg",
+        "table_caption": [
+            "Table 3: ImageNet and NICO Top-1 Accuracy $( \\% )$ of linear classifiers trained on the representations learnt with different SSL methods. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>ImageNet</td><td>NICO</td></tr><tr><td>InsDis [90]</td><td>56.5</td><td>65.6</td></tr><tr><td>PCL [56]</td><td>61.5</td><td>72.6</td></tr><tr><td>PIRL [61]</td><td>63.6</td><td>69.1</td></tr><tr><td>MoCo-v1 [36]</td><td>60.6</td><td>69.3</td></tr><tr><td>SimCLR (repro.) [16]</td><td>63.1</td><td>64.5</td></tr><tr><td>MoCo-v2 (repro.)[18]</td><td>67.3</td><td>78.0</td></tr><tr><td>SimSiam (repro.) [19]</td><td>68.8</td><td>66.7</td></tr><tr><td>SimCLR+IP-IRM</td><td>64.8</td><td>66.7</td></tr><tr><td>MoCo-v2+IP-IRM</td><td>67.6</td><td>79.5</td></tr><tr><td>SimSiam+IP-IRM</td><td>69.1</td><td></td></tr><tr><td></td><td></td><td>70.9</td></tr></table>",
+        "bbox": [
+            200,
+            88,
+            475,
+            226
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/8cb4b43d8af9d6b806f49d27f5ecdc3ffcfd884dbb5a12581321f78cc008ea4f.jpg",
+        "image_caption": [
+            "Figure 7: Visualization of CAM [98] on images from NICO [37] dataset using representations of the baseline MoCo-v2 [18] and our IP-IRM. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            531,
+            75,
+            777,
+            212
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/6a5ca7003ba9000bcd9a2c0f70a2e44edde7a5520c4ae2aa31b6d73275da8859.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 4: Accuracy $( \\% )$ of 5-way-5-shot few-shot evaluation using the image representation learned on ImageNet [25]. More detailed results are given in Appendix. "
+        ],
+        "table_body": "<table><tr><td>Method</td><td>Aircraft</td><td>Caltech</td><td>Cars</td><td>Cifar10</td><td>Cifar100</td><td>DTD</td><td>Flowers</td><td>Food</td><td>Pets</td><td>SUN</td><td>Average</td></tr><tr><td>InsDis [90]</td><td>35.07</td><td>75.97</td><td>37.49</td><td>51.49</td><td>57.61</td><td>69.38</td><td>77.35</td><td>50.01</td><td>66.38</td><td>74.97</td><td>59.57</td></tr><tr><td>PCL [56]</td><td>36.86</td><td>90.72</td><td>39.68</td><td>59.26</td><td>60.78</td><td>69.53</td><td>67.50</td><td>57.06</td><td>88.31</td><td>84.51</td><td>65.42</td></tr><tr><td>PIRL [61]</td><td>36.70</td><td>78.63</td><td>39.21</td><td>49.85</td><td>55.23</td><td>70.43</td><td>78.37</td><td>51.61</td><td>69.40</td><td>76.64</td><td>60.61</td></tr><tr><td>MoCo-v1 [36]</td><td>35.31</td><td>79.60</td><td>36.35</td><td>46.96</td><td>51.62</td><td>68.76</td><td>75.42</td><td>49.77</td><td>68.32</td><td>74.77</td><td>58.69</td></tr><tr><td>MoCo-v2[18]</td><td>31.98</td><td>92.32</td><td>41.47</td><td>56.50</td><td>63.33</td><td>78.00</td><td>80.05</td><td>57.25</td><td>83.23</td><td>88.10</td><td>67.22</td></tr><tr><td>IP-IRM (Ours)</td><td>32.98</td><td>93.16</td><td> 42.87</td><td>60.73</td><td>68.54</td><td>79.30</td><td>82.68</td><td>59.61</td><td>85.23</td><td>89.38</td><td>69.44</td></tr></table>",
+        "bbox": [
+            183,
+            287,
+            818,
+            380
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            428,
+            825,
+            497
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Few-Shot Tasks. As shown in Table 4, our IP-IRM significantly improves the performance of 5-way-5-shot setting, e.g., we outperform the baseline MoCo-v2 by $2 . 2 \\%$ . This is because IP-IRM can further disentangled $\\mathcal { G } \\backslash \\mathcal { D } _ { \\mathrm { a u g } }$ over SSL, which is essential for representations to generalize to different downstream class domains (recall Corollary 2 of Lemma 1). This is also in line with recent works [86] showing that a disentangled representation is especially beneficial in low-shot scenarios, and further demonstrates the importance of disentanglement in downstream tasks. ",
+        "bbox": [
+            174,
+            503,
+            825,
+            588
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            611,
+            297,
+            628
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We presented an unsupervised disentangled representation learning method called Iterative Partitionbased Invariant Risk Minimization (IP-IRM), based on Self-Supervised Learning (SSL). IP-IRM iteratively partitions the dataset into semantic-related subsets, and learns a representation invariant across the subsets using SSL with an IRM loss. We show that with theoretical guarantee, IP-IRM converges with a disentangled representation under the group-theoretical view, which fundamentally surpasses the capabilities of existing SSL and fully-supervised learning. Our proposed theory is backed by strong empirical results in disentanglement metrics, SSL classification accuracy and transfer performance. IP-IRM achieves disentanglement without using generative models, making it widely applicable on large-scale visual tasks. As future directions, we will continue to explore the application of group theory in representation learning and seek additional forms of inductive bias for faster convergence. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            797
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            820,
+            553,
+            839
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors would like to thank all reviewers for their constructive suggestions. This research is partly supported by the Alibaba-NTU Joint Research Institute, the A\\*STAR under its AME YIRG Grant (Project No. A20E6c0101), and the Singapore Ministry of Education (MOE) Academic Research Fund (AcRF) Tier 2 grant. ",
+        "bbox": [
+            176,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References [1] Philip W Anderson. More is different. Science, 1972. [2] Martin Arjovsky, Léon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization. arXiv preprint arXiv:1907.02893, 2019. [3] Philip Bachman, R Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. arXiv preprint arXiv:1906.00910, 2019. [4] Yoshua Bengio. Learning deep architectures for AI. Now Publishers Inc, 2009. [5] Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. IEEE transactions on pattern analysis and machine intelligence, 35(8):1798–1828, 2013. [6] Lukas Bossard, Matthieu Guillaumin, and Luc Van Gool. Food-101–mining discriminative components with random forests. In European conference on computer vision, 2014. [7] Jane Bromley, Isabelle Guyon, Yann LeCun, Eduard Säckinger, and Roopak Shah. Signature verification using a\" siamese\" time delay neural network. Advances in neural information processing systems, 6:737–744, 1993. [8] Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel Ziegler, Jeffrey Wu, Clemens Winter, Chris Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. In Advances in Neural Information Processing Systems, 2020. [9] Christopher P Burgess, Irina Higgins, Arka Pal, Loic Matthey, Nick Watters, Guillaume Desjardins, and Alexander Lerchner. Understanding disentangling in $\\beta$ -vae. arXiv preprint arXiv:1804.03599, 2018.   \n[10] Ruichu Cai, Zijian Li, Pengfei Wei, Jie Qiao, Kun Zhang, and Zhifeng Hao. Learning disentangled semantic representation for domain adaptation. In IJCAI: proceedings of the conference, 2019.   \n[11] Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. In Proceedings of the European Conference on Computer Vision (ECCV), pages 132–149, 2018.   \n[12] Mathilde Caron, Piotr Bojanowski, Julien Mairal, and Armand Joulin. Unsupervised pretraining of image features on non-curated data. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 2959–2968, 2019.   \n[13] Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. arXiv preprint arXiv:2006.09882, 2020.   \n[14] Long Chen, Hanwang Zhang, Jun Xiao, Wei Liu, and Shih-Fu Chang. Zero-shot visual recognition using semantics-preserving adversarial embedding networks. In CVPR, 2018.   \n[15] Ricky TQ Chen, Xuechen Li, Roger Grosse, and David Duvenaud. Isolating sources of disentanglement in variational autoencoders. In Advances in neural information processing systems, 2018.   \n[16] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In International conference on machine learning, pages 1597–1607. PMLR, 2020.   \n[17] Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. In Advances in neural information processing systems, 2016.   \n[18] Xinlei Chen, Haoqi Fan, Ross Girshick, and Kaiming He. Improved baselines with momentum contrastive learning. arXiv preprint arXiv:2003.04297, 2020.   \n[19] Xinlei Chen and Kaiming He. Exploring simple siamese representation learning. arXiv preprint arXiv:2011.10566, 2020.   \n[20] Ching-Yao Chuang, Joshua Robinson, Lin Yen-Chen, Antonio Torralba, and Stefanie Jegelka. Debiased contrastive learning. arXiv preprint arXiv:2007.00224, 2020.   \n[21] Mircea Cimpoi, Subhransu Maji, Iasonas Kokkinos, Sammy Mohamed, and Andrea Vedaldi. Describing textures in the wild. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2014.   \n[22] Adam Coates, Andrew $\\mathrm { N g }$ , and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pages 215–223. JMLR Workshop and Conference Proceedings, 2011.   \n[23] Taco Cohen and Max Welling. Learning the irreducible representations of commutative lie groups. In International Conference on Machine Learning, 2014.   \n[24] Taco S Cohen, Mario Geiger, Jonas Köhler, and Max Welling. Spherical cnns. In ICLR, 2018.   \n[25] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A largescale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pages 248–255. Ieee, 2009.   \n[26] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), 2019.   \n[27] Kien Do and Truyen Tran. Theory and evaluation metrics for learning disentangled representations. In International conference on learning representations, 2020.   \n[28] Carl Doersch, Abhinav Gupta, and Alexei A Efros. Unsupervised visual representation learning by context prediction. In Proceedings of the IEEE international conference on computer vision, pages 1422–1430, 2015.   \n[29] Cian Eastwood and Christopher KI Williams. A framework for the quantitative evaluation of disentangled representations. In International conference on learning representations, 2018.   \n[30] Linus Ericsson, Henry Gouk, and Timothy M. Hospedales. How Well Do Self-Supervised Models Transfer? In CVPR, 2021.   \n[31] Li Fei-Fei, Rob Fergus, and Pietro Perona. Learning generative visual models from few training examples: An incremental bayesian approach tested on 101 object categories. In 2004 conference on computer vision and pattern recognition workshop, 2004.   \n[32] Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, François Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. The Journal of Machine Learning Research, 2016.   \n[33] Spyros Gidaris, Praveer Singh, and Nikos Komodakis. Unsupervised representation learning by predicting image rotations. arXiv preprint arXiv:1803.07728, 2018.   \n[34] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020.   \n[35] W.F.J. Harris, W. Fulton, and J. Harris. Representation Theory: A First Course. 1991.   \n[36] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. arXiv preprint arXiv:1911.05722, 2019. ",
+        "bbox": [
+            174,
+            87,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            178,
+            74,
+            828,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[37] Yue He, Zheyan Shen, and Peng Cui. Towards non-iid image classification: A dataset and baselines. Pattern Recognition, 110:107383, 2021. ",
+        "bbox": [
+            178,
+            90,
+            825,
+            121
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[38] Olivier Henaff. Data-efficient image recognition with contrastive predictive coding. In International Conference on Machine Learning, pages 4182–4192. PMLR, 2020. ",
+        "bbox": [
+            179,
+            128,
+            823,
+            159
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[39] I. Higgins, Loïc Matthey, A. Pal, C. Burgess, Xavier Glorot, M. Botvinick, S. Mohamed, and Alexander Lerchner. beta-vae: Learning basic visual concepts with a constrained variational framework. In ICLR, 2017. ",
+        "bbox": [
+            181,
+            167,
+            823,
+            210
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[40] Irina Higgins, David Amos, David Pfau, Sebastien Racaniere, Loic Matthey, Danilo Rezende, and Alexander Lerchner. Towards a definition of disentangled representations. arXiv preprint arXiv:1812.02230, 2018. ",
+        "bbox": [
+            179,
+            220,
+            826,
+            263
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[41] Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-vae: Learning basic visual concepts with a constrained variational framework. International conference on learning representations, 2017. ",
+        "bbox": [
+            181,
+            272,
+            826,
+            329
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[42] R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Phil Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. arXiv preprint arXiv:1808.06670, 2018. ",
+        "bbox": [
+            181,
+            338,
+            823,
+            382
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[43] Jun-Ting Hsieh, Bingbin Liu, De-An Huang, Li Fei-Fei, and Juan Carlos Niebles. Learning to decompose and disentangle representations for video prediction. In Advances in neural information processing systems, 2018. ",
+        "bbox": [
+            181,
+            391,
+            823,
+            435
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[44] Qianjiang Hu, Xiao Wang, Wei Hu, and Guo-Jun Qi. Adco: Adversarial contrast for efficient learning of unsupervised representations from self-trained negative adversaries. arXiv preprint arXiv:2011.08435, 2020. ",
+        "bbox": [
+            181,
+            444,
+            823,
+            486
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[45] Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Logan Engstrom, Brandon Tran, and Aleksander Madry. Adversarial examples are not bugs, they are features. In Advances in Neural Information Processing Systems, 2019. ",
+        "bbox": [
+            181,
+            496,
+            823,
+            540
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[46] Andrew Jaegle, Stephen Phillips, Daphne Ippolito, and Kostas Daniilidis. Understanding image motion with group representations. 2018. ",
+        "bbox": [
+            181,
+            547,
+            821,
+            578
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[47] Thomas W. Judson. Abstract Algebra: Theory and Applications (The Prindle, Weber & Schmidt Series in Advanced Mathematics). Prindle Weber & Schmidt, 1994. ",
+        "bbox": [
+            181,
+            587,
+            823,
+            617
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[48] Yannis Kalantidis, Mert Bulent Sariyildiz, Noe Pion, Philippe Weinzaepfel, and Diane Larlus. Hard negative mixing for contrastive learning. arXiv preprint arXiv:2010.01028, 2020. ",
+        "bbox": [
+            179,
+            626,
+            826,
+            655
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[49] Theofanis Karaletsos, Serge Belongie, and Gunnar Rätsch. Bayesian representation learning with oracle constraints. International conference on learning representations, 2015. ",
+        "bbox": [
+            178,
+            664,
+            823,
+            694
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[50] Hyunjik Kim and Andriy Mnih. Disentangling by factorising. In International Conference on Machine Learning, 2018. ",
+        "bbox": [
+            181,
+            703,
+            823,
+            732
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[51] Diederik Kingma and Max Welling. Auto-encoding variational bayes. In ICLR, 2014. ",
+        "bbox": [
+            186,
+            741,
+            782,
+            758
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[52] Simon Kornblith, Jonathon Shlens, and Quoc V Le. Do better imagenet models transfer better? In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2019. ",
+        "bbox": [
+            179,
+            767,
+            826,
+            809
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[53] Alex Krizhevsky. Learning multiple layers of features from tiny images. 2012. ",
+        "bbox": [
+            183,
+            819,
+            735,
+            835
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[54] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            181,
+            844,
+            820,
+            872
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[55] Kibok Lee, Yian Zhu, Kihyuk Sohn, Chun-Liang Li, Jinwoo Shin, and Honglak Lee. i-mix: A domain-agnostic strategy for contrastive representation learning. In ICLR, 2021. ",
+        "bbox": [
+            183,
+            882,
+            821,
+            912
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[56] Junnan Li, Pan Zhou, Caiming Xiong, Richard Socher, and Steven CH Hoi. Prototypical contrastive learning of unsupervised representations. arXiv preprint arXiv:2005.04966, 2020.   \n[57] Zinan Lin, Kiran Thekumparampil, Giulia Fanti, and Sewoong Oh. Infogan-cr and modelcentrality: Self-supervised model training and selection for disentangling gans. In International Conference on Machine Learning, 2020.   \n[58] F. Locatello, M. Tschannen, S. Bauer, G. Rätsch, B. Schölkopf, and O. Bachem. Disentangling factors of variations using few labels. In 8th International Conference on Learning Representations (ICLR), 2020.   \n[59] Francesco Locatello, Stefan Bauer, Mario Lucic, Gunnar Raetsch, Sylvain Gelly, Bernhard Schölkopf, and Olivier Bachem. Challenging common assumptions in the unsupervised learning of disentangled representations. In international conference on machine learning, 2019.   \n[60] Subhransu Maji, Esa Rahtu, Juho Kannala, Matthew Blaschko, and Andrea Vedaldi. Finegrained visual classification of aircraft. arXiv preprint arXiv:1306.5151, 2013.   \n[61] Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 6707–6717, 2020.   \n[62] Maria-Elena Nilsback and Andrew Zisserman. Automated flower classification over a large number of classes. In 2008 Sixth Indian Conference on Computer Vision, Graphics & Image Processing, 2008.   \n[63] Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In European conference on computer vision, pages 69–84. Springer, 2016.   \n[64] Utkarsh Ojha, Krishna Kumar Singh, Cho-Jui Hsieh, and Yong Jae Lee. Elastic-infogan: Unsupervised disentangled representation learning in class-imbalanced data. In Advances in neural information processing systems, 2020.   \n[65] Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.   \n[66] Giambattista Parascandolo, Niki Kilbertus, Mateo Rojas-Carulla, and Bernhard Schölkopf. Learning independent causal mechanisms. In Proceedings of the 35th International Conference on Machine Learning, pages 4036–4044, 2018.   \n[67] Omkar M Parkhi, Andrea Vedaldi, Andrew Zisserman, and CV Jawahar. Cats and dogs. In 2012 IEEE conference on computer vision and pattern recognition, 2012.   \n[68] Robin Quessard, Thomas Barrett, and William Clements. Learning disentangled representations and group structure of dynamical environments. Advances in Neural Information Processing Systems, 2020.   \n[69] Rajesh PN Rao and Daniel L Ruderman. Learning lie groups for invariant visual perception. Advances in neural information processing systems, 1999.   \n[70] Scott Reed, Kihyuk Sohn, Yuting Zhang, and Honglak Lee. Learning to disentangle factors of variation with manifold interaction. In International conference on machine learning, 2014.   \n[71] Xuanchi Ren, Tao Yang, Yuwang Wang, and Wenjun Zeng. Do generative models know disentanglement? contrastive learning is all you need. arXiv preprint arXiv:2102.10543, 2021.   \n[72] Karl Ridgeway and Michael C Mozer. Learning deep disentangled embeddings with the f-statistic loss. In Advances in neural information processing systems, 2018.   \n[73] Joshua Robinson, Ching-Yao Chuang, Suvrit Sra, and Stefanie Jegelka. Contrastive learning with hard negative samples. arXiv preprint arXiv:2010.04592, 2020.   \n[74] Bernhard Schölkopf, Dominik Janzing, Jonas Peters, Eleni Sgouritsa, Kun Zhang, and Joris Mooij. On causal and anticausal learning. In Proceedings of the 29th International Conference on Machine Learning, 2012.   \n[75] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In 3rd International Conference on Learning Representations, 2015.   \n[76] Ivan Sosnovik, Michał Szmaja, and Arnold Smeulders. Scale-equivariant steerable networks. 2020.   \n[77] Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014.   \n[78] Raphael Suter, Djordje Miladinovic, Stefan Bauer, and Bernhard Schölkopf. Interventional robustness of deep latent variable models. arXiv, 2018.   \n[79] Raphael Suter, Djordje Miladinovic, Bernhard Schölkopf, and Stefan Bauer. Robustly disentangled causal mechanisms: Validating deep representations for interventional robustness. In International Conference on Machine Learning, 2019.   \n[80] Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019.   \n[81] Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. In Andrea Vedaldi, Horst Bischof, Thomas Brox, and Jan-Michael Frahm, editors, European conference on computer vision, 2020.   \n[82] Yonglong Tian, Chen Sun, Ben Poole, Dilip Krishnan, Cordelia Schmid, and Phillip Isola. What makes for good views for contrastive learning. arXiv preprint arXiv:2005.10243, 2020.   \n[83] Yuandong Tian, Xinlei Chen, and Surya Ganguli. Understanding self-supervised learning dynamics without contrastive pairs. arXiv preprint arXiv:2102.06810, 2021.   \n[84] Luan Tran, Xi Yin, and Xiaoming Liu. Disentangled representation learning gan for poseinvariant face recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017.   \n[85] Laurens Van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of machine learning research, 9(11), 2008.   \n[86] Sjoerd Van Steenkiste, Francesco Locatello, Jürgen Schmidhuber, and Olivier Bachem. Are disentangled representations helpful for abstract visual reasoning? In Advances in neural information processing systems, 2019.   \n[87] Tan Wang, Chang Zhou, Qianru Sun, and Hanwang Zhang. Causal attention for unbiased visual recognition. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2021.   \n[88] Xudong Wang, Ziwei Liu, and Stella X Yu. Unsupervised feature learning by cross-level discrimination between instances and groups. arXiv preprint arXiv:2008.03813, 2020.   \n[89] Daniel E Worrall and Max Welling. Deep scale-spaces: Equivariance over scale. In NeurIPS, 2019.   \n[90] Zhirong Wu, Yuanjun Xiong, Stella X Yu, and Dahua Lin. Unsupervised feature learning via non-parametric instance discrimination. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3733–3742, 2018.   \n[91] Jianxiong Xiao, James Hays, Krista A Ehinger, Aude Oliva, and Antonio Torralba. Sun database: Large-scale scene recognition from abbey to zoo. In 2010 IEEE computer society conference on computer vision and pattern recognition, 2010.   \n[92] Tete Xiao, Xiaolong Wang, Alexei A Efros, and Trevor Darrell. What should not be contrastive in contrastive learning. In International Conference on Learning Representations, 2021.   \n[93] Linjie Yang, Ping Luo, Chen Change Loy, and Xiaoou Tang. A large-scale car dataset for fine-grained categorization and verification. In 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2015.   \n[94] Mang Ye, Xu Zhang, Pong C Yuen, and Shih-Fu Chang. Unsupervised embedding learning via invariant and spreading instance feature. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 6210–6219, 2019.   \n[95] Zhongqi Yue, Tan Wang, Hanwang Zhang, Qianru Sun, and Xian-Sheng Hua. Counterfactual zero-shot and open-set visual recognition. In CVPR, 2021.   \n[96] Zhongqi Yue, Hanwang Zhang, Qianru Sun, and Xian-Sheng Hua. Interventional few-shot learning. In NeurIPS, 2020.   \n[97] Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In ICLR, 2018.   \n[98] Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2921–2929, 2016.   \n[99] Yizhe Zhu, Martin Renqiang Min, Asim Kadav, and Hans Peter Graf. S3vae: Self-supervised sequential vae for representation disentanglement and data generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2020.   \n[100] Zhenyao Zhu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Multi-view perceptron: a deep model for learning face identity and view representations. Advances in Neural Information Processing Systems 27 (NIPS 2014), 2014. ",
+        "bbox": [
+            178,
+            53,
+            828,
+            922
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            179,
+            75,
+            828,
+            917
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            89,
+            826,
+            455
+        ],
+        "page_idx": 15
+    }
+]

parse/train/RtNpzLdHUAW/RtNpzLdHUAW.md

@@ -0,0 +1,324 @@
+# STOCHASTIC SUBSET SELECTION FOR EFFICIENT TRAINING AND INFERENCE OF NEURAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Current machine learning algorithms are designed to work with huge volumes of high dimensional data such as images. However, these algorithms are being increasingly deployed to resource constrained systems such as mobile devices and embedded systems. Even in cases where large computing infrastructure is available, the size of each data instance, as well as datasets, can provide a huge bottleneck in data transfer across communication channels. Also, there is a huge incentive both in energy and monetary terms in reducing both the computational and memory requirements of these algorithms. For non-parametric models that require to leverage the stored training data at the inference time, the increased cost in memory and computation could be even more problematic. In this work, we aim to reduce the volume of data these algorithms must process through an endto-end two-stage neural subset selection model, where the first stage selects a set of candidate points using a conditionally independent Bernoulli mask followed by an iterative coreset selection via a conditional Categorical distribution. The subset selection model is trained by meta-learning with a distribution of sets. We validate our method on set reconstruction and classification tasks with feature selection as well as the selection of representative samples from a given dataset, on which our method outperforms relevant baselines. We also show in our experiments that our method enhances scalability of non-parametric models such as Neural Processes.
+
+# 1 INTRODUCTION
+
+The recent success of deep learning algorithms partly owes to the availability of huge volume of data (Deng et al., 2009; Krizhevsky et al., 2009; Liu et al., 2015), which enables training of very large deep neural networks. However, the high dimensionality of each data instance and the large size of datasets makes it difficult, especially for resource-limited devices (Chan et al., 2018; Li et al., 2019; Bhatia et al., 2019), to store and transfer the dataset, or perform on-device learning with the data. This problem becomes more problematic for non-parametric models such as Neural Processes (Hensel, 1973; Kim et al., 2019a) which require the training dataset to be stored for inference. Therefore, it is appealing to reduce the size of the dataset, both at the instance (Dovrat et al., 2019; Li et al., 2018b;b) and the dataset level, such that we selects only a small number of samples from the dataset, each of which contains only few selected input features (e.g. pixels). Then, we could use the selected subset for the reconstruction of the entire set (either each instance or the entire dataset) or for a prediction task, such as classification.
+
+The simplest way to obtain such a subset is random sampling, but it is highly sub-optimal in that it treats all elements in the set equally. However, the pixels from each image and examples from each dataset will have varying degree of importance (Katharopoulos & Fleuret, 2018) to a target task, whether it is reconstruction or prediction, and thus random sampling will generally incur large loss of accuracy for the target task. There exist some work on coreset construction (Huggins et al., 2016; Campbell & Broderick, 2018; 2019) which proposed to construct a small subset with the most important samples for Bayesian posterior inference. However, these methods cannot be applied straightforwardly to deep learning with an arbitrary target task. How can we then sample elements from the given set to construct a subset, such that it suffers from minimal accuracy loss on any target task? To this end, we propose to learn a sampler that learns to sample the most important samples for a given task, by training it jointly with the target task and additionally meta-learn a sampler over a distribution of datasets for instance selection in the classification task.
+
+![](images/8c4bfea74b3d97e11d0387bec64ec03c7362c0e78e70cf1445763b0807c76c85.jpg)  
+Figure 1: Concept: Our Stochastic Subset Selection method is generic and can be applied to many type of sets. (a) Selecting a subset of features (pixels) out of an image. This reduces communication cost in data transfer between devices and allows faster training or inference on resource-constrained devices due to the reduced computational cost. (b) Selecting a subset of instances out of a dataset. This helps resource-constrained system to train faster, or to make non-parametric inference more scalable.
+
+Specifically, we learn the sampling rate for individual samples in two stages. First we learn a Bernoulli sampling rate for individual sample to efficiently screen out less important elements. Then, to select the most important elements out of this candidate set considering relative importance, we use a Categorical distribution to model the conditional distribution of sampling each element given a set of selected elements. After learning the sampling probability for each stage, we could perform stochastic selection of a given set, with linear time complexity. Our Stochastic Subset Selection (SSS) is a general framework to sample elements from a set, and it can be applied to both feature sampling and instance sampling. SSS can reduce the memory and computation cost required to process data while retaining performance on downstream tasks.
+
+Our model can benefit from a wide range of practical applications. For example, when sending an image to an edge device with low computing power, instead of sending the entire image, we could send a subset of pixels with their coordinates, which will reduce both communication and inference cost. Similarly, edge devices may need to perform inference on a huge amount of data that could be represented as a set (e.g. video, point clouds) in real-time, and our feature selection could be used to speed up the inference. Moreover, our model could also help with on-device learning on personal data (e.g. photos), as it can select out examples to train the model at a reduced cost. Finally, it can help with the scalability of non-parametric models which requires storage of training examples, such as Neural Processes, to scale up to large-scale problems.
+
+We validate our SSS model on multiple datasets for 1D function regression and 2D image reconstruction and classification for both feature selection and instance selection. The results show that our method is able to select samples with minimal decrease on the target task accuracy, largely outperforming random or an existing sampling method. Our contribution in this work is threefold:
+
+• We propose a novel two-stage stochastic subset selection method that learns to sample a subset from a larger set with linear time complexity, with minimal loss of accuracy at the downstream task. We propose a framework that trains the subset selection model via meta-learning, such that it can generalize to unseen tasks. We validate the efficacy and generality of our model on various datasets for feature selection from an instance and instance selection from a dataset, on which it significantly outperforms relevant baselines.
+
+# 2 RELATED WORK
+
+Set encoding - Permutation invariant networks Recently, extensive research efforts have been made in the area of set representation learning with the goal of obtaining order-invariant (or equivariant) and size-invariant representations. Many propose simple methods to obtain set representations by applying non-linear transformations to each element before a pooling layer (e.g. average pooling or max pooling) (Ravanbakhsh et al., 2016; Qi et al., 2017b; Zaheer et al., 2017; Sannai et al., 2019). However, these models are known to have limited expressive power and sometimes not capable of capturing high moments of distributions. Yet approaches such as Stochastic Deep Network (De Bie et al., 2018) and Set Transformer (Lee et al., 2018) consider the pairwise (or higher order) interactions among set elements and hence can capture more complex statistics of the distributions . These methods often result in higher performance in classification/regression tasks; however, they have run time complexities of $O ( n ^ { \mathbf { \bar { 2 } } } )$ or higher.
+
+![](images/0d7ed56f9b00b144a332829b601d15c8d05dec4362a5183f9be8a4cd109fd933.jpg)  
+Figure 2: Overview. The subset $D _ { s }$ is sampled by a stochastic 2-stage subset selection process. Dark shaded boxes correspond to selected elements while lightly shaded boxes correspond to non-selected elements in the given set. Also, Ber and Cat correspond to the Bernoulli and Categorical distributions respectively. (a) Candidate(in blue) Selection. (b) Core Subset(in green) Selection using continuous relaxations of discrete distributions.
+
+Subset sampling There exist some works which have been proposed to handle large sets. Dovrat et al. (2019) proposed to learn to sample a subset from a set by generating $k$ virtual points, then matching them back to a subset of the original set. However, such element generation and matching process is highly inefficient. Our method on the other hand only learns to select from the original elements and does not suffer from such overhead. Wang et al. (2018) proposed to distill the knowledge of a large dataset to a small number of artificial data instances. However, these artificial data instances are only for faster training and doesn’t capture the statistics of the original set. Moreover, the instances are generated artificially and can differ from the original set making the method less applicable to other tasks. Also several works (Qi et al., 2017a;c; Li et al., 2018b; Eldar et al., 1997; Moenning & Dodgson, 2003) propose farthest point sampling, which selects $k$ points from a set by ensuring that the selected samples are far from each other on a given metric space.
+
+Image Compression Due to the huge demand for image and video transfer over the internet, a number of works have attempted to compress images with minimal distortion. These models (Toderici et al., 2017; Rippel & Bourdev, 2017; Mentzer et al., 2018; Li et al., 2018a) typically consist of a pair of encoder and decoder, where the encoder will transfer the image into a compact matrix to reduce the memory footprint and communication cost, while the decoder is used to reconstruct the image back. These methods, while achieving huge successes in the image compression problem, are less flexible than ours. Firstly, our model can be applied to any type of sets (and instances represented as sets), while the aforementioned models mainly work for images represented in tensor form. Furthermore, our method can be applied both at the instance and dataset level.
+
+Representation learning Our instance-sampling model is also related to the Variational Auto Encoder (VAE) (Kingma & Welling, 2013). However, while VAE learns a compact representation of a data point, our model learns a compact representation of a set. Balın et al. (2019) learns a global feature selection model for reconstruction of the input data from selected features via unsupervised learning. Chen et al. (2018) learns instancewise feature selection with the goal of model interpretation by extracting subset of features most informative for a given sample. Our method also falls in this category.
+
+Active Learning Active learning methods are aimed at selection of data points for labeling given a small labelled set. This domain is different from our method since active learning does not consider the label information but our method does utilize label information. Also, our motivation is quite different. We focus on efficiency in inference and training of non-parametric models by reducing the sizes of the inputs, be it pixels or instances and this greatly differs from the goal of active learning. Methods such as (Sener & Savarese, 2017; Coleman et al., 2019; Wei et al., 2015) all tackle the data selection problem in the active learning setting.
+
+![](images/2ab4d2181373e9e07d906d3829e1471cf2cf43ece7c9f41ac2a1a0e1a47bc7ea.jpg)  
+Figure 3: Graphical Models: (a) Feature Selection for Reconstruction. (b) Feature Selection for Prediction Task. (c) Instance Selection model. (d) Instance Selection model for Classification
+
+# 3 APPROACH
+
+# 3.1 PRELIMINARIES
+
+In this work, we consider data of the type $D = \{ d _ { 1 } , \ldots , d _ { n } \}$ where individual $d _ { i }$ ’s are possibly represented as input $x _ { i }$ and target $y _ { i }$ . $D$ is the complete set and we assume that within $D$ , there exists a subset $D _ { s } = \{ s _ { i } , \ldots , s _ { k } \} \subset D$ such that $k \ll n$ and that for an arbitrarily defined loss function $\ell ( . , D )$ that we are interested in optimizing over the full set $D$ , $D _ { s }$ can be used as a proxy for $D$ such that $\ell ( . , D ) \approx \ell ( . , D _ { s } )$ . In what follows, we present a method that learns the conditional distribution $p ( D _ { s } | D )$ of the subset $D _ { s }$ via a two stage selection procedure dubbed candidate selection and autoregressive subset selection. The overall objective is then to minimize the loss function with respect to the subset $D _ { s }$ , $\mathbb { E } _ { p ( D _ { s } | D ) } [ \ell ( . , D _ { s } ) ]$ . When the set $D$ itself follows a distribution of sets as in the meta-learning framework, then the objective becomes $\mathbb { E } _ { D } [ \mathbb { E } _ { p ( D _ { s } | D ) } [ \ell ( . , D _ { s } ) ] ]$ . In essence, we seek to construct a subset $D _ { s }$ that is optimally representative of the full set $D$ w.r.t $\ell ( . )$ .
+
+# 3.2 STOCHASTIC SUBSET SELECTION
+
+In order to select $D _ { s }$ , we need to model the interactions among the elements of $D$ and construct $D _ { s }$ based on said interactions. However, when the cardinality $| D |$ of the set $D$ is large or it’s elements $d _ { i }$ ’s are high dimensional, modeling such pairwise interactions becomes computationally infeasible. As such, we first present the candidate selection procedure used to construct a smaller set, $D _ { c }$ , without considering inter-sample dependencies. This is then followed by the autoregressive subset selection procedure used to construct $D _ { s }$ from $D _ { c }$ by modeling inter-sample dependencies. The complete model is depicted in Figure 2.
+
+# 3.3 CANDIDATE SELECTION
+
+We model the task of candidate selection as a random Bernoulli process where the logits of the Bernoulli function are conditioned on the set representation of the full set $D$ and the individual elements $d _ { i } \in D$ . For a set $D$ with cardinality $n$ we define $Z : = \{ z _ { i } \} _ { i = 1 } ^ { n }$ such that $z _ { i } \in \{ 0 , 1 \}$ and $z _ { i } = 1$ implies that $d _ { i } \in D _ { c }$ and for each $d _ { i }$ , $z _ { i }$ is computed according to:
+
+$$
+p ( z _ { i } | d _ { i } , D ) = \mathtt { B e r } ( z _ { i } ; \rho ( d _ { i } , r ( D ) ) ) ,
+$$
+
+where $r ( D )$ is a permutation-invariant function that compresses $D$ into a single vector set representation and $\rho ( d _ { i } , r ( D ) )$ computes the logits used to calculate the probability of $d _ { i }$ belonging to $D _ { c }$ . We implement both $r ( D )$ and $\rho ( d _ { i } , r ( D ) )$ as neural networks and specifically for $r ( D )$ , we use Deep Sets (Zaheer et al., 2017). Since Ber is non-differentiable, we use the continuous relaxations of the Bernoulli distribution introduced in (Maddison et al., 2016; Jang et al., 2016; Gal et al., 2017).
+
+Specifically, to sample $z _ { i }$ , we execute the following computational routine:
+
+$$
+z _ { i } = \sigma \Big ( \frac { 1 } { \tau } \Big ( \log \frac { \pi _ { i } } { 1 - \pi _ { i } } + \log \frac { u } { 1 - u } \Big ) \Big ) , \quad \pi _ { i } = \rho ( d _ { i } , r ( D ) ) , \quad u \sim \mathrm { U n i f } ( 0 , 1 ) ,
+$$
+
+where $\sigma$ is the Sigmoid function, $\tau$ is the temperature for the continuous relaxation and $u$ is sampled from the uniform distribution. $\tau$ is set to 0.05 in all our experiments. Given that pair-wise interactions
+
+<table><tr><td colspan="2">Algorithm1Fixed Size Subset Selection</td></tr><tr><td>Input OutputDg= {s1,S2,..., sk} (selected subset)</td><td>k(subset size),q(# elements selected at each iteration),D= {d1,d2,...,dn} (Full Set)</td></tr><tr><td colspan="2">1:procedure STOCHASTIC SUBSET SELECTION(k,q, D)</td></tr><tr><td>2: 3:</td><td>(π1,π2,.:.,πn) ←(p(di,r(D)),...,p(dn,r(D)))</td></tr><tr><td></td><td>Zi~Ber(πi) fori=1,...,n.</td></tr><tr><td>4: 5:</td><td>Dc←{di fori=1:nif zi} Candidate Selection</td></tr><tr><td>6:</td><td>Ds← for i=1,...,k/q do AutoRegressive Subset Selection</td></tr><tr><td>7:</td><td>Ds←DUAUTOSELECT(q,Ds,Dc) Select q elements</td></tr><tr><td>8:</td><td>return D s</td></tr><tr><td>9:</td><td>procedure AUTOSELECT(q,Dg,Dc)</td></tr><tr><td colspan="2">10: C={w1,w2,...,wm} ←Dc\Ds</td></tr><tr><td>11:</td><td>(p1,p2,...,Pm)←(f(w1,Dc,Ds),f(w2,Dc,Ds),...,f(wm,Dc,Ds))</td></tr><tr><td>12:</td><td>(p1,P2,...,Pm) ← (pi,p2,...,Pm)/∑j=1Pj</td></tr><tr><td>13: 14:</td><td>Q ← Select q elements from C with probability (pi,P2,..., pm)</td></tr><tr><td></td><td>return Q</td></tr></table>
+
+between elements are not considered in this stage, learning $p ( z _ { i } | d _ { i } , D )$ ensures that highly activating samples are selected instead of a random subset of the original set.
+
+# 3.4 AUTOREGRESSIVE SUBSET SELECTION
+
+The candidate selection stage can introduce samples with redundant information in $D _ { c }$ since no effort was made to compare the informativity of the elements. To alleviate this issue, we must first model the interactions between the elements of $D _ { c }$ and construct $D _ { s }$ based on the relative importance of individual elements. To construct a representative subset $D _ { s }$ with $| D _ { s } | = k$ , $k$ iterative steps are required and at step $i$ the probability of an element in $D _ { c } \setminus D _ { s } ^ { ( i - 1 ) }$ belonging to $D _ { s }$ is computed according to:
+
+$$
+p ( s _ { i } = d | D _ { c } , D _ { s } ^ { ( i - 1 ) } ) = \frac { f ( d , D _ { c } , D _ { s } ^ { ( i - 1 ) } ) } { \sum _ { d ^ { \prime } \in D _ { c } \backslash D _ { s } ^ { ( i - 1 ) } } f ( d ^ { \prime } , D _ { c } , D _ { s } ^ { ( i - 1 ) } ) } \quad \forall d \in D _ { c } \setminus D _ { s } ^ { ( i - 1 ) } ,
+$$
+
+where $D _ { s } ^ { ( i - 1 ) }$ is the constructed subset at iteration $i - 1$ and $f$ is a positive function. The key to avoiding samples with redundant information in $D _ { s } ^ { ( k ) }$ lies in the fact that for each element added to $D _ { s }$ , it’s selection is conditioned on both $D _ { c }$ and all elements in $D _ { s } ^ { ( i - 1 ) }$ . We further propose a method that samples $q$ elements from $\mathbf { C a t } ( p _ { 1 } , \ldots , p _ { m } )$ in a single pass for efficient training. Specifically, instead of sampling $q$ times from the categorical distribution, we can sample the selection mask for element $j$ from $\mathrm { B e r } ( q * p _ { j } )$ . In this routine, the probability of the element $j$ being selected is $q * p _ { j }$ which is very close to the original distribution. Algorithm 1 details the entire procedure. The inference complexity depends heavily on the choice of the function $f$ . If $f$ considers the pairwise interactions between all candidate elements and the selected elements, the inference complexity is $O ( n ) { + } O ( k ^ { 2 } d / q )$ where $n , d , k$ correspond to $| D |$ , $| D _ { c } |$ and $| D _ { s } |$ respectively. In our experiments, for the choice of the function $f$ , we utilize either a Set Transformer(Lee et al., 2018) or DeepSets(Zaheer et al., 2017) to model the pairwise interactions between the elements of a given set.
+
+# 3.5 CONSTRAINING THE SIZE OF $D _ { c }$
+
+For computational efficiency, we may desire to restrict the size of $D _ { c }$ to save computational cost when constructing $D _ { s }$ . We adopt the idea of Information Bottleneck and constrain the distribution of $Z$ for $D _ { c }$ . Specifically,
+
+$$
+\mathbb { E } _ { p ( D ) } [ \mathbb { E } _ { p ( D _ { s } | D ) } [ \ell ( . , D _ { s } ) ] + \beta \mathbf { K } \mathbf { L } [ p ( Z | D ) | | r ( Z ) ] ]
+$$
+
+![](images/f452cc57183096f9b9016d494b4bc192de7b00ca1e631d71e61f30022cbfcb93.jpg)  
+Figure 4: Models’ performance on set reconstruction and classification task (lighter-color areas present the standard deviations). (a) 1D Function reconstruction. (b) CelebA (reconstruction). (c) CelebA (classification)
+
+![](images/c1f829aea08984161a9c05a62e8d24e9024fd1c4e58d431e4feadae71dc001a3.jpg)  
+Figure 5: 1D Function Reconstruction.
+
+where $r ( Z )$ is a sparse prior. In our experiments, we set the parameter of the Bernoulli spares prior $r ( Z )$ to either 0.1 or 0.01 for different levels of sparsity and $\beta$ is set to 1.0 or 0.001.
+
+# 3.6 TASKS
+
+We now present four tasks for which the described subset selection method is applied.
+
+Set Reconstruction Given $D _ { s }$ and a network $p _ { \theta } ( Y | X , D _ { s } )$ parameterized by $\theta$ , the task is to reconstruct $D = ( X , Y )$ . The objective function for this task is given as:
+
+$$
+\begin{array} { r } { \mathbb { E } _ { p ( D ) } [ \mathbb { E } _ { p ( D _ { s } | D ) } [ - \log p _ { \theta } ( Y | X , D _ { s } ) ] + \beta \mathbf { K L } [ p ( Z | D ) | | r ( Z ) ] ] } \end{array}
+$$
+
+Minimizing this objective ensures that we learn a compact subset $( D _ { s } )$ most representative of $D$ and $D _ { s }$ can then be used for other tasks. We implement $p _ { \theta } ( Y | X , D _ { s } )$ as an Attentive Neural Process (ANP) (Kim et al., 2019b). An ANP takes as input a context $D _ { s }$ in this case) and predicts a distribution of the elements in the original set $D$ . It mimics the behaviour of a Gaussian Process but with reduced inference complexity. The complete model is depicted in Figure 3a.Experimental results for this task can be found in Section 4.1.
+
+Set Classification/Prediction We can also opt to train the network to predict a single target $y _ { D }$ for the set $D$ . For instance, the target could be the class of an image(classification) or the statistics of the set(regression problem). Here, $p _ { \theta } ( y _ { D } | D _ { s } )$ is a neural network that predicts the target $y _ { D }$ . A set in this task, may be the features from a single example like an image and experimental results can be found in Section 4.2.The model for this task is depicted in Figure 3b. The objective function for this task is given as:
+
+$$
+\mathbb { E } _ { p ( D ) } [ \mathbb { E } _ { p ( D _ { s } | D ) } [ - \log p _ { \theta } ( y _ { D } | D _ { s } ) ] + \beta \mathbf { K L } [ p ( Z | D ) | | r ( Z ) ] ]
+$$
+
+Dataset Distillation: Instance Selection For this task, we are given a dataset $\begin{array} { r l } { \mathcal { D } } & { { } = } \end{array}$ $\{ D _ { 1 } , \ldots , D _ { n } \}$ where each $D _ { i }$ is a set of data points sampled from the entire dataset. Using CelebA as in illustrative example, some $D _ { i }$ may consist of $| D _ { i } |$ randomly sampled faces from the whole dataset. The goal is to construct $D _ { s }$ for each $D _ { i } \in \mathcal { D }$ . We describe a model capable of taking as input $D _ { i } \in \mathcal { D }$ to perform a task such as the reconstruction of all elements in the given dataset.
+
+Table 1: CelebA Attributes Classification.   
+
+<table><tr><td>Model</td><td>#Pixels</td><td>Storage</td><td>mAUC</td></tr><tr><td>Full Image</td><td>All 38804</td><td>114KB</td><td>0.9157</td></tr><tr><td>RS</td><td>500</td><td>5KB</td><td>0.8471</td></tr><tr><td>SSS(rec)</td><td>500</td><td>5KB</td><td>0.8921</td></tr><tr><td>SSS(MC)</td><td>500</td><td>5*5KB</td><td>0.9132</td></tr><tr><td>SSS(ours)</td><td>500</td><td>5KB</td><td>0.9093</td></tr></table>
+
+For a single dataset $D _ { i } \in \mathcal { D }$ , we apply the subset construction method already described to a $D _ { s }$ that can be used to reconstruct all the elements in $D _ { i }$ . In essence, $D _ { i }$ is distilled into a new dataset $D _ { s }$ with $k < | D _ { i } |$ elements. The task then is to reconstruct the entire set $D _ { i }$ back conditioned only on $D _ { s }$ . As a first step, we represent $D _ { s }$ as a unique representative vector $c$ for each element in the dataset akin to the statistics network used in the Neural Statistician (Edwards & Storkey, 2016) model. Specifically, to reconstruct an element $d _ { i } \in D _ { i }$ given $D _ { s }$ , $c$ is computed by applying a stochastic cross-attention
+
+Table 2: . FID Score for varying Instance Selection   
+
+<table><tr><td>#Instances</td><td>2</td><td>5</td><td>10</td><td>15</td><td>20</td><td>30</td></tr><tr><td>FPS</td><td>6.50</td><td>4.51</td><td>3.07</td><td>2.75</td><td>2.71</td><td>2.29</td></tr><tr><td>Random</td><td>3.73</td><td>1.16</td><td>0.90</td><td>0.38</td><td>0.39</td><td>0.20</td></tr><tr><td>SSS(ours)</td><td>2.53</td><td>1.02</td><td>0.59</td><td>0.33</td><td>0.24</td><td>0.17</td></tr></table>
+
+Table 3: Accuracy on miniImagenet   
+
+<table><tr><td>#Instances</td><td>1</td><td>2</td><td>5</td><td>10</td></tr><tr><td>FPS</td><td>0.432</td><td>0.501</td><td>0.598</td><td>0.636</td></tr><tr><td>Random</td><td>0.444</td><td>0.525</td><td>0.618</td><td>0.663</td></tr><tr><td>SSS(ours)</td><td>0.475</td><td>0.545</td><td>0.625</td><td>0.664</td></tr></table>
+
+mechanism on $D _ { s }$ where the stochasticity is supplied by a query $\alpha$ which is computed using $d _ { i }$ . To obtain varying styles in the generated images, we additionally learn a latent variable $w$ used to perturb $c$ and both are combined to obtain a new element $x$ . The graphical model for this process is depicted in Figure 3c. Additionally, to ensure that $c$ is properly learnt, we add an informativity loss by reconstructing $c$ from the generated samples from the given dataset. The objective for the model depicted in Figure 3c for a single dataset $D$ is :
+
+$$
+\begin{array} { r } { \mathcal { L } ( \theta , \phi , \psi ) = \displaystyle \sum _ { d _ { i } \in D } \big [ \mathbb { E } _ { q _ { \phi } ( w _ { i } \mid d _ { i } ) } \big [ p _ { \theta } ( d _ { i } \vert w _ { i } , c _ { i } ) \big ] - \mathbf { K L } [ q _ { \phi } ( w _ { i } \vert d _ { i } ) \vert \vert p _ { \psi } ( w ) \big ] } \\ { - \mathbf { K L } \big [ q _ { \phi } ( \alpha _ { i } \vert d _ { i } ) \vert \vert p _ { \psi } ( \alpha ) \big ] - \mathbf { K L } \big [ q _ { \phi } ( c _ { i } \vert D _ { s } , \alpha _ { i } ) \vert \vert p _ { \phi } ( c ) \big ] \big ] } \end{array}
+$$
+
+where $p _ { \psi } ( \cdot )$ are priors on their respective latent variables and $q _ { \phi } ( \cdot )$ ’s are implemented with neural networks. All priors are chosen to be Gaussian with zero mean and unit variance. This objective is combined with the informativity loss on all samples in $D _ { i }$ . It is important to note that $c$ is computed using only $D _ { i }$ for every element in $D$ . In addition to Equation 7 and the informativity loss, the model is optimized together with the subset selection model already described. When the model is fully optimized, it is applied to the instance selection task on the given dataset. In summary, the purpose of the generative model introduced is to train the subset selection module for the instance selection task. Experimetal results for this task can be found in Section 4.3.
+
+Dataset Distillation: Classification Finally in the dataset distillation task, we consider the problem of selecting prototypes to be used for few-shot classification. Here, we adopt Prototypical Networks (Snell et al., 2017) and apply the subset selection model to the task of selecting representative prototypes from each class to be used for classifying new instances. By learning to select the prototypes, we can remove outliers that would otherwise change the class prediction boundaries in the classification task. The complete graphical model for this task is given in Figure 3d where again $D _ { s }$ corresponds to the selected prototypes and $x _ { * }$ and $y _ { * }$ correspond to query and class label respectively. Experimental results for this task can be found in Section 4.3.
+
+# 4 EXPERIMENTS
+
+In this section, we present our experimental results. Model architectures and training hyper parameters are specified in the Appendix C.
+
+# 4.1 FEATURE SELECTION EXPERIMENTS
+
+Function Reconstruction - Approximation Our first experiment is on 1D function reconstruction. Suppose that we have a function ${ \bar { f } } : [ a , b ] \to \mathbb { R }$ . We first construct a set of data points of that function: $D = \{ ( x _ { 1 } , y _ { 1 } = f ( x _ { 1 } ) ) , ( x _ { 2 } , y _ { 2 } = f ( x _ { 2 } ) ) , \ldots , ( x _ { n } , y _ { n } = f ( x _ { n } ) ) \}$ where $( x _ { 1 } , x _ { 2 } , \ldots , x _ { n } )$ are uniformly distributed along the $\mathbf { X }$ -axis within the interval $[ a , b ]$ . Now if we have a family of functions $( f ^ { ( 1 ) } , f ^ { ( 2 ) } , \dots , f ^ { ( N ) } )$ , this will lead to a family of sets $( \bar { D } ^ { ( 1 ) } , D ^ { ( 2 ) } , \dots , D ^ { ( N ) } )$ . We train our model which consists of the subset selection model $p ( D _ { s } | D )$ and a task network $p ( \dot { Y } | X , D _ { s } )$ (e.g. ANP), on this data set and report the reconstruction loss, which is the negative log-likelihood.
+
+![](images/4f7599e4f585b537097e9f00fca3788fb0d0249ed363cec483e54bef48d1c7fc.jpg)  
+Figure 6: CelebA reconstruction samples with varying number of pixels.
+
+![](images/2852c4b401d717968822f0216269e10258bf48c196e319bf8a9939301dbef471.jpg)  
+Figure 7: Instance Selection Samples from a dataset of size 200.
+
+We compare SSS with Random Select(RS) (randomly selects a subset of $D$ and uses an ANP to reconstruct the set), and Learning to Sample (LTS) (Dovrat et al., 2019) to sample k elements and uses an ANP to reconstruct the set). Figure 4a shows the performance (reconstruction loss) of our models(SSS) and the baselines.
+
+SSS out-performs Random Select (RS), verifying that the subset selection model $p ( D _ { s } | D )$ can learn a meaningful distribution for the selected elements. Our model also out-performs the Learning to Sample (LTS) baseline.
+
+Through the visualization of the selected points in Figure 5, we can see that out model tends to pick out more points (presented as red dots) in the drifting parts of the curve, which is reasonable since these parts are harder to reconstruct. The other two baselines sometimes fails to do that, which leads to inaccurate reconstructions.
+
+Image Reconstruction Given an image we learn to select a core subset of pixels that best reconstructs the original image. Here, $x$ is 2-dimensional and $y$ is 3-dimensional for RGB images. An ANP is then used to reconstruct the remaining pixels from a set of context elements (selected subset in our case). We conduct this experiment on the CelebA dataset (Liu et al., 2018). Figure 4b shows that our model significantly outperforms ANP with RS (as in the original ANP paper) and the LTS baseline. Figure 6 shows the reconstruction samples of our model which are visually better than the reconstruction of the baselines for the same number of pixels.
+
+# 4.2 CLASSIFICATION/REGRESSION
+
+In this subsection, we validate our model on the prediction task. The goal is to learn to select a subset for a target task such as classification or regression. We again use the CelebA dataset, but this time the selected pixels are used to give predictions for 40 attributes of a celebrity’s face (in a multi-task learning setting). For our proposed model, only the selected pixels are used for prediction (other pixels’ values are set to zeros). Table 1 shows that using only 500 pixels $( \sim 1 . 3 \%$ of total pixels in an image), we can achieve a mean AUC of 0.9093 $9 9 . 3 \%$ of the accuracy obtained with the full image). Figure $\cdot$ shows the classification performance (in terms of mean AUC) versus the number of pixels selected. The AUC with selected pixels learned from our SSS is significantly higher than that of the random pixels baseline, showing the effectiveness of our subset selection method. We also include another baseline, namely SSS(rec). This is our stochastic subset selection model trained for reconstruction, but then later used for classification. Our model outperforms this variant, showing the effectiveness of training with the target task. Note that LTS cannot be applied to this experimental setup because during training, the generated virtual points cannot be converted back to an image in matrix form (due to the virtual coordinate), thus we cannot train the LTS model with CNN-based classification on the target task.
+
+Ablation Study Since our method is stochastic, the predictive distribution can be written as $\mathbb { E } _ { p ( D _ { s } | D ) } \left[ p _ { \theta } ( \dot { y } _ { D } | D _ { s } ) \right]$ , and we can use Monte Carlo sampling to get the prediction in practice. However, throughout the experiment section, we only reported the result with one sampled subset, since it gives the best reduction in memory and computational cost. This can be seen as MC sampling with one sample. We compare it against another variant: SSS(MC) with MC sampling (5 samples). It should be noted that by doing MC sampling with 5 samples, the computational cost (inference) is increased by 5 times, and the memory requirement can be increased by up to 5 times too. Table 1 shows that our model achieves comparable performance with that variant, thus justifying that it can achieve good performance for target tasks, while reducing memory and computation requirement.
+
+# 4.3 DATASET DISTILLATION
+
+Instance Selection We present results on the instance selection task applied to a whole dataset. In this task, we use the CelebA dataset since it has an imbalance both in terms of gender and race. A dataset is constructed by sampling 200 random images from the full dataset. In this experiment, we seek to select only a few(5-30) representative images from these generated datasets. On this task, our subset selection module is trained via the procedure detailed in Section 3.6 on instance selection. To evaluate the effectiveness of the SSS model, we evaluate the model in terms of the diversity in the selected subset using the Fréchet Inception Distance(FID Score) (Heusel et al., 2017) which measures the similarity and diversity between two datasets. We compare our model with the model that randomly samples instances from the full dataset. Additionally, we compare our method with the Farthest Point Sampling(FPS) algorithm which selects $k$ points from a given set by computing distances on a metric space between all elements and selecting those elements that are furthest from each other. FPS in general seeks to obtain a wide coverage over a given set and hence is a suitable baseline. The results of this experiment is presented in Table 4 where our selection method achieves a lower FID score compared to FPS and Random Sampling. Additionally, given that the dataset is highly imbalanced, FPS performs worst since by selecting the furthest elements in the given set it cannot capture the true representation of the whole dataset even when compared with Random Sampling. Also for small sample selection, our method outperforms FPS and Random Sampling significantly since our method is able to model the interactions within the full dataset and hence can select the most representative subset.
+
+Classification We use the miniImageNet dataset (Vinyals et al., 2016) and go from a 20 shot classification task to one of 1,2,5 or 10 shot classification task. We again compare with Random Sampling and FPS and apply them together with SSS for the reduction in shot. The results for this experiment is shown in Table 3, where it can be observed that SSS can learn to select more representative prototypes compared to the other methods especially in the few-shot problems where the choice of prototypes matters more. All models were trained for 300 epochs and the best model was picked using a validation set.
+
+# 5 CONCLUSION
+
+In this paper, we have proposed a stochastic subset selection method to reduce the size of an arbitrary set while preserving performance on a target task. Our selection method utilizes a Bernoulli mask to perform candidate selection, and a stack of Categorical distributions to iteratively select a core subset from the candidate set. As a result, the selection process does take the dependencies of the set’s members into account. Hence, it can select a compact set that avoids samples with redundant information. By using the compact subset in place of the original set for a target task, we can save memory, communication and computational cost. We hope that this can facilitate the use of machine learning algorithm in resource-limited systems such as mobile and embedded devices.
+
+# REFERENCES
+
+Muhammed Fatih Balın, Abubakar Abid, and James Zou. Concrete autoencoders: Differentiable feature selection and reconstruction. In International Conference on Machine Learning, pp. 444–453, 2019.   
+Abhinav Bhatia, Pradeep Varakantham, and Akshat Kumar. Resource constrained deep reinforcement learning. In Proceedings of the International Conference on Automated Planning and Scheduling, volume 29, pp. 610–620, 2019.   
+Trevor Campbell and Tamara Broderick. Bayesian coreset construction via greedy iterative geodesic ascent. arXiv preprint arXiv:1802.01737, 2018.   
+Trevor Campbell and Tamara Broderick. Automated scalable bayesian inference via hilbert coresets. The Journal of Machine Learning Research, 20(1):551–588, 2019.   
+Michael Chan, Daniel Scarafoni, Ronald Duarte, Jason Thornton, and Luke Skelly. Learning network architectures of deep cnns under resource constraints. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pp. 1703–1710, 2018.
+
+Jianbo Chen, Le Song, Martin J Wainwright, and Michael I Jordan. Learning to explain: An information-theoretic perspective on model interpretation. arXiv preprint arXiv:1802.07814, 2018.
+
+Cody Coleman, Christopher Yeh, Stephen Mussmann, Baharan Mirzasoleiman, Peter Bailis, Percy Liang, Jure Leskovec, and Matei Zaharia. Selection via proxy: Efficient data selection for deep learning. arXiv preprint arXiv:1906.11829, 2019.
+
+Gwendoline De Bie, Gabriel Peyré, and Marco Cuturi. Stochastic deep networks. arXiv preprint arXiv:1811.07429, 2018.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009.
+
+Oren Dovrat, Itai Lang, and Shai Avidan. Learning to sample. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2760–2769, 2019.
+
+Harrison Edwards and Amos Storkey. Towards a neural statistician. arXiv preprint arXiv:1606.02185, 2016.
+
+Yuval Eldar, Michael Lindenbaum, Moshe Porat, and Yehoshua Y Zeevi. The farthest point strategy for progressive image sampling. IEEE Transactions on Image Processing, 6(9):1305–1315, 1997.
+
+Yarin Gal, Jiri Hron, and Alex Kendall. Concrete dropout. In Advances in neural information processing systems, pp. 3581–3590, 2017.
+
+HERBERT Hensel. Neural processes in thermoregulation. Physiological Reviews, 53(4):948–1017, 1973.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In Advances in neural information processing systems, pp. 6626–6637, 2017.
+
+Jonathan Huggins, Trevor Campbell, and Tamara Broderick. Coresets for scalable bayesian logistic regression. In Advances in Neural Information Processing Systems, pp. 4080–4088, 2016.
+
+Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax. arXiv preprint arXiv:1611.01144, 2016.
+
+Angelos Katharopoulos and François Fleuret. Not all samples are created equal: Deep learning with importance sampling. arXiv preprint arXiv:1803.00942, 2018.
+
+Hyunjik Kim, Andriy Mnih, Jonathan Schwarz, Marta Garnelo, Ali Eslami, Dan Rosenbaum, Oriol Vinyals, and Yee Whye Teh. Attentive neural processes. arXiv preprint arXiv:1901.05761, 2019a.
+
+Hyunjik Kim, Andriy Mnih, Jonathan Schwarz, Marta Garnelo, Ali Eslami, Dan Rosenbaum, Oriol Vinyals, and Yee Whye Teh. Attentive neural processes. arXiv preprint arXiv:1901.05761, 2019b.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. Cifar-10 and cifar-100 datasets. URl: https://www. cs. toronto. edu/kriz/cifar. html, 6, 2009.
+
+Juho Lee, Yoonho Lee, Jungtaek Kim, Adam R Kosiorek, Seungjin Choi, and Yee Whye Teh. Set transformer. arXiv preprint arXiv:1810.00825, 2018.
+
+Mengtian Li, Ersin Yumer, and Deva Ramanan. Budgeted training: Rethinking deep neural network training under resource constraints. arXiv preprint arXiv:1905.04753, 2019.
+
+Mu Li, Wangmeng Zuo, Shuhang Gu, Debin Zhao, and David Zhang. Learning convolutional networks for content-weighted image compression. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3214–3223, 2018a.
+
+Yangyan Li, Rui Bu, Mingchao Sun, Wei Wu, Xinhan Di, and Baoquan Chen. Pointcnn: Convolution on x-transformed points. In Advances in neural information processing systems, pp. 820–830, 2018b.
+
+Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In Proceedings of International Conference on Computer Vision (ICCV), December 2015.
+
+Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Large-scale celebfaces attributes (celeba) dataset. Retrieved August, 15:2018, 2018.
+
+Chris J Maddison, Andriy Mnih, and Yee Whye Teh. The concrete distribution: A continuous relaxation of discrete random variables. arXiv preprint arXiv:1611.00712, 2016.
+
+Fabian Mentzer, Eirikur Agustsson, Michael Tschannen, Radu Timofte, and Luc Van Gool. Conditional probability models for deep image compression. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4394–4402, 2018.
+
+Carsten Moenning and Neil A Dodgson. Fast marching farthest point sampling. Technical report, University of Cambridge, Computer Laboratory, 2003.
+
+Charles R Qi, Hao Su, Kaichun Mo, and Leonidas J Guibas. Pointnet: Deep learning on point sets for 3d classification and segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 652–660, 2017a.
+
+Charles R Qi, Hao Su, Kaichun Mo, and Leonidas J Guibas. Pointnet: Deep learning on point sets for 3d classification and segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 652–660, 2017b.
+
+Charles Ruizhongtai Qi, Li Yi, Hao Su, and Leonidas J Guibas. Pointnet $^ { + + }$ : Deep hierarchical feature learning on point sets in a metric space. In Advances in neural information processing systems, pp. 5099–5108, 2017c.
+
+Siamak Ravanbakhsh, Jeff Schneider, and Barnabas Poczos. Deep learning with sets and point clouds. arXiv preprint arXiv:1611.04500, 2016.
+
+Oren Rippel and Lubomir Bourdev. Real-time adaptive image compression. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2922–2930. JMLR. org, 2017.
+
+Akiyoshi Sannai, Yuuki Takai, and Matthieu Cordonnier. Universal approximations of permutation invariant/equivariant functions by deep neural networks. arXiv preprint arXiv:1903.01939, 2019.
+
+Ozan Sener and Silvio Savarese. Active learning for convolutional neural networks: A core-set approach. arXiv preprint arXiv:1708.00489, 2017.
+
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in neural information processing systems, pp. 4077–4087, 2017.
+
+George Toderici, Damien Vincent, Nick Johnston, Sung Jin Hwang, David Minnen, Joel Shor, and Michele Covell. Full resolution image compression with recurrent neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5306–5314, 2017.
+
+Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in neural information processing systems, pp. 3630–3638, 2016.
+
+Tongzhou Wang, Jun-Yan Zhu, Antonio Torralba, and Alexei A Efros. Dataset distillation. arXiv preprint arXiv:1811.10959, 2018.
+
+Kai Wei, Rishabh Iyer, and Jeff Bilmes. Submodularity in data subset selection and active learning. In International Conference on Machine Learning, pp. 1954–1963, 2015.
+
+Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Ruslan R Salakhutdinov, and Alexander J Smola. Deep sets. In Advances in neural information processing systems, pp. 3391–3401, 2017.
+
+# A APPENDIX
+
+Organization This supplementary file is organized as follows. We provide the full pseudo-code for the Greedy Training Algorithm.We then show some visualization of our method for feature selection (in both 1D function and CelebA dataset) and report the results with multiple runs of the instance selection experiment, as well as its visualization. Qualitative results for Instance Selection as applied to the few-shot classification task are provided together with model specifications.
+
+# A.1 GREEDY TRAINING ALGORITHM
+
+Algorithm 2 shows our greedy training algorithm with stochastic gradient descent. The idea of the greedy training algorithm is to train the auto-regressive model to select the best next $q$ elements from the candidate set to minimize the target loss on the selected samples. By doing this, we do not have to run the auto-regressive model $k / q$ time during training, thus reducing the computational cost.
+
+<table><tr><td colspan="2">Algorithm2 Greedy Training Algorithm</td></tr><tr><td rowspan="4">Input</td><td>k(max subset size)</td></tr><tr><td>q(# elements selected at each iteration)</td></tr><tr><td>p(D) (distribution of sets)</td></tr><tr><td>α (learning rate)</td></tr><tr><td>Output</td><td>a target task with loss function l(·, ·) trained model with converged θ and </td></tr><tr><td colspan="2"></td></tr><tr><td colspan="2">1:0,←initialization 2:while not converged do</td></tr><tr><td></td><td></td></tr><tr><td>3:</td><td> Sample a minibatch with m sets D(1), D(2),..,D(m) from p(D)</td></tr><tr><td>4: 5:</td><td>D)~ p(D)|D()) for j=1...m</td></tr><tr><td>6:</td><td>i~ random sample from (O,...,k - q) I(）~ random i-element subset of D) for j = 1... m</td></tr><tr><td>7:</td><td>Q(）~ select a q-element subset from Di)\1(i) (with the auto-regressive model)</td></tr><tr><td>8:</td><td></td></tr><tr><td></td><td>0←0-avθ∑j=-1e(.,10）UQの),Φ←Φ-aVm∑j=1e(,1)）UQ)）</td></tr></table>
+
+# B INSTANCE SELECTION SAMPLES
+
+In this section, we show more examples of our 1D and CelebA experiments on how the models select the set elements for the target task.
+
+# B.0.1 1D FUNCTION - RECONSTRUCTION
+
+Figure 8 shows the reconstruction samples of our model on the 1D function dataset, which is objectively better than that of Learning to Sample (LTS) or Random Subset (RS). Since RS selects the set elements randomly, it can leave out important part of the 1D curve leading to wrong reconstructions. LTS also selects insufficient amount of set elements in some parts of the curves, resulting in suboptimal reconstructions.
+
+# B.1 CELEBA
+
+Figure 9 shows the selected pixels of our model for both the classification and reconstruction task. For the attribute classification task, the model tends to select pixels mainly from the face, since the task is to classify characteristics of the person. For reconstruction, the selected pixels are more evenly distributed, since the background also contributes significantly to the reconstruction loss.
+
+# B.2 DATASET DISTILLATION: INSTANCE SELECTION
+
+In Table 4, we represent the full results for the Instance Selection model on the CelebA dataset. For these experiments, we construct a set by randomly sampling 200 face images from the full dataset. To evaluate the model, we create multiple such datasets and run the baselines(Random Sampling and FPS) and SSS on the same datasets. The FID metric is then computed on the instances and averaged on all the randomly constructed datasets. For FPS, we use the open-source implementation in https://github.com/rusty1s/pytorch_cluster. Further, we provide qualitative results on a single dataset in Figure 10 where we show how our model picks 5 instances from the full set of 200 images face images.
+
+![](images/1267332bafb946ac28226f84c52b8c9b923d44d361c22ec75041defdcfde8073.jpg)  
+Figure 8: Reconstruction samples of 1D functions with different selection methods
+
+![](images/abec989fc625eb3b7b8d82cf32495eec8e42381076bc414d83aac3931e3509c4.jpg)  
+Figure 9: Selected pixels for different tasks on CelebA.
+
+Table 4: . FID Score for varying Instance Selection   
+
+<table><tr><td>#Instances</td><td>2</td><td>5</td><td>10</td><td>15</td><td>20</td><td>30</td></tr><tr><td>FPS</td><td>6.5014 ± 4.3502</td><td>4.5098± 2.3809</td><td>3.0746 ± 1.0979</td><td>2.7458 ± 0.6201</td><td>2.7118 ± 1.0410</td><td>2.2943± 0.8010</td></tr><tr><td>Random</td><td>3.7309 ± 1.1690</td><td>1.1575 ± 0.6532</td><td>0.8970 ± 0.4867</td><td>0.3843 ± 0.2171</td><td>0.3877 ± 0.1906</td><td>0.1980 ±0.1080</td></tr><tr><td>SSS</td><td>2.5307 ± 1.3583</td><td>1.0186 ± 0.1982</td><td>0.5922 ± 0.3181</td><td>0.3331 ± 0.1169</td><td>0.2381 ± 0.1153</td><td>0.1679 ± 0.0807</td></tr></table>
+
+# B.3 DATASET DISTILLATION: CLASSIFICATION
+
+In Figure 11 we provide visualizations for the instance selection problem as applied to the few-shot classification task. Here, we go from a 20-shot to a 1-shot classification problem where the prototype is selected from the support using SSS.
+
+# C MODEL SPECIFICATIONS
+
+SSS consists of $r ( D )$ , $\rho ( d _ { i } , r ( D ) )$ and $f ( d , D _ { c } , D _ { s } ^ { ( i - 1 ) }$ . We describe the models in this section.
+
+![](images/09763ee30d68e0631571b5be518f61d4d1948419c039947d7992ee815a5d9f20.jpg)  
+Figure 10: Visualization of a set with 200 images for instance selection. The two stage selection method in SSS is visualized as Candidate Set and SSS. A coreset of size 5 is visualized.
+
+![](images/d479b4da2e4843c2a7203d4072821ade6fe567c6efd74250ed1f792c7da0a03b.jpg)  
+Figure 11: Sample visualization of prototype selection for the miniImagenet dataset on the few-shot classification task. Each row represents a set that corresponds to the support from which a prototype is selected for the few-shot classification task.
+
+For all experiments, $r ( D )$ is implemented as DeepSets. This means that we take the mean of all the samples in a set to obtain the set representation.
+
+$\rho ( d _ { i } , r ( D ) )$ is implemented as a neural network with the following specifications: there are 3 Linear layers each followed by ReLU activation. Also, all inputs are projected into feature space using 3 Linear layers, each followed by ReLU activation.
+
+In the set classification task, $f ( d , D _ { c } , D _ { s } ^ { ( i - 1 ) }$ is implemented as a Set Transformer network. All other experiments use DeepSets.

parse/train/VKVShLsAuZ/VKVShLsAuZ.md

@@ -0,0 +1,222 @@
+# NeuroLKH: Combining Deep Learning Model with Lin-Kernighan-Helsgaun Heuristic for Solving the Traveling Salesman Problem
+
+Liang Xin Nanyang Technological University Singapore XINL0003@e.ntu.edu.sg
+
+Wen Song Shandong Unviersity Qingdao, China wensong@email.sdu.edu.cn
+
+Zhiguang Cao∗ Singapore Institute of Manufacturing Technology Singapore zhiguangcao@outlook.com
+
+Jie Zhang Nanyang Technological University Singapore jzhang@ntu.edu.sg
+
+# Abstract
+
+We present NeuroLKH, a novel algorithm that combines deep learning with the strong traditional heuristic Lin-Kernighan-Helsgaun (LKH) for solving Traveling Salesman Problem. Specifically, we train a Sparse Graph Network (SGN) with supervised learning for edge scores and unsupervised learning for node penalties, both of which are critical for improving the performance of LKH. Based on the output of SGN, NeuroLKH creates the edge candidate set and transforms edge distances to guide the searching process of LKH. Extensive experiments firmly demonstrate that, by training one model on a wide range of problem sizes, NeuroLKH significantly outperforms LKH and generalizes well to much larger sizes. Also, we show that NeuroLKH can be applied to other routing problems such as Capacitated Vehicle Routing Problem (CVRP), Pickup and Delivery Problem (PDP), and CVRP with Time Windows (CVRPTW).
+
+# 1 Introduction
+
+Traveling Salesman Problem (TSP) is an important NP-hard Combinatorial Optimization Problem with extensive industrial applications in various domains. Exact methods have the exponential worstcase computational complexity, which renders them impractical for solving large-scale problems in reality, even for highly optimized solvers such as Concorde. In contrast, although lacking optimality guarantees and non-trivial theoretical analysis, heuristic solvers search for near-optimal solutions with much lower complexity. They are usually desirable for real-life applications where statistically better performance is the goal.
+
+Traditional heuristic methods are manually designed based on expert knowledge which is usually human-interpretable. However, supported by the recent development of deep learning technology, modern methods train powerful deep neural networks to learn the complex patterns from the TSP instances generated from some specific distributions [32, 1, 6, 21, 18, 34, 33, 35]. The performances of deep learning models for solving TSP are constantly improved by these works, which unfortunately are still far worse than the strong traditional heuristic solver and generally limited to relatively small problem sizes.
+
+We believe that learning-based methods should be combined with strong traditional heuristic algorithms, which is also suggested by [2]. In such a way, while learning the complex patterns from data samples, the efficient heuristics highly optimized by researchers for decades can be effectively utilized, especially for problems such as TSP which are well-studied due to their importance.
+
+The Lin-Kernighan-Helsgaun (LKH) algorithm [12, 13] is generally considered as a very strong heuristic for solving TSP, which is developed based on the Lin-Kernighan (LK) heuristic [25]. LKH iteratively searches for $\lambda$ -opt moves to improve the existing solution where $\lambda$ edges of the tour are exchanged for another $\lambda$ edges to form a shorter tour. To save the searching time, the edges to add are limited to a small edge candidate set, which is created before search. One of the most significant contributions of LKH is to generate the edge candidate set based on Minimum Spanning Tree, rather than using the nearest neighbor method in the LK heuristic. Furthermore, LKH applies penalty values to the nodes which are iteratively optimized using subgradient optimization (will be detailed in Section 3). The optimized node penalties are used by LKH to transform the edge distances for the $\lambda$ -opt searching process and improve the quality of edge candidate sets, both of which help find better solutions.
+
+However, the edge candidate set generation in LKH is still guided by hand-crafted rules, which could limit the quality of edge candidates and hence the search performance. Moreover, the iterative optimization of node penalties is time-consuming, especially for large-scale problems. To address these limitations, we propose NeuroLKH, a novel learning-based method featuring a Sparse Graph Network (SGN) combined with the highly efficient $\lambda$ -opt local search of LKH. SGN outputs the edge scores and node penalties simultaneously, which are trained by supervised learning and unsupervised learning, respectively. NeuroLKH transforms the edge distances based on the node penalties learned inductively from training instances, instead of performing iterative optimization for each instance, therefore saving a significant amount of time. More importantly, at the same time the edge scores are used to create the edge candidate set, leading to substantially better sets than those created by LKH. NeuroLKH trains one single network on TSP instances across a wide range of sizes and generalizes well to substantially larger problems with minutes of unsupervised offline fine-tuning to adjust the node penalty scales for different sizes.
+
+Same as existing works on deep learning models for solving TSP, NeuroLKH aims to learn complex patterns from data samples to find better solutions for instances following specific distributions. Following the evaluation process in these works, we perform extensive experiments. Results show that NeuroLKH improves the baseline algorithms by large margins, not only across the wide range of training problem sizes, but also on much larger problem sizes not used in training. Furthermore, NeuroLKH trained with instances of relatively simple distributions generalizes well to traditional benchmark with various node distributions such as the TSPLIB [27]. Also, we show that NeuroLKH can be applied to guide the extension of LKH [14] for more complicated routing problems such as the Capacitated Vehicle Routing Problem (CVRP), Pickup and Delivery Problem (PDP) and CVRP with Time Windows (CVRPTW), using generated test datasets and traditional benchmarks [28, 30].
+
+# 2 Related works
+
+Till now, for routing problems such as TSP, most works focus on learning construction heuristics, where deep neural networks are trained to sequentially select the nodes to visit with supervised learning [32, 15] or reinforcement learning [1, 6, 26, 21, 22]. Similarly, networks are trained to pick edges in [18, 20]. In another line of works [4, 33, 16, 9, 5], researchers employ deep learning models to learn the actions for improving existing solutions, such as picking regions and rules or selecting nodes for the 2-opt heuristic. However, the performance of these works is still quite far from the strong non-learning heuristics such as LKH. In addition, they focus only on relatively small-sized problems (up to hundreds of nodes).
+
+A recent work [8] generalizes a network pre-trained on fixed-size small graphs to solve larger size problems by sampling small sub-graphs to infer and merging the results. This interesting idea can be applied to very large graphs, however, the performance is still inferior to LKH and deteriorates rapidly with the increase of problem size.
+
+In a concurrent work [36], a VSR-LKH method is proposed which also applies a learning method in combination with LKH. However, very different from our method, VSR-LKH applies traditional reinforcement learning during the searching process for each instance, instead of learning patterns for a class of instances. Moreover, VSR-LKH aims to guide the decision on edge selections within the edge candidate set, which is generated using the original procedure of LKH. NeuroLKH significantly outperforms VSR-LKH by large margins in all the settings of our experiments on testing instances following the training distributions, especially when the time limits are short. Even more impressively, NeuroLKH achieves performance similar to VSR-LKH on traditional benchmark TSPLIB [27] with various node distributions, which are very different from the training distributions for NeuroLKH.
+
+![](images/555bfa4b7f83d8522db3438f8d66631afa6d835d18cf03d7b3f9e3f1e25fe8dc.jpg)  
+Figure 1: NeuroLKH algorithm and the original LKH algorithm.
+
+# 3 Preliminaries: LKH algorithm
+
+The Lin-Kernighan-Helsgaun (LKH) algorithm [12, 13] is a local optimization algorithm developed based on the $\lambda$ -opt move [24], where $\lambda$ edges in the current tour are exchanged by another set of $\lambda$ edges to achieve a shorter tour. While solving one instance, the LKH algorithm can conduct multiple trials to find better solutions. In each trial, starting from a randomly initialized tour, it iteratively searches for $\lambda$ -opt exchanges that improve the tour, until no such exchanges can be found. In each iteration, the $\lambda$ -opt exchanges are searched in the ascending order of variable $\lambda$ and the tour will be replaced once an exchange is found to reduce the tour distance.
+
+One central rule is that the $\lambda$ -opt searching process is restricted and directed by an edge candidate set, which is created before search based on the $\alpha$ -measure using sensitivity analysis of the Minimum Spanning Tree. Here we briefly introduce the related concepts. A TSP graph can be viewed as an undirected graph $G = ( V , E )$ with $V$ as the set of $| V |$ nodes and $E$ as the set of edges weighted by distances. A spanning tree of $G$ is a connected graph with $| V | - 1$ edges from $G$ and no cycles where any pair of nodes is connected by a path. A 1-tree of $G$ is a spanning tree for the graph of node set $V \backslash \{ 1 \}$ } combined with two edges in $E$ connected to node 1, an arbitrary special node in $V$ . A minimum 1-tree is the 1-tree with minimum length. The $\alpha$ -measure of an edge $( i , j ) \in E$ for graph $G$ is defined as $\alpha ( i , j ) = \mathbb { L } ( T ^ { + } ( i , j ) ) - \mathbb { L } ( T )$ , where $\mathbb { L } ( T )$ is the length of Minimum 1-Tree $T$ and $\mathbb { L } ( T ^ { + } ( i , j ) )$ is the length of Minimum 1-Tree $T ^ { + } ( i , j )$ required to include the edge $( i , j )$ . The $\alpha$ -measure of an edge can be viewed as the extra length of the Minimum 1-Tree to include this edge.
+
+The edge candidate set consists of the $k$ edges with the smallest $\alpha$ -measures connected to each node $k = 5$ as default). During the $\lambda$ -opt searching process, the edges to be included into the new tour are limited to the edges in this candidate set, and edges with smaller $\alpha$ -measures will have higher priorities to be searched over. Therefore this candidate set not only restricts but also directs the search.
+
+Moreover, the quality of $\alpha$ -measures can be improved significantly by a subgradient optimization method. If we add a penalty $\pi _ { i }$ to each node $i$ and transform the original distance $s _ { i , j }$ of the edge $( i , j )$ to a new distance $c _ { i , j }$ as $c _ { i , j } = s _ { i , j } + \pi _ { i } + \pi _ { j }$ , the optimal tour for the TSP will stay the same but the Minimum 1-Tree usually will change. Because by definition, a Minimum 1-Tree with node degrees all equal to 2 is an optimal solution for the corresponding TSP instance. With the length of Minimum 1-Tree resulting from the penalty $\pi = ( \pi _ { 1 } , . . . , \pi _ { | V | } )$ as $\mathsf { \bar { L } } ( T _ { \pi } )$ , $w ( \pi ) = \mathbb { L } ( T _ { \pi } ) - 2 \bar { \Sigma _ { i } } \pi _ { i }$ is a lower bound of the optimal tour distance for the original TSP instance. LKH applies subgradient optimization [11] to iteratively maximize this lower bound for multiple steps until convergence by applying $\pi ^ { \tau + 1 } = \pi ^ { \tau } + t ^ { \tau } ( d ^ { \tau } - 2 )$ at step $\tau$ , where $t ^ { \tau }$ is the scalar step size, $d ^ { \tau }$ is the vector of node degrees in the Minimum 1-Tree with penalty $\pi ^ { \tau }$ . Therefore, the node degrees are pushed towards 2. The $\alpha$ -measures after this optimization will substantially improve the quality of edge candidate set. Furthermore, the transformed edge distance $c _ { i , j }$ after this optimization helps find better solutions when used during the searching process for $\lambda$ -opt exchanges.
+
+# 4 The proposed NeuroLKH algorithm
+
+The subgradient optimization in LKH can substantially improve the quality of edge candidate sets based on the $\alpha$ -measures, and transform the edge distances effectively to achieve reasonably good performance. However, it still has major limitations as the optimization process is over one instance iteratively until convergence, which costs a large amount of time, especially for large-scale problems. Moreover, even after subgradient optimization, some critical patterns could be missed by the relatively straightforward sensitivity analysis of spanning tree. Therefore, the quality of edge candidate set could be further improved by large margins, which will in turn improve the overall performance.
+
+We propose the NeuroLKH algorithm, which employs a Sparse Graph Network to learn the complex patterns associated with the TSP instances generated from a distribution. Concretely, the network will learn the edge scores and node penalties simultaneously with a multi-task training process. The edge scores are trained with supervised learning for creating the edge candidate set, while the node penalties are trained with unsupervised learning for transforming the edge distances. The architecture of NeuroLKH is presented in Figure 1, along with the original LKH algorithm. We will detail the Sparse Graph Network, the training process and the proposed NeuroLKH algorithm in the following.
+
+# 4.1 Sparse Graph Network
+
+For the Sparse Graph Network (SGN), we format the TSP instance as a sparse directed graph $G ^ { * } = ( V , E ^ { * } )$ containing the node set $V$ and a sparse edge set $E ^ { * }$ which only includes the $\gamma$ shortest edges pointed from each node, as shown in the leftmost green box in Figure 1, where the circles represent the nodes and the diamonds represent the directed edges. Sparsification of the graph is crucial for effectively training the deep learning model on large TSP instances and generalizing to even larger sizes. Note that edge $( i , j )$ belongs to $E ^ { * }$ does not necessarily mean that the oppositedirection edge $( j , i )$ belongs to $E ^ { * }$ . The node inputs $x _ { v } \in \mathbb { R } ^ { 2 }$ are the node coordinates and the edge inputs $x _ { e } \in \mathbb { R }$ are the edge distances. Though we focus on 2-dimensional TSP with Euclidean distance as the other deep learning literature like [21], the model can be applied to other kinds of TSP.
+
+The SGN consists of 1) one encoder embedding the edge and node inputs into the corresponding feature vectors, and 2) two decoders for the edge scores and node penalties, respectively.
+
+Encoder. The encoder first linearly projects the node inputs and the edge inputs into feature vectors $v _ { i } ^ { 0 } \in \mathbb { R } ^ { D }$ and $e _ { i , j } ^ { 0 } \in \mathbb { R } ^ { j }$ , respectively, where $D$ is the feature dimension, $i \in V$ and $( i , j ) \in E ^ { * }$ . Then the node and edge features are embedded with $L$ Sparse Graph Convolutional Layers, which are defined formally as follows:
+
+$$
+\begin{array} { c l } { { a t t n _ { i , j } ^ { \iota } = e x p ( W _ { a } ^ { \iota } e _ { i , j } ^ { { \iota - 1 } } ) \oslash \displaystyle \sum _ { ( i , m ) \in E * } e x p ( W _ { a } ^ { \iota } e _ { i , m } ^ { { \iota - 1 } } ) , } } \\ { { \strut } } \\ { { \displaystyle v _ { i } ^ { l } = v _ { i } ^ { l - 1 } + R e L U ( B N ( W _ { s } ^ { \iota } v _ { i } ^ { { \iota - 1 } } + \sum _ { ( i , j ) \in E ^ { * } } a t t n _ { i , j } ^ { \iota } \odot W _ { n } ^ { \iota } v _ { j } ^ { { \iota - 1 } } ) ) , } } \\ { { \strut } } \\ { { \strut } } \\ { { \displaystyle r _ { i , j } ^ { l } = \left\{ W _ { \iota } ^ { l } e _ { j , i } ^ { { \iota - 1 } } , \begin{array} { l l } { { \mathrm { i f ~ } ( j , i ) \in E ^ { * } } } \\ { { W _ { \iota } ^ { \iota } p ^ { l } , } } \end{array} \right. } } & { { \mathrm { o t h e r w i s e } } } \end{array}
+$$
+
+$$
+e _ { i , j } ^ { l } = e _ { i , j } ^ { l - 1 } + R e L U ( B N ( W _ { f } ^ { l } v _ { i } ^ { l - 1 } + W _ { t } ^ { l } v _ { j } ^ { l - 1 } + W _ { o } ^ { l } e _ { i , j } ^ { l - 1 } + r _ { i , j } ^ { l } ) ) ,
+$$
+
+where $\odot$ and $\oslash$ represent the element-wise multiplication and the element-wise division, respectively; $l = 1 , 2 , . . . , L$ is the layer index; $W _ { a } ^ { l } , W _ { s } ^ { l } , W _ { n } ^ { l } , \dot { W } _ { r } ^ { l } , W _ { f } ^ { l } , W _ { t } ^ { l } , W _ { o } ^ { l } \in \mathbb { R } ^ { D \times D }$ and $p ^ { l } \in \mathbb { R } ^ { D }$ are trainable parameters; Eqs. (2) and (4) consist of a Skip-Connection layer [10] and a Batch Normalization layer [17] in each; and the idea of element-wise attention in Eq. (1) is adopted from [3]. As the input graph $G ^ { * }$ is directed and sparse, edges with different directions are embedded separately. But obviously the embedding of an edge $( i , j )$ should benefit from knowing whether its opposite-direction counterpart $( j , i )$ is also in the graph and the information of $( j , i )$ , which motivates our design of Eqs. (3) and (4).
+
+Decoders. The edge decoder takes the edge embeddings $e _ { i , j } ^ { L }$ from the encoder and embeds them with two layers of linear projection followed by ReLU activation into efi,j . Then the edge scores $\beta _ { i , j }$ are calculated as follows:
+
+$$
+\beta _ { i , j } = \frac { e x p ( W _ { \beta } e _ { i , j } ^ { f } ) } { \sum _ { ( i , m ) \in E ^ { * } } e x p ( W _ { \beta } e _ { i , m } ^ { f } ) } ,
+$$
+
+Algorithm 1 NeuroLKH Algorithm   
+
+<table><tr><td>Input: TSP instance,number of trials K Output: TSP solution BestTour</td></tr><tr><td></td></tr><tr><td>1: Convert the TSP instance to SGN input G*,xu, xe</td></tr><tr><td>2: Calculate the edge scores βi,j and the node penalties Ti with Eqs. (5) and (6)</td></tr><tr><td>3: EdgeDistance=TransformEdgeDistance(π)</td></tr><tr><td></td></tr><tr><td>4: EdgeCandidateSet=CreateEdgeCandidateSet(β) 5: BestTour=LKHSearchingTrials(EdgeDistance,EdgeCandidateSet,K)</td></tr></table>
+
+Similarly, the node decoder first embeds the node embeddings $v _ { i } ^ { L }$ with two layers of linear projection and ReLU activation into $v _ { i } ^ { f }$ . Then the node penalties $\pi _ { i }$ are calculated as follows:
+
+$$
+\pi _ { i } = C \operatorname { t a n h } ( W _ { \pi } v _ { i } ^ { f } ) ,
+$$
+
+where $W _ { \beta }$ ${ \sf \Psi } _ { 3 } , W _ { \pi } \in \mathbb { R } ^ { D \times 1 }$ are trainable parameters; $C = 1 0$ is used to keep the node penalties in the range of $[ - 1 0 , 1 0 ]$ .
+
+# 4.2 Training process
+
+We train the network to learn the edge scores with supervised learning. And the edge loss $\mathcal { L } _ { \beta }$ is detailed as follows:
+
+$$
+\mathcal { L } _ { \beta } = - \frac { 1 } { \gamma | V | } \sum _ { ( i , j ) \in E ^ { * } } ( \mathbb { 1 } \{ ( i , j ) \in E _ { o } ^ { * } \} \log \beta _ { i , j } + \mathbb { 1 } \{ ( i , j ) \notin E _ { o } ^ { * } \} \log ( 1 - \beta _ { i , j } ) ) ,
+$$
+
+where $E _ { o } ^ { * } = \{ ( i , j ) \in E ^ { * } | ( i , j )$ in the optimal tour}. Effectively, we increase the edge scores $\beta _ { i , j }$ if the edge $( i , j )$ belongs to the optimal tour and decrease them otherwise.
+
+The node penalties are trained by unsupervised learning. Similar to the goal of subgradient optimization in LKH, we are trying to transform the Minimum 1-Tree generated from the TSP graph $G$ closer to a tour where all nodes have a degree of 2. An important distinction from LKH is that we are learning the patterns for a class of TSP instances following a distribution, instead of optimizing the penalties for a specific TSP instance. The node loss ${ \mathcal { L } } _ { \pi }$ is detailed as follows:
+
+$$
+\mathcal { L } _ { \pi } = - \frac { 1 } { \vert V \vert } \sum _ { i \in V } ( d _ { i } ( \pi ) - 2 ) \pi _ { i } ,
+$$
+
+where $d _ { i } ( \pi )$ is the degree of node $i$ in the Minimum 1-Tree $T _ { \pi }$ induced with penalty $\pi = ( \pi _ { 1 } , . . . , \pi _ { | V | } )$ The penalties are increased for nodes with degrees larger than 2 and decreased for nodes with smaller degrees. The SGN is trained for the task of outputting the edge scores and node penalties simultaneously with the loss function $\mathcal { L } = \mathcal { L } _ { \beta } + \eta _ { \pi } \mathcal { L } _ { \pi }$ , where $\eta _ { \pi }$ is the coefficient for balancing the two losses.
+
+# 4.3 NeuroLKH algorithm
+
+The process of using NeuroLKH to solve one instance is shown in Algorithm 1. Firstly, the TSP instance is converted to a sparse directed graph $G ^ { * }$ . Then the SGN encoder embeds the nodes and edges in $G ^ { * }$ into feature embeddings, based on which the decoders output the node penalties $\pi$ and edge scores $\beta$ . Afterwards, NeuroLKH creates powerful edge candidate set and transforms the distance of each edge effectively, which further guides NeuroLKH to conduct multiple LKH trials to find good solutions. We detail each part as follows.
+
+Transform Edge Distance. Based on the node penalties $\pi _ { i }$ , the original edge distances $s _ { i , j }$ are transformed into new distances $c _ { i , j } = s _ { i , j } + \pi _ { i } + \pi _ { j }$ , which will be used in the search process. With such a transformation, the optimal solution tour will stay the same. And the tour distance calculated with the transformed edge distances will be subtracted by $2 \sum _ { i \in V } \pi _ { i }$ to restore the tour distance for the original TSP.
+
+Create Edge Candidate Set. For each node $i \in V$ , the edge scores $\beta _ { i , j }$ are sorted for $( i , j ) \in E ^ { * }$ and the edges with the top- $k$ largest scores are included in the edge candidate set. Edges with larger scores have higher priorities in the candidate set, which will be tried first for adding in the exchange during the LKH search process. Note that neither the original LKH nor NeuroLKH can guarantee all the edges in the optimal tour to be included in the edge candidate set. However, optimal solutions are still likely to be found during the multiple trials.
+
+LKH Searching Trials. To solve one TSP instance, LKH conducts multiple trials to find better solutions. In each trial, one tour is initialized randomly, and iterations of LKH search are conducted for the $\lambda$ -opt exchanges until the tour can no longer be improved by such exchanges. In each iteration, LKH searches in the ascending order of $\lambda$ for $\lambda$ -opt exchanges to reduce tour length, which will be applied once found.
+
+Based on the trained SGN network, NeuroLKH infers the edge distance transformation and candidate set to guide the LKH trials, which is done by performing forward calculation through the model. This is much faster than the corresponding procedure in the original LKH, which employs subgradient optimization on each instance iteratively until convergence and is apparently time-consuming especially for large-scale problems. More importantly, rather than using the hand-crafted rules based on sensitivity analysis in the original LKH, NeuroLKH learns to create edge candidate set of much higher quality with the powerful deep model, leading to significantly better performance.
+
+# 5 Experiments
+
+In this section, we conduct extensive experiments on TSP with various sizes and show the effective performance of NeuroLKH compared to the baseline algorithms. Our code is publicly available.1
+
+Dataset distribution. Closely following the existing works such as [21], we experiment with the 2-dimensional TSP instances in the Euclidean distance space where both coordinates of each node are generated independently from a unit uniform distribution. We train only one network using TSP instances ranging from 101 to 500 nodes. Since the amount of supervision and feedback during training is linearly related to the number of nodes. We generate $\bar { 5 } 0 0 0 0 0 0 / | V |$ instances for each size $| V |$ in the training dataset, resulting in approximately 780000 instances in total. Therefore the amounts of supervision and feedback are kept similar across different sizes. We use Concorde 2 to get the optimal edges $E _ { o } ^ { * }$ for the supervised training of edge scores. For testing, we generate 1000 instances for each testing problem size.
+
+Hyperparameters. We choose the number of directed edges pointed from one node in the sparse edge set $E ^ { * }$ as $\gamma = 2 0$ , which results in only $0 . 0 1 \%$ of the edges in the optimal tours missed in $E ^ { * }$ for the training dataset. We also conduct experiments to justify this choice in Appendix Section A. The hidden dimension is set to $D = 1 2 8$ in the network with $L = 3 0$ Sparse Graph Convolutional Layers. The node penalty coefficient in the loss function is $\eta _ { \pi } = 1$ . The network is trained by Adam Optimizer [19] with learning rate of 0.0001 for 16 epochs, which takes approximately 4 days. The deep learning models are trained and evaluated with one RTX-2080Ti GPU. The other parts of experiments without deep models for NeuroLKH and other baselines are conducted with random seed 1234 on an Intel(R) Core(TM) i9-10940X CPU unless stated otherwise. Hyperparameters for the LKH searching process are consistent with the example script for TSP given by LKH available online 3 and those used in [36].
+
+# 5.1 Comparative study on TSP
+
+Here, we compare NeuroLKH with the original LKH algorithm [13] and the recently proposed VSR-LKH algorithm [36]. We do not compare with other deep learning based methods here because their performances are rather inferior to LKH, and most of them can hardly generalize to problems with more than 100 nodes. One exception is the method in [8], which is tested on large problems but the performances are still far worse than LKH.
+
+All algorithms are run once for each testing instance as we find running multiple times only provides very marginal improvement. For each testing problem size, we run the original LKH for 1, 10, 100, and 1000 trials, and record the total amounts of time in solving the 1000 instances. Then we impose the same amounts of time as time limits to NeuroLKH and VSR-LKH for solving the same 1000 instances for fair comparison. Note that for NeuroLKH, the solving time is the summation of the inference time of SGN on GPU and LKH searching time on CPU. In the following tables, for each size and time limit, we report the average performance (tour distance) and the total solving time for the 1000 testing instances.
+
+Table 1: Comparative results on training sizes   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Time(s)</td><td colspan="2">|V|=100</td><td rowspan="2">Time(s)</td><td colspan="2">|V|= 200</td><td rowspan="2"></td><td colspan="2">|V|= 500</td><td rowspan="2">Gap(%oo)</td></tr><tr><td>Obj</td><td>Gap(%oo)</td><td></td><td>Obj Gap(%oo)</td><td>Time(s)</td><td>Obj</td></tr><tr><td>Concorde</td><td>207</td><td>*7.753246</td><td>0.000</td><td>1072</td><td></td><td>*10.701303</td><td>0.000</td><td>17022</td><td>*16.541830</td><td>0.000</td></tr><tr><td rowspan="3">LKH (1 trial) VSR-LKH</td><td rowspan="3">33</td><td>7.755071</td><td>2.353</td><td rowspan="3"></td><td>10.707043</td><td></td><td rowspan="3"></td><td></td><td></td><td>9.009</td></tr><tr><td>7.754980</td><td>2.236</td><td>80</td><td>10.706739</td><td>5.364 5.080</td><td>16.556733 16.557297</td><td>9.350</td></tr><tr><td>7.753332</td><td>0.111</td><td>10.701873</td><td></td><td>338</td><td>16.543197</td><td>0.826</td></tr><tr><td rowspan="3">NeuroLKH LKH (10 trials) VSR-LKH</td><td rowspan="3">43</td><td></td><td></td><td></td><td></td><td>0.533</td><td></td><td></td><td></td><td></td></tr><tr><td>7.754177</td><td>1.200</td><td>111</td><td>10.703724</td><td></td><td>2.263</td><td>445</td><td>16.548017</td><td>3.740</td></tr><tr><td>7.754184 7.753311</td><td>1.209 0.083</td><td></td><td>10.703997 10.701623</td><td>2.518</td><td></td><td></td><td>16.549591 16.542880</td><td>4.692 0.634</td></tr><tr><td rowspan="2">NeuroLKH LKH (100 trials) VSR-LKH</td><td rowspan="2">127</td><td></td><td>0.263</td><td></td><td></td><td></td><td>0.299 0.423</td><td></td><td></td><td></td></tr><tr><td>7.753450 7.753407</td><td>0.207</td><td>368</td><td>10.701755 10.701687</td><td></td><td>0.359</td><td>1147</td><td>16.543707 16.543085</td><td>1.134 0.759</td></tr><tr><td rowspan="2">NeuroLKH LKH (1000 trials)</td><td rowspan="2"></td><td>7.753270</td><td>0.030</td><td></td><td></td><td>10.701381</td><td>0.073</td><td></td><td>16.542163</td><td>0.201</td></tr><tr><td></td><td></td><td></td><td>10.701351</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td rowspan="2">VSR-LKH NeuroLKH</td><td rowspan="2">938</td><td>7.753254</td><td>0.010 0.097</td><td>2805</td><td></td><td>10.701336</td><td>0.045 0.031</td><td>7527</td><td>16.542125 16.541934</td><td>0.178</td></tr><tr><td>7.753322 7.753247</td><td>0.000</td><td></td><td>10.701303</td><td></td><td>0.000</td><td></td><td>16.541847</td><td>0.063 0.010</td></tr></table>
+
+Comparison on training sizes. In Table 1, we report the performances of LKH, VSR-LKH and NeuroLKH on three testing datasets with 100, 200 and 500 nodes, which are within the size range of instances used in training. Note that we train only one SGN Network on a wide range of problem sizes and here we use these three sizes to demonstrate the testing performances. We also use the exact solver Concorde on these instances to obtain the optimal solutions and compute the optimality gap for each method. As shown in this table, it is clear that NeuroLKH outperforms both LKH and VSR-LKH significantly and consistently across different problem sizes and with different time limits. Notably, the optimality gaps are reduced by at least an order of magnitude for most of the cases, which is a significant improvement.
+
+Generalization analysis on larger sizes. We further show the generalization ability of NeuroLKH on much larger graph sizes of 1000, 2000 and 5000 nodes. Note that while the edge scores in SGN generalize well without any modification, it is hard for the node penalties to directly generalize. This is because they are trained unsupervisedly and SGN does not have any knowledge about how to penalize the nodes for larger TSP instances. Nevertheless, this could be resolved by a simple fine-tuning step. As the learned node embeddings are very powerful, we only fine-tune the very small amount of parameters in the SGN node decoder and keep the other parameters fixed. Specifically, for each of the large sizes, we fine-tune the node decoder for 100 iterations with batch size of $5 0 0 0 / | V |$ , which only takes less than one minute for each size of 1000, 2000 and 5000. This fast fine-tuning process is for TSPs of one size generated from the distribution instead of specific instances, and may be viewed as adjusting the scale of penalties for large sizes. The generalization results are summarized in Table 2. Note that we do not run Concorde here due to the prohibitively long running time, and the gaps are with respect to the best value found by all methods. Clearly, NeuroLKH generalizes well to substantially larger problem sizes and the improvement of NeuroLKH over baselines is significant and consistent across all the settings.
+
+Further discussion. The inference time of SGN in NeuroLKH for the 1000 instances of 100, 200, 500, 1000, 2000 and 5000 nodes is 3s, 6s, 16s, 33s, 63s and 208s, which is approximately linear with the number of nodes $| V |$ . In contrast, the subgradient optimization in LKH and VSR-LKH needs 20s, 51s, 266s, 1028s, 4501s and 38970s, which grows superlinearly with $| V |$ and is much longer than SGN inference, especially for large-scale problems. For NeuroLKH, the saved time is used to conduct more trials, which effectively helps to find better solutions. This effect is more salient with short time limit. Meanwhile, the number of trials is also small for short time limit and the algorithm only searches a small number of solutions, in which case the guidance of edge candidate set is more important. Due to these two reasons, the improvement of NeuroLKH over baselines is particularly substantial for short time limit. This is a desirable property especially for time-critical applications and solving large-scale problems, for which large numbers of trials are not feasible.
+
+Table 2: Comparative results on generalization sizes   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Time(s)</td><td colspan="2">|V|= 1000 Obj</td><td colspan="3">IV|= 2000</td><td colspan="3">IV|= 5000</td></tr><tr><td></td><td>Gap(%00)</td><td>Time(s)</td><td>Obj</td><td>Gap(%o0)</td><td>Time(s)</td><td>Obj</td><td>Gap(%0)</td></tr><tr><td>LKH(1 trial)</td><td rowspan="2">1183</td><td>23.155916</td><td>10.593</td><td rowspan="2">4843</td><td>32.483851</td><td>11.264</td><td rowspan="2">40048</td><td>51.025519</td><td>12.284</td></tr><tr><td>VSR-LKH</td><td>23.154946</td><td>10.173</td><td>32.485551</td><td>11.788</td><td>51.025539</td><td>12.288</td></tr><tr><td rowspan="2">NeuroLKH LKH(10 trials)</td><td rowspan="2"></td><td>23.133494</td><td>0.899</td><td rowspan="2"></td><td>32.449752</td><td>0.755</td><td rowspan="2"></td><td>50.965382</td><td>0.484</td></tr><tr><td>23.143435</td><td>5.197</td><td>32.466953</td><td>6.056</td><td>50.998721</td><td>7.026</td></tr><tr><td rowspan="2">VSR-LKH NeuroLKH</td><td rowspan="2">1414</td><td>23.143347</td><td>5.159</td><td rowspan="2">5322</td><td>32.467997</td><td>6.377</td><td rowspan="2">41523</td><td>51.000093</td><td>7.295</td></tr><tr><td>23.133066</td><td>0.714</td><td>32.449519</td><td>0.683</td><td>50.965219</td><td>0.452</td></tr><tr><td rowspan="2">LKH(100 trials)</td><td rowspan="2">2567</td><td>23.135427</td><td>1.735</td><td rowspan="2"></td><td>32.455454</td><td>2.512</td><td rowspan="2"></td><td>50.976677</td><td>2.700</td></tr><tr><td>23.134426</td><td>1.302</td><td>32.454427</td><td>2.195</td><td>50.979317</td><td>3.218</td></tr><tr><td rowspan="2">VSR-LKH NeuroLKH</td><td rowspan="2"></td><td>23.132258</td><td>0.365</td><td rowspan="2">7371</td><td>32.448666</td><td>0.420</td><td rowspan="2">47884</td><td>50.964677</td><td>0.345</td></tr><tr><td>23.132216</td><td>0.347</td><td></td><td>0.509</td><td></td><td>0.455</td></tr><tr><td rowspan="2">LKH(1000 trials) VSR-LKH</td><td rowspan="2">12884</td><td>23.131658</td><td>0.105</td><td rowspan="2">25613</td><td>32.448954 32.447953</td><td>0.200</td><td rowspan="2">103885</td><td>50.965233 50.965300</td><td>0.468</td></tr><tr><td>23.131414</td><td>0.000</td><td>32.447304</td><td>0.000</td><td>50.962916</td><td>0.000</td></tr></table>
+
+In Figure 2, we plot the performance of the LKH, VSR-LKH and NeuroLKH algorithms for solving the testing datasets with different numbers of nodes against different running time to visualize the improvement process (the resulting objective values after each trial). The time limits are set to the longest ones used in Table 1 and Table 2, which are the running time of LKH with 1000 trials. Clearly, NeuroLKH outperforms both LKH and VSR-LKH significantly and consistently across different problem sizes and with different time limits. In particular, NeuroLKH is superior as it not only reaches good solutions fast but also converges to better solutions eventually. With the same performance (i.e. objective value), NeuroLKH considerably reduces the computational time. We can also conclude that when the time limit is short, the improvement of NeuroLKH over baselines is particularly substantial. In addition, we show that the subgradient optimization is necessary for LKH and VSR-LKH. As exhibited in Figure 2, the performances of both LKH and VSR-LKH are much worse without subgradient optimization (w/o SO). More impressively, even ignoring the preprocessing time (IPT) used for subgradient optimization (pertaining to LKH and VSR-LKH) and Sparse Graph Network inferring (pertaining to NeuroLKH), NeuroLKH still outstrips both LKH and VSR-LKH. Note that this comparison is unfair for NeuroLKH as LKH and VSR-LKH consume much longer preprocessing time which is unavoidable.
+
+For the results reported in Table 1 and Table 2, almost all the improvements of NeuroLKH over LKH and VSR-LKH on different sizes and with different time limits are statistically significant with confidence levels larger than $9 9 \%$ . The only one exception is the performance on TSP with 100 nodes and the running time of LKH with 1000 trials where the confidence levels are $9 0 . 5 \%$ and $9 7 . 6 \%$ for the improvements, respectively.
+
+In the Appendix Section A, we also show that NeuroLKH substantially outperforms other deep learning based methods [21, 20, 33, 18, 15, 8, 22, 5].
+
+Generalization to TSPLIB benchmark. Besides generalization to larger sizes, generalization to different distributions remains a crucial challenge for deep learning based methods in existing works. The TSPLIB benchmark contains instances with various node distributions, making it extremely hard for such methods. We test on all the 72 TSPLIB instances with Euclidean distances and less than 10000 nodes. The number of trials is set to be the number of nodes and the algorithms are run 10 times for each instance following the convention for TSPLIB in [12, 36]. With the various unknown node distributions, we do not fine-tune the model for the node penalties and only use the edge scores in NeuroLKH. For the 24 instances labeled as hard in [36], which the original LKH fails to solve optimally during at least one of the 10 runs, NeuroLKH trained with uniformly distributed data is able to find optimal solutions 6.13 times on average, which is much better than LKH (3.75 times). As an active learning method, VSR-LKH finds optimal solutions 6.42 times on average, slightly better than NeuroLKH. While NeuroLKH improves the results on most hard instances, it could generalize poorly on instances with certain special patterns such as where most nodes are located along several horizontal lines, making it fail to solve 11 of the 48 easy instances optimally for some runs.
+
+With the same training dataset size, we trained another model NeuroLKH_M using a mixture of instances with uniformly distributed nodes, clustered nodes with 3-8 clusters, half uniform and half clustered nodes following [30]. NeuroLKH_M finds optimal solutions 6.79 times on average for the hard instances and fails to solve only 5 easy instances optimally for some runs, better than the
+
+![](images/273c9892f25b4866fa915d42faa86aa3e755594fcc67dba61133d0c46158bd97.jpg)  
+Figure 2: Performances of LKH, VSR-LKH and NeuroLKH for solving TSP with different sizes against different running time
+
+NeuroLKH trained with only uniformly distributed instances. For all the 72 instances, NeuroLKH_M finds optimal solutions 8.74 times on average, which is much better than LKH (7.92 times) but slightly worse than VSR-LKH (8.78 times). Detailed results of each instance are listed in the Appendix Section B.
+
+# 5.2 Experiments on other routing problems
+
+Finally, we show that NeuroLKH can be easily extended to solve much more complicated routing problems such as the Capacitated Vehicle Routing Problem (CVRP), the Pickup and Delivery Problem (PDP) and CVRP with Time Windows (CVRPTW). We briefly introduce the problems in the Appendix Section C. Different from TSP, the node penalties do not apply to these problems. Therefore, NeuroLKH only learns the edge candidate set. As these three problems are very hard to solve and the optimal solutions are not available in a reasonable amount of time, we use LKH with 10000 trials to get solutions as training labels. The demands, capacities, starts and ends in the time windows are taken as node inputs along with the coordinates. For PDP, we add connections between each pair of pickup and delivery nodes and assign weight matrices for these connections in Eq. (2). For PDP and CVRPTW, the edge directions affect the tour feasibility therefore the model learns the in-direction edge scores and out-direction edge scores for each node with Eq. (5).
+
+The node coordinates are also generated uniformly from the unit square for all three problems, following [21, 23]. For CVRP, the demands of customers are generated uniformly from integers $\{ 1 . . 9 \}$ with the capacity fixed as $4 0 + 0 . 1 \times | V |$ , compatible with the largest CVRP (100 nodes) studied in [21]. For CVRPTW, we use the same way to generate demands, capacity, serving time and time windows as [7]. A training dataset for CVRP with 101-500 nodes and $1 2 0 0 0 0 / | V |$ instances for each size (about 180000 in total) is used to train the SGN for 10 epochs. PDP and CVRPTW are harder to solve therefore we use a training dataset with 41-200 nodes and $2 4 0 0 0 0 / | V |$ instances for each size. The other hyperparameters in SGN are the same as TSP and those for LKH searching process are consistent with example scripts given by LKH for CVRP, PDP and CVRPTW (with the SPECIAL hyperparameter).
+
+In Table 3, we show the performance of NeuroLKH and the original LKH on testing datasets with 1000 instances for the smallest and largest graph sizes (number of customers) used in training as well as a much larger generalization size. We use the solving time of LKH with 100, 1000, 10000 trials as the time limits. For 100 trials, both methods fail to find feasible solutions for less than $1 \%$ of the PDP and CVRPTW test instances with 300 nodes. Whenever this happens, we push the infeasible visits to the end to get feasible solutions. The inferring time of SGN is 1s, 3s, 7s, 10s, 19s and 40s in total for the 1000 instances in the testing datasets with 40, 100, 200, 300, 500 and 1000 nodes, which is a tiny fraction compared to the LKH searching process. As shown in Table 3, NeuroLKH significantly improves the solution quality compared with the original LKH which is a very strong heuristic solver for all three problems, showing its potential in handling various types of routing problems.
+
+Table 3: Comparative results for other routing problems   
+
+<table><tr><td>Method</td><td></td><td>Time(s)</td><td>Obj</td><td>Gap(%)</td><td>Time(s)</td><td>Obj</td><td>Gap(%)</td><td>Time(s)</td><td>Obj</td><td>Gap(%)</td></tr><tr><td rowspan="5">GRRP</td><td></td><td></td><td>|V|= 100</td><td></td><td></td><td>|V|= 500</td><td></td><td>Generalization |V|</td><td></td><td>=1000</td></tr><tr><td>LKH (100 trials) NeuroLKH</td><td>485</td><td>15.8363 15.7770</td><td>1.675 1.295</td><td>2043</td><td>42.1621 41.7311</td><td>5.394 4.316</td><td>4607</td><td>58.1372 56.6469</td><td>9.750 6.937</td></tr><tr><td>LKH (1000 trials) NeuroLKH</td><td>4520</td><td>15.6483 15.6295</td><td>0.468 0.348</td><td>15812</td><td>40.6103 40.4974</td><td>1.515 1.233</td><td>30133</td><td>54.3412 54.0499</td><td>2.584 2.034</td></tr><tr><td>LKH(10000 trials) NeuroLKH</td><td>45435</td><td>15.5823 15.5754</td><td>0.044 0.000</td><td>166875</td><td>40.0670 40.0043</td><td>0.157 0.000</td><td>319368</td><td>53.1093 52.9723</td><td>0.259 0.000</td></tr><tr><td>LKH (100 trials)</td><td></td><td>|V|= 40</td><td></td><td></td><td>|V|= 200</td><td></td><td>Generalization |V|</td><td></td><td>=300</td></tr><tr><td rowspan="3">P</td><td>NeuroLKH</td><td>115</td><td>6.2495 6.2241</td><td>0.819 0.409</td><td>2832</td><td>13.8390 13.6246</td><td>5.535 3.899</td><td>7939</td><td>17.0913 16.7867</td><td>6.916 5.011</td></tr><tr><td>LKH(1000 trials) NeuroLKH</td><td>845</td><td>6.2088 6.2041</td><td>0.163 0.087</td><td>21216</td><td>13.2850 13.2443</td><td>1.310 0.999</td><td>55643</td><td>16.2447 16.1857</td><td>1.620 1.251</td></tr><tr><td>LKH(10000 trials) NeuroLKH</td><td>7989</td><td>6.1998 6.1988</td><td>0.018 0.000</td><td>195220</td><td>13.1387 13.1132</td><td>0.194 0.000</td><td>515377</td><td>16.0119 15.9857</td><td>0.163 0.000</td></tr><tr><td rowspan="5">CIPRRA</td><td></td><td>一</td><td>|V|= 40</td><td></td><td></td><td>|V|= 200</td><td></td><td>Generalization |V|</td><td></td><td>=300</td></tr><tr><td>LKH(100 trials) NeuroLKH</td><td>147</td><td>9.3051 9.2606</td><td>1.081 0.597</td><td>813</td><td>26.1757 25.4000</td><td>7.124 3.949</td><td>1746</td><td>34.2301 32.9676</td><td>8.798 4.786</td></tr><tr><td>LKH(1000 trials) NeuroLKH</td><td>1017</td><td>9.2276 9.2207</td><td>0.239 0.164</td><td>4525</td><td>24.9770 24.7857</td><td>2.218 1.435</td><td>7820</td><td>32.2671 32.0224</td><td>2.559 1.781</td></tr><tr><td>LKH(10000 rials) NeuroLKH</td><td>9624</td><td>9.2073 9.2056</td><td>0.018 0.000</td><td>45509</td><td>24.5338 24.4350</td><td>0.405 0.000</td><td>75481</td><td>31.5719 31.4620</td><td>0.350 0.000</td></tr></table>
+
+Performance on traditional benchmarks. To show the effectiveness of NeuroLKH on complicated routing problems with various distributions, we perform experiments on CVRPLIB [30] and Solomon [28] benchmark datasets. CVRPLIB [30] contains various sized CVRP instances with a combination of 3 depot positioning, 3 customer positioning and 7 demand distributions. Solomon benchmark [28] contains CVRPTW instances with 100 customers and various distributions of time windows. We detail the benchmarks, the training datasets and the results for each instance in the Appendix Section D. In summary, tested on the 43 instances with 100-300 nodes in CVRPLIB [30], NeuroLKH improves the average performances on 38, 38 and 31 instances when the time limits are set to the time of LKH with 100, 1000 and 10000 trials, respectively. On the 11 Solomon R2-type instances, NeuroLKH outperforms LKH almost consistently with all the settings (32 out of the 33).
+
+# 6 Conclusion
+
+In this paper, we propose an algorithm utilizing the great power of deep learning models to combine with a strong heuristic for TSP. Specifically, one Sparse Graph Network is trained to predict the edge scores and the node penalties for generating the edge candidate set and transforming the edge distances, respectively. As shown in the extensive experiments, the improvement of NeuroLKH over baseline algorithms within different time limits is consistent and significant. And NeuroLKH generalizes well to instances with much larger graph sizes than training sizes and traditional benchmarks with various node distributions. Also, we use CVRP, PDP and CVRPTW to demonstrate that NeuroLKH effectively applies to other routing problems. NeuroLKH can effectively learn the routing patterns for TSP which generalize well to much larger sizes and different distributions of nodes. However, for other complicated routing problems such as CVRP and CVRPTW, although NeuroLKH generalizes well to larger sizes, it is hard to directly generalize to other distributions of demands and time windows without training, which is a limitation of NeuroLKH and is left for future research. In addition, NeuroLKH can be further combined with other learning based techniques such as sparsifying the TSP graph [29] and other strong traditional algorithms such as the Hybrid Genetic Search [31].
+
+# Acknowledgments and Disclosure of Funding
+
+This work was supported by the A\*STAR Cyber-Physical Production System (CPPS) – Towards Contextual and Intelligent Response Research Program, under the RIE2020 IAF-PP Grant A19C1a0018, and Model Factory $@$ SIMTech, in part by the National Natural Science Foundation of China under Grant 61803104 and Grant 62102228, and in part by the Young Scholar Future Plan of Shandong University under Grant 62420089964188.
+
+# References
+
+[1] I. Bello, H. Pham, Q. V. Le, M. Norouzi, and S. Bengio. Neural combinatorial optimization with reinforcement learning. In Proceedings of International Conference on Learning Representations (ICLR)., 2016. [2] Y. Bengio, A. Lodi, and A. Prouvost. Machine learning for combinatorial optimization: a methodological tour d’horizon. European Journal of Operational Research, 2020.   
+[3] X. Bresson and T. Laurent. Residual gated graph convnets. arXiv preprint arXiv:1711.07553, 2017.   
+[4] X. Chen and Y. Tian. Learning to perform local rewriting for combinatorial optimization. In Advances in Neural Information Processing Systems, pages 6278–6289, 2019.   
+[5] P. R. d. O. da Costa, J. Rhuggenaath, Y. Zhang, and A. Akcay. Learning 2-opt heuristics for the traveling salesman problem via deep reinforcement learning. In Asian Conference on Machine Learning, pages 465–480. PMLR, 2020. [6] H. Dai, E. Khalil, Y. Zhang, B. Dilkina, and L. Song. Learning combinatorial optimization algorithms over graphs. In Advances in Neural Information Processing Systems, pages 6348– 6358, 2017.   
+[7] J. K. Falkner and L. Schmidt-Thieme. Learning to solve vehicle routing problems with time windows through joint attention. arXiv preprint arXiv:2006.09100, 2020.   
+[8] Z.-H. Fu, K.-B. Qiu, and H. Zha. Generalize a small pre-trained model to arbitrarily large tsp instances. In Proceedings of the AAAI Conference on Artificial Intelligence, 2021.   
+[9] S. Y. Hao Lu, Xingwen Zhang. A learning-based iterative method for solving vehicle routing problems. In Proceedings of International Conference on Learning Representations (ICLR)., 2020.   
+[10] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770– 778, 2016.   
+[11] M. Held and R. M. Karp. The traveling-salesman problem and minimum spanning trees: Part ii. Mathematical programming, 1(1):6–25, 1971.   
+[12] K. Helsgaun. An effective implementation of the lin–kernighan traveling salesman heuristic. European Journal of Operational Research, 126(1):106–130, 2000.   
+[13] K. Helsgaun. General k-opt submoves for the lin–kernighan tsp heuristic. Mathematical Programming Computation, 1(2-3):119–163, 2009.   
+[14] K. Helsgaun. An extension of the lin-kernighan-helsgaun tsp solver for constrained traveling salesman and vehicle routing problems. Roskilde: Roskilde University, 2017.   
+[15] A. Hottung, B. Bhandari, and K. Tierney. Learning a latent search space for routing problems using variational autoencoders. In Proceedings of International Conference on Learning Representations (ICLR)., 2021.   
+[16] A. Hottung and K. Tierney. Neural large neighborhood search for the capacitated vehicle routing problem. In European Conference on Artificial Intelligence, 2020.   
+[17] S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pages 448–456, 2015.   
+[18] C. K. Joshi, T. Laurent, and X. Bresson. An efficient graph convolutional network technique for the travelling salesman problem. arXiv preprint arXiv:1906.01227, 2019.   
+[19] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. In Proceedings of International Conference on Learning Representations (ICLR)., 2014.   
+[20] W. Kool, H. van Hoof, J. Gromicho, and M. Welling. Deep policy dynamic programming for vehicle routing problems. arXiv preprint arXiv:2102.11756, 2021.   
+[21] W. Kool, H. van Hoof, and M. Welling. Attention, learn to solve routing problems! In Proceedings of International Conference on Learning Representations (ICLR)., 2019.   
+[22] Y.-D. Kwon, J. Choo, B. Kim, I. Yoon, Y. Gwon, and S. Min. Pomo: Policy optimization with multiple optima for reinforcement learning. In Advances in Neural Information Processing Systems, volume 33, 2020.   
+[23] J. Li, L. Xin, Z. Cao, A. Lim, W. Song, and J. Zhang. Heterogeneous attentions for solving pickup and delivery problem via deep reinforcement learning. IEEE Transactions on Intelligent Transportation Systems, 2021.   
+[24] S. Lin. Computer solutions of the traveling salesman problem. Bell System Technical Journal, 44(10):2245–2269, 1965.   
+[25] S. Lin and B. W. Kernighan. An effective heuristic algorithm for the traveling-salesman problem. Operations research, 21(2):498–516, 1973.   
+[26] M. Nazari, A. Oroojlooy, L. Snyder, and M. Takác. Reinforcement learning for solving the vehicle routing problem. In Advances in Neural Information Processing Systems, pages 9839– 9849, 2018.   
+[27] G. Reinelt. Tsplib—a traveling salesman problem library. ORSA journal on computing, 3(4):376–384, 1991.   
+[28] M. M. Solomon. Algorithms for the vehicle routing and scheduling problems with time window constraints. Operations research, 35(2):254–265, 1987.   
+[29] Y. Sun, A. Ernst, X. Li, and J. Weiner. Generalization of machine learning for problem reduction: a case study on travelling salesman problems. OR Spectrum, 43(3):607–633, 2021.   
+[30] E. Uchoa, D. Pecin, A. Pessoa, M. Poggi, T. Vidal, and A. Subramanian. New benchmark instances for the capacitated vehicle routing problem. European Journal of Operational Research, 257(3):845–858, 2017.   
+[31] T. Vidal, T. G. Crainic, M. Gendreau, N. Lahrichi, and W. Rei. A hybrid genetic algorithm for multidepot and periodic vehicle routing problems. Operations Research, 60(3):611–624, 2012.   
+[32] O. Vinyals, M. Fortunato, and N. Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, volume 28, 2015.   
+[33] Y. Wu, W. Song, Z. Cao, J. Zhang, and A. Lim. Learning improvement heuristics for solving routing problems. IEEE Transactions on Neural Networks and Learning Systems, 2021.   
+[34] L. Xin, W. Song, Z. Cao, and J. Zhang. Step-wise deep learning models for solving routing problems. IEEE Transactions on Industrial Informatics, 17(7):4861–4871, 2020.   
+[35] L. Xin, W. Song, Z. Cao, and J. Zhang. Multi-decoder attention model with embedding glimpse for solving vehicle routing problems. In Proceedings of the 35th AAAI Conference on Artificial Intelligence, pages 12042–12049, 2021.   
+[36] J. Zheng, K. He, J. Zhou, Y. Jin, and C.-m. Li. Combining reinforcement learning with linkernighan-helsgaun algorithm for the traveling salesman problem. In Proceedings of the AAAI Conference on Artificial Intelligence, 2021.

parse/train/VKVShLsAuZ/VKVShLsAuZ_content_list.json

@@ -0,0 +1,1036 @@
+[
+    {
+        "type": "text",
+        "text": "NeuroLKH: Combining Deep Learning Model with Lin-Kernighan-Helsgaun Heuristic for Solving the Traveling Salesman Problem ",
+        "text_level": 1,
+        "bbox": [
+            189,
+            122,
+            810,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Liang Xin Nanyang Technological University Singapore XINL0003@e.ntu.edu.sg ",
+        "bbox": [
+            241,
+            251,
+            472,
+            308
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wen Song Shandong Unviersity Qingdao, China wensong@email.sdu.edu.cn ",
+        "bbox": [
+            545,
+            251,
+            756,
+            308
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zhiguang Cao∗ Singapore Institute of Manufacturing Technology Singapore zhiguangcao@outlook.com ",
+        "bbox": [
+            202,
+            328,
+            526,
+            383
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jie Zhang Nanyang Technological University Singapore jzhang@ntu.edu.sg ",
+        "bbox": [
+            563,
+            328,
+            794,
+            385
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            420,
+            535,
+            435
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present NeuroLKH, a novel algorithm that combines deep learning with the strong traditional heuristic Lin-Kernighan-Helsgaun (LKH) for solving Traveling Salesman Problem. Specifically, we train a Sparse Graph Network (SGN) with supervised learning for edge scores and unsupervised learning for node penalties, both of which are critical for improving the performance of LKH. Based on the output of SGN, NeuroLKH creates the edge candidate set and transforms edge distances to guide the searching process of LKH. Extensive experiments firmly demonstrate that, by training one model on a wide range of problem sizes, NeuroLKH significantly outperforms LKH and generalizes well to much larger sizes. Also, we show that NeuroLKH can be applied to other routing problems such as Capacitated Vehicle Routing Problem (CVRP), Pickup and Delivery Problem (PDP), and CVRP with Time Windows (CVRPTW). ",
+        "bbox": [
+            233,
+            450,
+            766,
+            617
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            643,
+            310,
+            661
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Traveling Salesman Problem (TSP) is an important NP-hard Combinatorial Optimization Problem with extensive industrial applications in various domains. Exact methods have the exponential worstcase computational complexity, which renders them impractical for solving large-scale problems in reality, even for highly optimized solvers such as Concorde. In contrast, although lacking optimality guarantees and non-trivial theoretical analysis, heuristic solvers search for near-optimal solutions with much lower complexity. They are usually desirable for real-life applications where statistically better performance is the goal. ",
+        "bbox": [
+            174,
+            675,
+            825,
+            772
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Traditional heuristic methods are manually designed based on expert knowledge which is usually human-interpretable. However, supported by the recent development of deep learning technology, modern methods train powerful deep neural networks to learn the complex patterns from the TSP instances generated from some specific distributions [32, 1, 6, 21, 18, 34, 33, 35]. The performances of deep learning models for solving TSP are constantly improved by these works, which unfortunately are still far worse than the strong traditional heuristic solver and generally limited to relatively small problem sizes. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            876
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We believe that learning-based methods should be combined with strong traditional heuristic algorithms, which is also suggested by [2]. In such a way, while learning the complex patterns from data samples, the efficient heuristics highly optimized by researchers for decades can be effectively utilized, especially for problems such as TSP which are well-studied due to their importance. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The Lin-Kernighan-Helsgaun (LKH) algorithm [12, 13] is generally considered as a very strong heuristic for solving TSP, which is developed based on the Lin-Kernighan (LK) heuristic [25]. LKH iteratively searches for $\\lambda$ -opt moves to improve the existing solution where $\\lambda$ edges of the tour are exchanged for another $\\lambda$ edges to form a shorter tour. To save the searching time, the edges to add are limited to a small edge candidate set, which is created before search. One of the most significant contributions of LKH is to generate the edge candidate set based on Minimum Spanning Tree, rather than using the nearest neighbor method in the LK heuristic. Furthermore, LKH applies penalty values to the nodes which are iteratively optimized using subgradient optimization (will be detailed in Section 3). The optimized node penalties are used by LKH to transform the edge distances for the $\\lambda$ -opt searching process and improve the quality of edge candidate sets, both of which help find better solutions. ",
+        "bbox": [
+            174,
+            154,
+            825,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "However, the edge candidate set generation in LKH is still guided by hand-crafted rules, which could limit the quality of edge candidates and hence the search performance. Moreover, the iterative optimization of node penalties is time-consuming, especially for large-scale problems. To address these limitations, we propose NeuroLKH, a novel learning-based method featuring a Sparse Graph Network (SGN) combined with the highly efficient $\\lambda$ -opt local search of LKH. SGN outputs the edge scores and node penalties simultaneously, which are trained by supervised learning and unsupervised learning, respectively. NeuroLKH transforms the edge distances based on the node penalties learned inductively from training instances, instead of performing iterative optimization for each instance, therefore saving a significant amount of time. More importantly, at the same time the edge scores are used to create the edge candidate set, leading to substantially better sets than those created by LKH. NeuroLKH trains one single network on TSP instances across a wide range of sizes and generalizes well to substantially larger problems with minutes of unsupervised offline fine-tuning to adjust the node penalty scales for different sizes. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            491
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Same as existing works on deep learning models for solving TSP, NeuroLKH aims to learn complex patterns from data samples to find better solutions for instances following specific distributions. Following the evaluation process in these works, we perform extensive experiments. Results show that NeuroLKH improves the baseline algorithms by large margins, not only across the wide range of training problem sizes, but also on much larger problem sizes not used in training. Furthermore, NeuroLKH trained with instances of relatively simple distributions generalizes well to traditional benchmark with various node distributions such as the TSPLIB [27]. Also, we show that NeuroLKH can be applied to guide the extension of LKH [14] for more complicated routing problems such as the Capacitated Vehicle Routing Problem (CVRP), Pickup and Delivery Problem (PDP) and CVRP with Time Windows (CVRPTW), using generated test datasets and traditional benchmarks [28, 30]. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            636
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related works ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            657,
+            325,
+            674
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Till now, for routing problems such as TSP, most works focus on learning construction heuristics, where deep neural networks are trained to sequentially select the nodes to visit with supervised learning [32, 15] or reinforcement learning [1, 6, 26, 21, 22]. Similarly, networks are trained to pick edges in [18, 20]. In another line of works [4, 33, 16, 9, 5], researchers employ deep learning models to learn the actions for improving existing solutions, such as picking regions and rules or selecting nodes for the 2-opt heuristic. However, the performance of these works is still quite far from the strong non-learning heuristics such as LKH. In addition, they focus only on relatively small-sized problems (up to hundreds of nodes). ",
+        "bbox": [
+            174,
+            689,
+            825,
+            801
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A recent work [8] generalizes a network pre-trained on fixed-size small graphs to solve larger size problems by sampling small sub-graphs to infer and merging the results. This interesting idea can be applied to very large graphs, however, the performance is still inferior to LKH and deteriorates rapidly with the increase of problem size. ",
+        "bbox": [
+            174,
+            808,
+            823,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In a concurrent work [36], a VSR-LKH method is proposed which also applies a learning method in combination with LKH. However, very different from our method, VSR-LKH applies traditional reinforcement learning during the searching process for each instance, instead of learning patterns for a class of instances. Moreover, VSR-LKH aims to guide the decision on edge selections within the edge candidate set, which is generated using the original procedure of LKH. NeuroLKH significantly outperforms VSR-LKH by large margins in all the settings of our experiments on testing instances following the training distributions, especially when the time limits are short. Even more impressively, NeuroLKH achieves performance similar to VSR-LKH on traditional benchmark TSPLIB [27] with various node distributions, which are very different from the training distributions for NeuroLKH. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/555bfa4b7f83d8522db3438f8d66631afa6d835d18cf03d7b3f9e3f1e25fe8dc.jpg",
+        "image_caption": [
+            "Figure 1: NeuroLKH algorithm and the original LKH algorithm. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            88,
+            820,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            270,
+            826,
+            353
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Preliminaries: LKH algorithm ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            375,
+            460,
+            392
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The Lin-Kernighan-Helsgaun (LKH) algorithm [12, 13] is a local optimization algorithm developed based on the $\\lambda$ -opt move [24], where $\\lambda$ edges in the current tour are exchanged by another set of $\\lambda$ edges to achieve a shorter tour. While solving one instance, the LKH algorithm can conduct multiple trials to find better solutions. In each trial, starting from a randomly initialized tour, it iteratively searches for $\\lambda$ -opt exchanges that improve the tour, until no such exchanges can be found. In each iteration, the $\\lambda$ -opt exchanges are searched in the ascending order of variable $\\lambda$ and the tour will be replaced once an exchange is found to reduce the tour distance. ",
+        "bbox": [
+            173,
+            407,
+            825,
+            505
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One central rule is that the $\\lambda$ -opt searching process is restricted and directed by an edge candidate set, which is created before search based on the $\\alpha$ -measure using sensitivity analysis of the Minimum Spanning Tree. Here we briefly introduce the related concepts. A TSP graph can be viewed as an undirected graph $G = ( V , E )$ with $V$ as the set of $| V |$ nodes and $E$ as the set of edges weighted by distances. A spanning tree of $G$ is a connected graph with $| V | - 1$ edges from $G$ and no cycles where any pair of nodes is connected by a path. A 1-tree of $G$ is a spanning tree for the graph of node set $V \\backslash \\{ 1 \\}$ } combined with two edges in $E$ connected to node 1, an arbitrary special node in $V$ . A minimum 1-tree is the 1-tree with minimum length. The $\\alpha$ -measure of an edge $( i , j ) \\in E$ for graph $G$ is defined as $\\alpha ( i , j ) = \\mathbb { L } ( T ^ { + } ( i , j ) ) - \\mathbb { L } ( T )$ , where $\\mathbb { L } ( T )$ is the length of Minimum 1-Tree $T$ and $\\mathbb { L } ( T ^ { + } ( i , j ) )$ is the length of Minimum 1-Tree $T ^ { + } ( i , j )$ required to include the edge $( i , j )$ . The $\\alpha$ -measure of an edge can be viewed as the extra length of the Minimum 1-Tree to include this edge. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            662
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The edge candidate set consists of the $k$ edges with the smallest $\\alpha$ -measures connected to each node $k = 5$ as default). During the $\\lambda$ -opt searching process, the edges to be included into the new tour are limited to the edges in this candidate set, and edges with smaller $\\alpha$ -measures will have higher priorities to be searched over. Therefore this candidate set not only restricts but also directs the search. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            726
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Moreover, the quality of $\\alpha$ -measures can be improved significantly by a subgradient optimization method. If we add a penalty $\\pi _ { i }$ to each node $i$ and transform the original distance $s _ { i , j }$ of the edge $( i , j )$ to a new distance $c _ { i , j }$ as $c _ { i , j } = s _ { i , j } + \\pi _ { i } + \\pi _ { j }$ , the optimal tour for the TSP will stay the same but the Minimum 1-Tree usually will change. Because by definition, a Minimum 1-Tree with node degrees all equal to 2 is an optimal solution for the corresponding TSP instance. With the length of Minimum 1-Tree resulting from the penalty $\\pi = ( \\pi _ { 1 } , . . . , \\pi _ { | V | } )$ as $\\mathsf { \\bar { L } } ( T _ { \\pi } )$ , $w ( \\pi ) = \\mathbb { L } ( T _ { \\pi } ) - 2 \\bar { \\Sigma _ { i } } \\pi _ { i }$ is a lower bound of the optimal tour distance for the original TSP instance. LKH applies subgradient optimization [11] to iteratively maximize this lower bound for multiple steps until convergence by applying $\\pi ^ { \\tau + 1 } = \\pi ^ { \\tau } + t ^ { \\tau } ( d ^ { \\tau } - 2 )$ at step $\\tau$ , where $t ^ { \\tau }$ is the scalar step size, $d ^ { \\tau }$ is the vector of node degrees in the Minimum 1-Tree with penalty $\\pi ^ { \\tau }$ . Therefore, the node degrees are pushed towards 2. The $\\alpha$ -measures after this optimization will substantially improve the quality of edge candidate set. Furthermore, the transformed edge distance $c _ { i , j }$ after this optimization helps find better solutions when used during the searching process for $\\lambda$ -opt exchanges. ",
+        "bbox": [
+            173,
+            731,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 The proposed NeuroLKH algorithm ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            88,
+            508,
+            107
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The subgradient optimization in LKH can substantially improve the quality of edge candidate sets based on the $\\alpha$ -measures, and transform the edge distances effectively to achieve reasonably good performance. However, it still has major limitations as the optimization process is over one instance iteratively until convergence, which costs a large amount of time, especially for large-scale problems. Moreover, even after subgradient optimization, some critical patterns could be missed by the relatively straightforward sensitivity analysis of spanning tree. Therefore, the quality of edge candidate set could be further improved by large margins, which will in turn improve the overall performance. ",
+        "bbox": [
+            173,
+            119,
+            825,
+            217
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We propose the NeuroLKH algorithm, which employs a Sparse Graph Network to learn the complex patterns associated with the TSP instances generated from a distribution. Concretely, the network will learn the edge scores and node penalties simultaneously with a multi-task training process. The edge scores are trained with supervised learning for creating the edge candidate set, while the node penalties are trained with unsupervised learning for transforming the edge distances. The architecture of NeuroLKH is presented in Figure 1, along with the original LKH algorithm. We will detail the Sparse Graph Network, the training process and the proposed NeuroLKH algorithm in the following. ",
+        "bbox": [
+            174,
+            223,
+            825,
+            320
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 Sparse Graph Network ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            335,
+            375,
+            351
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For the Sparse Graph Network (SGN), we format the TSP instance as a sparse directed graph $G ^ { * } = ( V , E ^ { * } )$ containing the node set $V$ and a sparse edge set $E ^ { * }$ which only includes the $\\gamma$ shortest edges pointed from each node, as shown in the leftmost green box in Figure 1, where the circles represent the nodes and the diamonds represent the directed edges. Sparsification of the graph is crucial for effectively training the deep learning model on large TSP instances and generalizing to even larger sizes. Note that edge $( i , j )$ belongs to $E ^ { * }$ does not necessarily mean that the oppositedirection edge $( j , i )$ belongs to $E ^ { * }$ . The node inputs $x _ { v } \\in \\mathbb { R } ^ { 2 }$ are the node coordinates and the edge inputs $x _ { e } \\in \\mathbb { R }$ are the edge distances. Though we focus on 2-dimensional TSP with Euclidean distance as the other deep learning literature like [21], the model can be applied to other kinds of TSP. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            487
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The SGN consists of 1) one encoder embedding the edge and node inputs into the corresponding feature vectors, and 2) two decoders for the edge scores and node penalties, respectively. ",
+        "bbox": [
+            173,
+            491,
+            823,
+            520
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Encoder. The encoder first linearly projects the node inputs and the edge inputs into feature vectors $v _ { i } ^ { 0 } \\in \\mathbb { R } ^ { D }$ and $e _ { i , j } ^ { 0 } \\in \\mathbb { R } ^ { j }$ , respectively, where $D$ is the feature dimension, $i \\in V$ and $( i , j ) \\in E ^ { * }$ . Then the node and edge features are embedded with $L$ Sparse Graph Convolutional Layers, which are defined formally as follows: ",
+        "bbox": [
+            173,
+            526,
+            825,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d312d8a6b5b4c4019277f14aaa8a026a38fde9bf587da890bcab0d83a11952a6.jpg",
+        "text": "$$\n\\begin{array} { c l } { { a t t n _ { i , j } ^ { \\iota } = e x p ( W _ { a } ^ { \\iota } e _ { i , j } ^ { { \\iota - 1 } } ) \\oslash \\displaystyle \\sum _ { ( i , m ) \\in E * } e x p ( W _ { a } ^ { \\iota } e _ { i , m } ^ { { \\iota - 1 } } ) , } } \\\\ { { \\strut } } \\\\ { { \\displaystyle v _ { i } ^ { l } = v _ { i } ^ { l - 1 } + R e L U ( B N ( W _ { s } ^ { \\iota } v _ { i } ^ { { \\iota - 1 } } + \\sum _ { ( i , j ) \\in E ^ { * } } a t t n _ { i , j } ^ { \\iota } \\odot W _ { n } ^ { \\iota } v _ { j } ^ { { \\iota - 1 } } ) ) , } } \\\\ { { \\strut } } \\\\ { { \\strut } } \\\\ { { \\displaystyle r _ { i , j } ^ { l } = \\left\\{ W _ { \\iota } ^ { l } e _ { j , i } ^ { { \\iota - 1 } } , \\begin{array} { l l } { { \\mathrm { i f ~ } ( j , i ) \\in E ^ { * } } } \\\\ { { W _ { \\iota } ^ { \\iota } p ^ { l } , } } \\end{array} \\right. } } & { { \\mathrm { o t h e r w i s e } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            587,
+            717,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5574475e6ebadefba65f40a283ef3fe37b64f5016e5dfe1b6d8e342ad7ecd682.jpg",
+        "text": "$$\ne _ { i , j } ^ { l } = e _ { i , j } ^ { l - 1 } + R e L U ( B N ( W _ { f } ^ { l } v _ { i } ^ { l - 1 } + W _ { t } ^ { l } v _ { j } ^ { l - 1 } + W _ { o } ^ { l } e _ { i , j } ^ { l - 1 } + r _ { i , j } ^ { l } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            707,
+            718,
+            727
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ and $\\oslash$ represent the element-wise multiplication and the element-wise division, respectively; $l = 1 , 2 , . . . , L$ is the layer index; $W _ { a } ^ { l } , W _ { s } ^ { l } , W _ { n } ^ { l } , \\dot { W } _ { r } ^ { l } , W _ { f } ^ { l } , W _ { t } ^ { l } , W _ { o } ^ { l } \\in \\mathbb { R } ^ { D \\times D }$ and $p ^ { l } \\in \\mathbb { R } ^ { D }$ are trainable parameters; Eqs. (2) and (4) consist of a Skip-Connection layer [10] and a Batch Normalization layer [17] in each; and the idea of element-wise attention in Eq. (1) is adopted from [3]. As the input graph $G ^ { * }$ is directed and sparse, edges with different directions are embedded separately. But obviously the embedding of an edge $( i , j )$ should benefit from knowing whether its opposite-direction counterpart $( j , i )$ is also in the graph and the information of $( j , i )$ , which motivates our design of Eqs. (3) and (4). ",
+        "bbox": [
+            173,
+            727,
+            825,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Decoders. The edge decoder takes the edge embeddings $e _ { i , j } ^ { L }$ from the encoder and embeds them with two layers of linear projection followed by ReLU activation into efi,j . Then the edge scores $\\beta _ { i , j }$ are calculated as follows: ",
+        "bbox": [
+            174,
+            829,
+            825,
+            876
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d79c004cecac570ab539c7064a10acfc954dde2a093ec1bc07c14bbf8725efbb.jpg",
+        "text": "$$\n\\beta _ { i , j } = \\frac { e x p ( W _ { \\beta } e _ { i , j } ^ { f } ) } { \\sum _ { ( i , m ) \\in E ^ { * } } e x p ( W _ { \\beta } e _ { i , m } ^ { f } ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            872,
+            611,
+            916
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/ede5a9db3578ed9f8554f4d1a71f677afb627692d9d771e2f2a15859861cbcf8.jpg",
+        "table_caption": [
+            "Algorithm 1 NeuroLKH Algorithm "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Input: TSP instance,number of trials K Output: TSP solution BestTour</td></tr><tr><td></td></tr><tr><td>1: Convert the TSP instance to SGN input G*,xu, xe</td></tr><tr><td>2: Calculate the edge scores βi,j and the node penalties Ti with Eqs. (5) and (6)</td></tr><tr><td>3: EdgeDistance=TransformEdgeDistance(π)</td></tr><tr><td></td></tr><tr><td>4: EdgeCandidateSet=CreateEdgeCandidateSet(β) 5: BestTour=LKHSearchingTrials(EdgeDistance,EdgeCandidateSet,K)</td></tr></table>",
+        "bbox": [
+            174,
+            107,
+            710,
+            223
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Similarly, the node decoder first embeds the node embeddings $v _ { i } ^ { L }$ with two layers of linear projection and ReLU activation into $v _ { i } ^ { f }$ . Then the node penalties $\\pi _ { i }$ are calculated as follows: ",
+        "bbox": [
+            173,
+            247,
+            823,
+            280
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2a8a698208401d7287e685b7af72ddc9db91e411b562d509e15a638ae293659d.jpg",
+        "text": "$$\n\\pi _ { i } = C \\operatorname { t a n h } ( W _ { \\pi } v _ { i } ^ { f } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            424,
+            285,
+            571,
+            305
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { \\beta }$ ${ \\sf \\Psi } _ { 3 } , W _ { \\pi } \\in \\mathbb { R } ^ { D \\times 1 }$ are trainable parameters; $C = 1 0$ is used to keep the node penalties in the range of $[ - 1 0 , 1 0 ]$ . ",
+        "bbox": [
+            174,
+            309,
+            825,
+            340
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 Training process ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            354,
+            330,
+            371
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We train the network to learn the edge scores with supervised learning. And the edge loss $\\mathcal { L } _ { \\beta }$ is detailed as follows: ",
+        "bbox": [
+            173,
+            380,
+            825,
+            409
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5c435988a04956190f2437056d11fbfd7fae9565a32493092a24069c7d734f84.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\beta } = - \\frac { 1 } { \\gamma | V | } \\sum _ { ( i , j ) \\in E ^ { * } } ( \\mathbb { 1 } \\{ ( i , j ) \\in E _ { o } ^ { * } \\} \\log \\beta _ { i , j } + \\mathbb { 1 } \\{ ( i , j ) \\notin E _ { o } ^ { * } \\} \\log ( 1 - \\beta _ { i , j } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            410,
+            759,
+            450
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $E _ { o } ^ { * } = \\{ ( i , j ) \\in E ^ { * } | ( i , j )$ in the optimal tour}. Effectively, we increase the edge scores $\\beta _ { i , j }$ if the edge $( i , j )$ belongs to the optimal tour and decrease them otherwise. ",
+        "bbox": [
+            171,
+            455,
+            825,
+            484
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The node penalties are trained by unsupervised learning. Similar to the goal of subgradient optimization in LKH, we are trying to transform the Minimum 1-Tree generated from the TSP graph $G$ closer to a tour where all nodes have a degree of 2. An important distinction from LKH is that we are learning the patterns for a class of TSP instances following a distribution, instead of optimizing the penalties for a specific TSP instance. The node loss ${ \\mathcal { L } } _ { \\pi }$ is detailed as follows: ",
+        "bbox": [
+            173,
+            489,
+            825,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/89732222210a53b0ef68b566affc38eefbf26fc58fb6be76de29b702d69ca1e6.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\pi } = - \\frac { 1 } { \\vert V \\vert } \\sum _ { i \\in V } ( d _ { i } ( \\pi ) - 2 ) \\pi _ { i } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            564,
+            601,
+            602
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $d _ { i } ( \\pi )$ is the degree of node $i$ in the Minimum 1-Tree $T _ { \\pi }$ induced with penalty $\\pi = ( \\pi _ { 1 } , . . . , \\pi _ { | V | } )$ The penalties are increased for nodes with degrees larger than 2 and decreased for nodes with smaller degrees. The SGN is trained for the task of outputting the edge scores and node penalties simultaneously with the loss function $\\mathcal { L } = \\mathcal { L } _ { \\beta } + \\eta _ { \\pi } \\mathcal { L } _ { \\pi }$ , where $\\eta _ { \\pi }$ is the coefficient for balancing the two losses. ",
+        "bbox": [
+            173,
+            606,
+            825,
+            676
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 NeuroLKH algorithm ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            691,
+            364,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The process of using NeuroLKH to solve one instance is shown in Algorithm 1. Firstly, the TSP instance is converted to a sparse directed graph $G ^ { * }$ . Then the SGN encoder embeds the nodes and edges in $G ^ { * }$ into feature embeddings, based on which the decoders output the node penalties $\\pi$ and edge scores $\\beta$ . Afterwards, NeuroLKH creates powerful edge candidate set and transforms the distance of each edge effectively, which further guides NeuroLKH to conduct multiple LKH trials to find good solutions. We detail each part as follows. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            801
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Transform Edge Distance. Based on the node penalties $\\pi _ { i }$ , the original edge distances $s _ { i , j }$ are transformed into new distances $c _ { i , j } = s _ { i , j } + \\pi _ { i } + \\pi _ { j }$ , which will be used in the search process. With such a transformation, the optimal solution tour will stay the same. And the tour distance calculated with the transformed edge distances will be subtracted by $2 \\sum _ { i \\in V } \\pi _ { i }$ to restore the tour distance for the original TSP. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            877
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Create Edge Candidate Set. For each node $i \\in V$ , the edge scores $\\beta _ { i , j }$ are sorted for $( i , j ) \\in E ^ { * }$ and the edges with the top- $k$ largest scores are included in the edge candidate set. Edges with larger scores have higher priorities in the candidate set, which will be tried first for adding in the exchange during the LKH search process. Note that neither the original LKH nor NeuroLKH can guarantee all the edges in the optimal tour to be included in the edge candidate set. However, optimal solutions are still likely to be found during the multiple trials. ",
+        "bbox": [
+            174,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "LKH Searching Trials. To solve one TSP instance, LKH conducts multiple trials to find better solutions. In each trial, one tour is initialized randomly, and iterations of LKH search are conducted for the $\\lambda$ -opt exchanges until the tour can no longer be improved by such exchanges. In each iteration, LKH searches in the ascending order of $\\lambda$ for $\\lambda$ -opt exchanges to reduce tour length, which will be applied once found. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            222
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Based on the trained SGN network, NeuroLKH infers the edge distance transformation and candidate set to guide the LKH trials, which is done by performing forward calculation through the model. This is much faster than the corresponding procedure in the original LKH, which employs subgradient optimization on each instance iteratively until convergence and is apparently time-consuming especially for large-scale problems. More importantly, rather than using the hand-crafted rules based on sensitivity analysis in the original LKH, NeuroLKH learns to create edge candidate set of much higher quality with the powerful deep model, leading to significantly better performance. ",
+        "bbox": [
+            174,
+            228,
+            825,
+            327
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            347,
+            312,
+            363
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct extensive experiments on TSP with various sizes and show the effective performance of NeuroLKH compared to the baseline algorithms. Our code is publicly available.1 ",
+        "bbox": [
+            173,
+            378,
+            823,
+            407
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dataset distribution. Closely following the existing works such as [21], we experiment with the 2-dimensional TSP instances in the Euclidean distance space where both coordinates of each node are generated independently from a unit uniform distribution. We train only one network using TSP instances ranging from 101 to 500 nodes. Since the amount of supervision and feedback during training is linearly related to the number of nodes. We generate $\\bar { 5 } 0 0 0 0 0 0 / | V |$ instances for each size $| V |$ in the training dataset, resulting in approximately 780000 instances in total. Therefore the amounts of supervision and feedback are kept similar across different sizes. We use Concorde 2 to get the optimal edges $E _ { o } ^ { * }$ for the supervised training of edge scores. For testing, we generate 1000 instances for each testing problem size. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            537
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameters. We choose the number of directed edges pointed from one node in the sparse edge set $E ^ { * }$ as $\\gamma = 2 0$ , which results in only $0 . 0 1 \\%$ of the edges in the optimal tours missed in $E ^ { * }$ for the training dataset. We also conduct experiments to justify this choice in Appendix Section A. The hidden dimension is set to $D = 1 2 8$ in the network with $L = 3 0$ Sparse Graph Convolutional Layers. The node penalty coefficient in the loss function is $\\eta _ { \\pi } = 1$ . The network is trained by Adam Optimizer [19] with learning rate of 0.0001 for 16 epochs, which takes approximately 4 days. The deep learning models are trained and evaluated with one RTX-2080Ti GPU. The other parts of experiments without deep models for NeuroLKH and other baselines are conducted with random seed 1234 on an Intel(R) Core(TM) i9-10940X CPU unless stated otherwise. Hyperparameters for the LKH searching process are consistent with the example script for TSP given by LKH available online 3 and those used in [36]. ",
+        "bbox": [
+            173,
+            544,
+            825,
+            696
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 Comparative study on TSP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            713,
+            401,
+            728
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here, we compare NeuroLKH with the original LKH algorithm [13] and the recently proposed VSR-LKH algorithm [36]. We do not compare with other deep learning based methods here because their performances are rather inferior to LKH, and most of them can hardly generalize to problems with more than 100 nodes. One exception is the method in [8], which is tested on large problems but the performances are still far worse than LKH. ",
+        "bbox": [
+            174,
+            739,
+            825,
+            809
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "All algorithms are run once for each testing instance as we find running multiple times only provides very marginal improvement. For each testing problem size, we run the original LKH for 1, 10, 100, and 1000 trials, and record the total amounts of time in solving the 1000 instances. Then we impose the same amounts of time as time limits to NeuroLKH and VSR-LKH for solving the same 1000 instances for fair comparison. Note that for NeuroLKH, the solving time is the summation of the inference time of SGN on GPU and LKH searching time on CPU. In the following tables, for each size and time limit, we report the average performance (tour distance) and the total solving time for the 1000 testing instances. ",
+        "bbox": [
+            176,
+            815,
+            823,
+            858
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9d89fc5a86a90294cb247e3e24f6db0cffad9dddd540f49d0984e8ffe88b6ccb.jpg",
+        "table_caption": [
+            "Table 1: Comparative results on training sizes "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">Time(s)</td><td colspan=\"2\">|V|=100</td><td rowspan=\"2\">Time(s)</td><td colspan=\"2\">|V|= 200</td><td rowspan=\"2\"></td><td colspan=\"2\">|V|= 500</td><td rowspan=\"2\">Gap(%oo)</td></tr><tr><td>Obj</td><td>Gap(%oo)</td><td></td><td>Obj Gap(%oo)</td><td>Time(s)</td><td>Obj</td></tr><tr><td>Concorde</td><td>207</td><td>*7.753246</td><td>0.000</td><td>1072</td><td></td><td>*10.701303</td><td>0.000</td><td>17022</td><td>*16.541830</td><td>0.000</td></tr><tr><td rowspan=\"3\">LKH (1 trial) VSR-LKH</td><td rowspan=\"3\">33</td><td>7.755071</td><td>2.353</td><td rowspan=\"3\"></td><td>10.707043</td><td></td><td rowspan=\"3\"></td><td></td><td></td><td>9.009</td></tr><tr><td>7.754980</td><td>2.236</td><td>80</td><td>10.706739</td><td>5.364 5.080</td><td>16.556733 16.557297</td><td>9.350</td></tr><tr><td>7.753332</td><td>0.111</td><td>10.701873</td><td></td><td>338</td><td>16.543197</td><td>0.826</td></tr><tr><td rowspan=\"3\">NeuroLKH LKH (10 trials) VSR-LKH</td><td rowspan=\"3\">43</td><td></td><td></td><td></td><td></td><td>0.533</td><td></td><td></td><td></td><td></td></tr><tr><td>7.754177</td><td>1.200</td><td>111</td><td>10.703724</td><td></td><td>2.263</td><td>445</td><td>16.548017</td><td>3.740</td></tr><tr><td>7.754184 7.753311</td><td>1.209 0.083</td><td></td><td>10.703997 10.701623</td><td>2.518</td><td></td><td></td><td>16.549591 16.542880</td><td>4.692 0.634</td></tr><tr><td rowspan=\"2\">NeuroLKH LKH (100 trials) VSR-LKH</td><td rowspan=\"2\">127</td><td></td><td>0.263</td><td></td><td></td><td></td><td>0.299 0.423</td><td></td><td></td><td></td></tr><tr><td>7.753450 7.753407</td><td>0.207</td><td>368</td><td>10.701755 10.701687</td><td></td><td>0.359</td><td>1147</td><td>16.543707 16.543085</td><td>1.134 0.759</td></tr><tr><td rowspan=\"2\">NeuroLKH LKH (1000 trials)</td><td rowspan=\"2\"></td><td>7.753270</td><td>0.030</td><td></td><td></td><td>10.701381</td><td>0.073</td><td></td><td>16.542163</td><td>0.201</td></tr><tr><td></td><td></td><td></td><td>10.701351</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td rowspan=\"2\">VSR-LKH NeuroLKH</td><td rowspan=\"2\">938</td><td>7.753254</td><td>0.010 0.097</td><td>2805</td><td></td><td>10.701336</td><td>0.045 0.031</td><td>7527</td><td>16.542125 16.541934</td><td>0.178</td></tr><tr><td>7.753322 7.753247</td><td>0.000</td><td></td><td>10.701303</td><td></td><td>0.000</td><td></td><td>16.541847</td><td>0.063 0.010</td></tr></table>",
+        "bbox": [
+            174,
+            112,
+            823,
+            295
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            338,
+            825,
+            409
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Comparison on training sizes. In Table 1, we report the performances of LKH, VSR-LKH and NeuroLKH on three testing datasets with 100, 200 and 500 nodes, which are within the size range of instances used in training. Note that we train only one SGN Network on a wide range of problem sizes and here we use these three sizes to demonstrate the testing performances. We also use the exact solver Concorde on these instances to obtain the optimal solutions and compute the optimality gap for each method. As shown in this table, it is clear that NeuroLKH outperforms both LKH and VSR-LKH significantly and consistently across different problem sizes and with different time limits. Notably, the optimality gaps are reduced by at least an order of magnitude for most of the cases, which is a significant improvement. ",
+        "bbox": [
+            174,
+            414,
+            825,
+            540
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Generalization analysis on larger sizes. We further show the generalization ability of NeuroLKH on much larger graph sizes of 1000, 2000 and 5000 nodes. Note that while the edge scores in SGN generalize well without any modification, it is hard for the node penalties to directly generalize. This is because they are trained unsupervisedly and SGN does not have any knowledge about how to penalize the nodes for larger TSP instances. Nevertheless, this could be resolved by a simple fine-tuning step. As the learned node embeddings are very powerful, we only fine-tune the very small amount of parameters in the SGN node decoder and keep the other parameters fixed. Specifically, for each of the large sizes, we fine-tune the node decoder for 100 iterations with batch size of $5 0 0 0 / | V |$ , which only takes less than one minute for each size of 1000, 2000 and 5000. This fast fine-tuning process is for TSPs of one size generated from the distribution instead of specific instances, and may be viewed as adjusting the scale of penalties for large sizes. The generalization results are summarized in Table 2. Note that we do not run Concorde here due to the prohibitively long running time, and the gaps are with respect to the best value found by all methods. Clearly, NeuroLKH generalizes well to substantially larger problem sizes and the improvement of NeuroLKH over baselines is significant and consistent across all the settings. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            752
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Further discussion. The inference time of SGN in NeuroLKH for the 1000 instances of 100, 200, 500, 1000, 2000 and 5000 nodes is 3s, 6s, 16s, 33s, 63s and 208s, which is approximately linear with the number of nodes $| V |$ . In contrast, the subgradient optimization in LKH and VSR-LKH needs 20s, 51s, 266s, 1028s, 4501s and 38970s, which grows superlinearly with $| V |$ and is much longer than SGN inference, especially for large-scale problems. For NeuroLKH, the saved time is used to conduct more trials, which effectively helps to find better solutions. This effect is more salient with short time limit. Meanwhile, the number of trials is also small for short time limit and the algorithm only searches a small number of solutions, in which case the guidance of edge candidate set is more important. Due to these two reasons, the improvement of NeuroLKH over baselines is particularly substantial for short time limit. This is a desirable property especially for time-critical applications and solving large-scale problems, for which large numbers of trials are not feasible. ",
+        "bbox": [
+            173,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/f0fd20864c1f639e1d8453848ea94e05d9f756c4c374eab1017774b97914a08b.jpg",
+        "table_caption": [
+            "Table 2: Comparative results on generalization sizes "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">Time(s)</td><td colspan=\"2\">|V|= 1000 Obj</td><td colspan=\"3\">IV|= 2000</td><td colspan=\"3\">IV|= 5000</td></tr><tr><td></td><td>Gap(%00)</td><td>Time(s)</td><td>Obj</td><td>Gap(%o0)</td><td>Time(s)</td><td>Obj</td><td>Gap(%0)</td></tr><tr><td>LKH(1 trial)</td><td rowspan=\"2\">1183</td><td>23.155916</td><td>10.593</td><td rowspan=\"2\">4843</td><td>32.483851</td><td>11.264</td><td rowspan=\"2\">40048</td><td>51.025519</td><td>12.284</td></tr><tr><td>VSR-LKH</td><td>23.154946</td><td>10.173</td><td>32.485551</td><td>11.788</td><td>51.025539</td><td>12.288</td></tr><tr><td rowspan=\"2\">NeuroLKH LKH(10 trials)</td><td rowspan=\"2\"></td><td>23.133494</td><td>0.899</td><td rowspan=\"2\"></td><td>32.449752</td><td>0.755</td><td rowspan=\"2\"></td><td>50.965382</td><td>0.484</td></tr><tr><td>23.143435</td><td>5.197</td><td>32.466953</td><td>6.056</td><td>50.998721</td><td>7.026</td></tr><tr><td rowspan=\"2\">VSR-LKH NeuroLKH</td><td rowspan=\"2\">1414</td><td>23.143347</td><td>5.159</td><td rowspan=\"2\">5322</td><td>32.467997</td><td>6.377</td><td rowspan=\"2\">41523</td><td>51.000093</td><td>7.295</td></tr><tr><td>23.133066</td><td>0.714</td><td>32.449519</td><td>0.683</td><td>50.965219</td><td>0.452</td></tr><tr><td rowspan=\"2\">LKH(100 trials)</td><td rowspan=\"2\">2567</td><td>23.135427</td><td>1.735</td><td rowspan=\"2\"></td><td>32.455454</td><td>2.512</td><td rowspan=\"2\"></td><td>50.976677</td><td>2.700</td></tr><tr><td>23.134426</td><td>1.302</td><td>32.454427</td><td>2.195</td><td>50.979317</td><td>3.218</td></tr><tr><td rowspan=\"2\">VSR-LKH NeuroLKH</td><td rowspan=\"2\"></td><td>23.132258</td><td>0.365</td><td rowspan=\"2\">7371</td><td>32.448666</td><td>0.420</td><td rowspan=\"2\">47884</td><td>50.964677</td><td>0.345</td></tr><tr><td>23.132216</td><td>0.347</td><td></td><td>0.509</td><td></td><td>0.455</td></tr><tr><td rowspan=\"2\">LKH(1000 trials) VSR-LKH</td><td rowspan=\"2\">12884</td><td>23.131658</td><td>0.105</td><td rowspan=\"2\">25613</td><td>32.448954 32.447953</td><td>0.200</td><td rowspan=\"2\">103885</td><td>50.965233 50.965300</td><td>0.468</td></tr><tr><td>23.131414</td><td>0.000</td><td>32.447304</td><td>0.000</td><td>50.962916</td><td>0.000</td></tr></table>",
+        "bbox": [
+            176,
+            112,
+            823,
+            282
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 2, we plot the performance of the LKH, VSR-LKH and NeuroLKH algorithms for solving the testing datasets with different numbers of nodes against different running time to visualize the improvement process (the resulting objective values after each trial). The time limits are set to the longest ones used in Table 1 and Table 2, which are the running time of LKH with 1000 trials. Clearly, NeuroLKH outperforms both LKH and VSR-LKH significantly and consistently across different problem sizes and with different time limits. In particular, NeuroLKH is superior as it not only reaches good solutions fast but also converges to better solutions eventually. With the same performance (i.e. objective value), NeuroLKH considerably reduces the computational time. We can also conclude that when the time limit is short, the improvement of NeuroLKH over baselines is particularly substantial. In addition, we show that the subgradient optimization is necessary for LKH and VSR-LKH. As exhibited in Figure 2, the performances of both LKH and VSR-LKH are much worse without subgradient optimization (w/o SO). More impressively, even ignoring the preprocessing time (IPT) used for subgradient optimization (pertaining to LKH and VSR-LKH) and Sparse Graph Network inferring (pertaining to NeuroLKH), NeuroLKH still outstrips both LKH and VSR-LKH. Note that this comparison is unfair for NeuroLKH as LKH and VSR-LKH consume much longer preprocessing time which is unavoidable. ",
+        "bbox": [
+            173,
+            318,
+            825,
+            540
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For the results reported in Table 1 and Table 2, almost all the improvements of NeuroLKH over LKH and VSR-LKH on different sizes and with different time limits are statistically significant with confidence levels larger than $9 9 \\%$ . The only one exception is the performance on TSP with 100 nodes and the running time of LKH with 1000 trials where the confidence levels are $9 0 . 5 \\%$ and $9 7 . 6 \\%$ for the improvements, respectively. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            614
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the Appendix Section A, we also show that NeuroLKH substantially outperforms other deep learning based methods [21, 20, 33, 18, 15, 8, 22, 5]. ",
+        "bbox": [
+            176,
+            621,
+            821,
+            650
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Generalization to TSPLIB benchmark. Besides generalization to larger sizes, generalization to different distributions remains a crucial challenge for deep learning based methods in existing works. The TSPLIB benchmark contains instances with various node distributions, making it extremely hard for such methods. We test on all the 72 TSPLIB instances with Euclidean distances and less than 10000 nodes. The number of trials is set to be the number of nodes and the algorithms are run 10 times for each instance following the convention for TSPLIB in [12, 36]. With the various unknown node distributions, we do not fine-tune the model for the node penalties and only use the edge scores in NeuroLKH. For the 24 instances labeled as hard in [36], which the original LKH fails to solve optimally during at least one of the 10 runs, NeuroLKH trained with uniformly distributed data is able to find optimal solutions 6.13 times on average, which is much better than LKH (3.75 times). As an active learning method, VSR-LKH finds optimal solutions 6.42 times on average, slightly better than NeuroLKH. While NeuroLKH improves the results on most hard instances, it could generalize poorly on instances with certain special patterns such as where most nodes are located along several horizontal lines, making it fail to solve 11 of the 48 easy instances optimally for some runs. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            849
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "With the same training dataset size, we trained another model NeuroLKH_M using a mixture of instances with uniformly distributed nodes, clustered nodes with 3-8 clusters, half uniform and half clustered nodes following [30]. NeuroLKH_M finds optimal solutions 6.79 times on average for the hard instances and fails to solve only 5 easy instances optimally for some runs, better than the ",
+        "bbox": [
+            176,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/273c9892f25b4866fa915d42faa86aa3e755594fcc67dba61133d0c46158bd97.jpg",
+        "image_caption": [
+            "Figure 2: Performances of LKH, VSR-LKH and NeuroLKH for solving TSP with different sizes against different running time "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            87,
+            825,
+            368
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "NeuroLKH trained with only uniformly distributed instances. For all the 72 instances, NeuroLKH_M finds optimal solutions 8.74 times on average, which is much better than LKH (7.92 times) but slightly worse than VSR-LKH (8.78 times). Detailed results of each instance are listed in the Appendix Section B. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            491
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 Experiments on other routing problems ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            512,
+            488,
+            526
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, we show that NeuroLKH can be easily extended to solve much more complicated routing problems such as the Capacitated Vehicle Routing Problem (CVRP), the Pickup and Delivery Problem (PDP) and CVRP with Time Windows (CVRPTW). We briefly introduce the problems in the Appendix Section C. Different from TSP, the node penalties do not apply to these problems. Therefore, NeuroLKH only learns the edge candidate set. As these three problems are very hard to solve and the optimal solutions are not available in a reasonable amount of time, we use LKH with 10000 trials to get solutions as training labels. The demands, capacities, starts and ends in the time windows are taken as node inputs along with the coordinates. For PDP, we add connections between each pair of pickup and delivery nodes and assign weight matrices for these connections in Eq. (2). For PDP and CVRPTW, the edge directions affect the tour feasibility therefore the model learns the in-direction edge scores and out-direction edge scores for each node with Eq. (5). ",
+        "bbox": [
+            174,
+            539,
+            825,
+            690
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The node coordinates are also generated uniformly from the unit square for all three problems, following [21, 23]. For CVRP, the demands of customers are generated uniformly from integers $\\{ 1 . . 9 \\}$ with the capacity fixed as $4 0 + 0 . 1 \\times | V |$ , compatible with the largest CVRP (100 nodes) studied in [21]. For CVRPTW, we use the same way to generate demands, capacity, serving time and time windows as [7]. A training dataset for CVRP with 101-500 nodes and $1 2 0 0 0 0 / | V |$ instances for each size (about 180000 in total) is used to train the SGN for 10 epochs. PDP and CVRPTW are harder to solve therefore we use a training dataset with 41-200 nodes and $2 4 0 0 0 0 / | V |$ instances for each size. The other hyperparameters in SGN are the same as TSP and those for LKH searching process are consistent with example scripts given by LKH for CVRP, PDP and CVRPTW (with the SPECIAL hyperparameter). ",
+        "bbox": [
+            174,
+            696,
+            825,
+            835
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Table 3, we show the performance of NeuroLKH and the original LKH on testing datasets with 1000 instances for the smallest and largest graph sizes (number of customers) used in training as well as a much larger generalization size. We use the solving time of LKH with 100, 1000, 10000 trials as the time limits. For 100 trials, both methods fail to find feasible solutions for less than $1 \\%$ of the PDP and CVRPTW test instances with 300 nodes. Whenever this happens, we push the infeasible visits to the end to get feasible solutions. The inferring time of SGN is 1s, 3s, 7s, 10s, 19s and 40s in total for the 1000 instances in the testing datasets with 40, 100, 200, 300, 500 and 1000 nodes, which is a tiny fraction compared to the LKH searching process. As shown in Table 3, NeuroLKH significantly improves the solution quality compared with the original LKH which is a very strong heuristic solver for all three problems, showing its potential in handling various types of routing problems. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/a508958986b8d8ee846d0f0cd4080cfa586632fff01cd468ddc576b818820573.jpg",
+        "table_caption": [
+            "Table 3: Comparative results for other routing problems "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td></td><td>Time(s)</td><td>Obj</td><td>Gap(%)</td><td>Time(s)</td><td>Obj</td><td>Gap(%)</td><td>Time(s)</td><td>Obj</td><td>Gap(%)</td></tr><tr><td rowspan=\"5\">GRRP</td><td></td><td></td><td>|V|= 100</td><td></td><td></td><td>|V|= 500</td><td></td><td>Generalization |V|</td><td></td><td>=1000</td></tr><tr><td>LKH (100 trials) NeuroLKH</td><td>485</td><td>15.8363 15.7770</td><td>1.675 1.295</td><td>2043</td><td>42.1621 41.7311</td><td>5.394 4.316</td><td>4607</td><td>58.1372 56.6469</td><td>9.750 6.937</td></tr><tr><td>LKH (1000 trials) NeuroLKH</td><td>4520</td><td>15.6483 15.6295</td><td>0.468 0.348</td><td>15812</td><td>40.6103 40.4974</td><td>1.515 1.233</td><td>30133</td><td>54.3412 54.0499</td><td>2.584 2.034</td></tr><tr><td>LKH(10000 trials) NeuroLKH</td><td>45435</td><td>15.5823 15.5754</td><td>0.044 0.000</td><td>166875</td><td>40.0670 40.0043</td><td>0.157 0.000</td><td>319368</td><td>53.1093 52.9723</td><td>0.259 0.000</td></tr><tr><td>LKH (100 trials)</td><td></td><td>|V|= 40</td><td></td><td></td><td>|V|= 200</td><td></td><td>Generalization |V|</td><td></td><td>=300</td></tr><tr><td rowspan=\"3\">P</td><td>NeuroLKH</td><td>115</td><td>6.2495 6.2241</td><td>0.819 0.409</td><td>2832</td><td>13.8390 13.6246</td><td>5.535 3.899</td><td>7939</td><td>17.0913 16.7867</td><td>6.916 5.011</td></tr><tr><td>LKH(1000 trials) NeuroLKH</td><td>845</td><td>6.2088 6.2041</td><td>0.163 0.087</td><td>21216</td><td>13.2850 13.2443</td><td>1.310 0.999</td><td>55643</td><td>16.2447 16.1857</td><td>1.620 1.251</td></tr><tr><td>LKH(10000 trials) NeuroLKH</td><td>7989</td><td>6.1998 6.1988</td><td>0.018 0.000</td><td>195220</td><td>13.1387 13.1132</td><td>0.194 0.000</td><td>515377</td><td>16.0119 15.9857</td><td>0.163 0.000</td></tr><tr><td rowspan=\"5\">CIPRRA</td><td></td><td>一</td><td>|V|= 40</td><td></td><td></td><td>|V|= 200</td><td></td><td>Generalization |V|</td><td></td><td>=300</td></tr><tr><td>LKH(100 trials) NeuroLKH</td><td>147</td><td>9.3051 9.2606</td><td>1.081 0.597</td><td>813</td><td>26.1757 25.4000</td><td>7.124 3.949</td><td>1746</td><td>34.2301 32.9676</td><td>8.798 4.786</td></tr><tr><td>LKH(1000 trials) NeuroLKH</td><td>1017</td><td>9.2276 9.2207</td><td>0.239 0.164</td><td>4525</td><td>24.9770 24.7857</td><td>2.218 1.435</td><td>7820</td><td>32.2671 32.0224</td><td>2.559 1.781</td></tr><tr><td>LKH(10000 rials) NeuroLKH</td><td>9624</td><td>9.2073 9.2056</td><td>0.018 0.000</td><td>45509</td><td>24.5338 24.4350</td><td>0.405 0.000</td><td>75481</td><td>31.5719 31.4620</td><td>0.350 0.000</td></tr></table>",
+        "bbox": [
+            178,
+            112,
+            823,
+            419
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            448,
+            825,
+            518
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Performance on traditional benchmarks. To show the effectiveness of NeuroLKH on complicated routing problems with various distributions, we perform experiments on CVRPLIB [30] and Solomon [28] benchmark datasets. CVRPLIB [30] contains various sized CVRP instances with a combination of 3 depot positioning, 3 customer positioning and 7 demand distributions. Solomon benchmark [28] contains CVRPTW instances with 100 customers and various distributions of time windows. We detail the benchmarks, the training datasets and the results for each instance in the Appendix Section D. In summary, tested on the 43 instances with 100-300 nodes in CVRPLIB [30], NeuroLKH improves the average performances on 38, 38 and 31 instances when the time limits are set to the time of LKH with 100, 1000 and 10000 trials, respectively. On the 11 Solomon R2-type instances, NeuroLKH outperforms LKH almost consistently with all the settings (32 out of the 33). ",
+        "bbox": [
+            174,
+            523,
+            825,
+            662
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            684,
+            299,
+            702
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose an algorithm utilizing the great power of deep learning models to combine with a strong heuristic for TSP. Specifically, one Sparse Graph Network is trained to predict the edge scores and the node penalties for generating the edge candidate set and transforming the edge distances, respectively. As shown in the extensive experiments, the improvement of NeuroLKH over baseline algorithms within different time limits is consistent and significant. And NeuroLKH generalizes well to instances with much larger graph sizes than training sizes and traditional benchmarks with various node distributions. Also, we use CVRP, PDP and CVRPTW to demonstrate that NeuroLKH effectively applies to other routing problems. NeuroLKH can effectively learn the routing patterns for TSP which generalize well to much larger sizes and different distributions of nodes. However, for other complicated routing problems such as CVRP and CVRPTW, although NeuroLKH generalizes well to larger sizes, it is hard to directly generalize to other distributions of demands and time windows without training, which is a limitation of NeuroLKH and is left for future research. In addition, NeuroLKH can be further combined with other learning based techniques such as sparsifying the TSP graph [29] and other strong traditional algorithms such as the Hybrid Genetic Search [31]. ",
+        "bbox": [
+            174,
+            718,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by the A\\*STAR Cyber-Physical Production System (CPPS) – Towards Contextual and Intelligent Response Research Program, under the RIE2020 IAF-PP Grant A19C1a0018, and Model Factory $@$ SIMTech, in part by the National Natural Science Foundation of China under Grant 61803104 and Grant 62102228, and in part by the Young Scholar Future Plan of Shandong University under Grant 62420089964188. ",
+        "bbox": [
+            174,
+            119,
+            826,
+            189
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            210,
+            266,
+            226
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] I. Bello, H. Pham, Q. V. Le, M. Norouzi, and S. Bengio. Neural combinatorial optimization with reinforcement learning. In Proceedings of International Conference on Learning Representations (ICLR)., 2016. [2] Y. Bengio, A. Lodi, and A. Prouvost. Machine learning for combinatorial optimization: a methodological tour d’horizon. European Journal of Operational Research, 2020.   \n[3] X. Bresson and T. Laurent. Residual gated graph convnets. arXiv preprint arXiv:1711.07553, 2017.   \n[4] X. Chen and Y. Tian. Learning to perform local rewriting for combinatorial optimization. In Advances in Neural Information Processing Systems, pages 6278–6289, 2019.   \n[5] P. R. d. O. da Costa, J. Rhuggenaath, Y. Zhang, and A. Akcay. Learning 2-opt heuristics for the traveling salesman problem via deep reinforcement learning. In Asian Conference on Machine Learning, pages 465–480. PMLR, 2020. [6] H. Dai, E. Khalil, Y. Zhang, B. Dilkina, and L. Song. Learning combinatorial optimization algorithms over graphs. In Advances in Neural Information Processing Systems, pages 6348– 6358, 2017.   \n[7] J. K. Falkner and L. Schmidt-Thieme. Learning to solve vehicle routing problems with time windows through joint attention. arXiv preprint arXiv:2006.09100, 2020.   \n[8] Z.-H. Fu, K.-B. Qiu, and H. Zha. Generalize a small pre-trained model to arbitrarily large tsp instances. In Proceedings of the AAAI Conference on Artificial Intelligence, 2021.   \n[9] S. Y. Hao Lu, Xingwen Zhang. A learning-based iterative method for solving vehicle routing problems. In Proceedings of International Conference on Learning Representations (ICLR)., 2020.   \n[10] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770– 778, 2016.   \n[11] M. Held and R. M. Karp. The traveling-salesman problem and minimum spanning trees: Part ii. Mathematical programming, 1(1):6–25, 1971.   \n[12] K. Helsgaun. An effective implementation of the lin–kernighan traveling salesman heuristic. European Journal of Operational Research, 126(1):106–130, 2000.   \n[13] K. Helsgaun. General k-opt submoves for the lin–kernighan tsp heuristic. Mathematical Programming Computation, 1(2-3):119–163, 2009.   \n[14] K. Helsgaun. An extension of the lin-kernighan-helsgaun tsp solver for constrained traveling salesman and vehicle routing problems. Roskilde: Roskilde University, 2017.   \n[15] A. Hottung, B. Bhandari, and K. Tierney. Learning a latent search space for routing problems using variational autoencoders. In Proceedings of International Conference on Learning Representations (ICLR)., 2021.   \n[16] A. Hottung and K. Tierney. Neural large neighborhood search for the capacitated vehicle routing problem. In European Conference on Artificial Intelligence, 2020.   \n[17] S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pages 448–456, 2015.   \n[18] C. K. Joshi, T. Laurent, and X. Bresson. An efficient graph convolutional network technique for the travelling salesman problem. arXiv preprint arXiv:1906.01227, 2019.   \n[19] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. In Proceedings of International Conference on Learning Representations (ICLR)., 2014.   \n[20] W. Kool, H. van Hoof, J. Gromicho, and M. Welling. Deep policy dynamic programming for vehicle routing problems. arXiv preprint arXiv:2102.11756, 2021.   \n[21] W. Kool, H. van Hoof, and M. Welling. Attention, learn to solve routing problems! In Proceedings of International Conference on Learning Representations (ICLR)., 2019.   \n[22] Y.-D. Kwon, J. Choo, B. Kim, I. Yoon, Y. Gwon, and S. Min. Pomo: Policy optimization with multiple optima for reinforcement learning. In Advances in Neural Information Processing Systems, volume 33, 2020.   \n[23] J. Li, L. Xin, Z. Cao, A. Lim, W. Song, and J. Zhang. Heterogeneous attentions for solving pickup and delivery problem via deep reinforcement learning. IEEE Transactions on Intelligent Transportation Systems, 2021.   \n[24] S. Lin. Computer solutions of the traveling salesman problem. Bell System Technical Journal, 44(10):2245–2269, 1965.   \n[25] S. Lin and B. W. Kernighan. An effective heuristic algorithm for the traveling-salesman problem. Operations research, 21(2):498–516, 1973.   \n[26] M. Nazari, A. Oroojlooy, L. Snyder, and M. Takác. Reinforcement learning for solving the vehicle routing problem. In Advances in Neural Information Processing Systems, pages 9839– 9849, 2018.   \n[27] G. Reinelt. Tsplib—a traveling salesman problem library. ORSA journal on computing, 3(4):376–384, 1991.   \n[28] M. M. Solomon. Algorithms for the vehicle routing and scheduling problems with time window constraints. Operations research, 35(2):254–265, 1987.   \n[29] Y. Sun, A. Ernst, X. Li, and J. Weiner. Generalization of machine learning for problem reduction: a case study on travelling salesman problems. OR Spectrum, 43(3):607–633, 2021.   \n[30] E. Uchoa, D. Pecin, A. Pessoa, M. Poggi, T. Vidal, and A. Subramanian. New benchmark instances for the capacitated vehicle routing problem. European Journal of Operational Research, 257(3):845–858, 2017.   \n[31] T. Vidal, T. G. Crainic, M. Gendreau, N. Lahrichi, and W. Rei. A hybrid genetic algorithm for multidepot and periodic vehicle routing problems. Operations Research, 60(3):611–624, 2012.   \n[32] O. Vinyals, M. Fortunato, and N. Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, volume 28, 2015.   \n[33] Y. Wu, W. Song, Z. Cao, J. Zhang, and A. Lim. Learning improvement heuristics for solving routing problems. IEEE Transactions on Neural Networks and Learning Systems, 2021.   \n[34] L. Xin, W. Song, Z. Cao, and J. Zhang. Step-wise deep learning models for solving routing problems. IEEE Transactions on Industrial Informatics, 17(7):4861–4871, 2020.   \n[35] L. Xin, W. Song, Z. Cao, and J. Zhang. Multi-decoder attention model with embedding glimpse for solving vehicle routing problems. In Proceedings of the 35th AAAI Conference on Artificial Intelligence, pages 12042–12049, 2021.   \n[36] J. Zheng, K. He, J. Zhou, Y. Jin, and C.-m. Li. Combining reinforcement learning with linkernighan-helsgaun algorithm for the traveling salesman problem. In Proceedings of the AAAI Conference on Artificial Intelligence, 2021. ",
+        "bbox": [
+            176,
+            224,
+            828,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            54,
+            828,
+            915
+        ],
+        "page_idx": 11
+    }
+]

parse/train/XZDeL25T12l/XZDeL25T12l.md

@@ -0,0 +1,374 @@
+# CAN STUDENTS OUTPERFORM TEACHERS IN KNOWLEDGE DISTILLATION BASED MODEL COMPRESSION?
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Knowledge distillation (KD) is an effective technique to compress a large model (teacher) to a compact one (student) by knowledge transfer. The ideal case is that the teacher is compressed to the small student without any performance dropping. However, even for the state-of-the-art (SOTA) distillation approaches, there is still an obvious performance gap between the student and the teacher. The existing literature usually attributes this to model capacity differences between them. However, model capacity differences are unavoidable in model compression. In this work, we systematically study this question. By designing exploratory experiments, we find that model capacity differences are not necessarily the root reason, and the distillation data matters when the student capacity is greater than a threshold. In light of this, we propose to go beyond in-distribution distillation and accordingly develop $\mathrm { K D + }$ . $\mathrm { K D + }$ is superior to the original KD as it outperforms KD and the other SOTA approaches substantially and is more compatible with the existing approaches to further improve their performances significantly 1.
+
+# 1 INTRODUCTION
+
+Deep neural networks (DNNs) have achieved remarkable performances in various domains, but they require large amounts of computation and memory. This seriously limits their deployment with limited resources or a strict latency requirement. One solution to this problem is knowledge distillation which transfers the knowledge from a large network (teacher) to a small one (student).
+
+Hinton et al. (2015) proposed the original knowledge distillation 2 (KD) which uses softened logits of a teacher as supervision to train a student. To make the student better capture the knowledge from the teacher, the existing studies focus on aligning their representations by using different criteria. However, there is still a significant performance gap between the teacher and the student. Figuring out the reason for this gap is essential for further improving the student performance.
+
+Mirzadeh et al. (2020) argue that the model capacity difference causes the failure for transferring the knowledge from a large teacher to a small student, thus leading to a large performance gap. Similarly, Cho & Hariharan (2019) point out that as the teacher grows in capacity and accuracy, it is difficult for the student to emulate the teacher. In this paper, we systematically study why students underperform teachers and how students can match or outperform teachers. We find that in most experimental settings of the existing literature, the root reason for the performance gap is not necessarily the capacity differenc as the student is powerful enough to memorize the teacher’s outputs. The reason lies in the distillation dataset on which the knowledge is transferred.
+
+As an old proverb says, indigo comes from blue, but it is bluer than blue. In reality, it is not rare for human students to do better than their teachers. These excellent human students not only well capture the knowledge from their teachers but also learn more related knowledge on their own. This gives an insight for students in KD to match or outperform their teachers. We find that currently the students in KD have not well captured the knowledge in their teachers as they only mimic the behavior of the teachers on sparse training data points. In light of this, we propose $\mathrm { K D + }$ which goes beyond in-distribution distillation to substantially reduce the performance gap between students and teachers.
+
+Our main contributions are summarized as follows:
+
+• Different from the common belief that model capacity differences result in the performance gap between students and teachers, we find that capacity differences are not necessarily the root reason and instead the distillation data matters when students’ capacities are greater than a threshold. To our best knowledge, this is the first work that systematically explores why small students underperform teachers and how students can outperform large teachers. • By designing exploratory experiments, we find the following: (1) only fitting teachers’ outputs at sparse training data points cannot make students well capture the local, indistribution shapes of the teacher functions; (2) different from the case on standard supervised learning, out-of-distribution data (but not all) can be beneficial to knowledge distillation. Different from the existing work focusing on using different criteria to align representations or logits between teachers and students, we address knowledge distillation from a novel (data) perspective by going beyond in-distribution distillation and accordingly develop $\mathrm { K D + }$ . Extensive experiments demonstrate that $\mathrm { K D + }$ largely reduces the performance gap between students and teachers, and even enables students to match or outperform their teachers. $\mathrm { K D + }$ is superior to KD as it outperforms KD and more than 10 SOTA methods substantially and shows a better compatibility with the existing methods and superiority in few-shot scenario.
+
+# 2 RELATED WORK
+
+The objective function of knowledge distillation can be simply expressed as a combination of the regular cross-entropy objective and a distillation objective. According to the distillation objective, the existing literature can be divided into logit-based approaches (Hinton et al., 2015) and representationbased approaches (Romero et al., 2015). Logit-based approaches construct the distillation objective based on output logits. Hinton et al. (2015) propose KD which penalizes the softened logit differences between a teacher and a student. Park et al. (2019) propose to transfer data sample relations from a teacher to a student by aligning their logit-based structures. On the other hand, representation-based approaches design the distillation objective based on feature maps. FitNet (Romero et al., 2015) aligns the features of a teacher and a student through regressions. AT (Zagoruyko & Komodakis, 2017) distills feature attention from a teacher into a student. CRD (Tian et al., 2020) maximizes the mutual information between student and teacher representations. Other representation-based methods (Yim et al., 2017; Huang & Wang, 2017; Kim et al., 2018; Liu et al., 2019; Srinivas & Fleuret, 2018; Wang et al., 2018; Heo et al., 2019a; Cho & Hariharan, 2019; Ahn et al., 2019; Koratana et al., 2019; Aguilar et al., 2019; Shen & Savvides, 2020) use different criteria to align feature representations. SSKD (Xu et al., 2020) introduces extra self-supervision tasks to assist KD. Online knowledge distillation (Zhang et al., 2018b; Chen et al., 2020; Anil et al., 2018; Chung et al., 2020; Zhu et al., 2018) trains multiple students simultaneously. Self-distillation (Furlanello et al., 2018; Yuan et al., 2020) approaches train a DNN by using itself as the teacher. It is observed that the existing studies focus on designing different criteria to align teacher-student representations or logits on in-distribution data. In this work, we address knowledge distillation from a data perspective by embedding out-of-distribution distillation into a regularizer.
+
+Mirzadeh et al. (2020) observe that the model capacity gap results in the failure for transferring knowledge from a large teacher to a small student, thus causing a performance gap. To reduce this gap, they propose a multi-step knowledge distillation framework by using several intermediate-size networks (teacher assistants). However, the students still underperform the teachers substantially. Cho & Hariharan (2019) argue that as the teacher grows in capacity and accuracy, it is difficult for the student to emulate the teacher. To reduce the influence of the large capacity gap, they regularize both the teacher and the knowledge distillation by early stopping. We find that capacity differences are not necessarily the root reason when student capacities are greater than a threshold.
+
+On the other hand, $\mathrm { K D + }$ goes beyond in-distribution distillation by exploring the knowledge between two training samples. Similar techniques have been used in many applications with different goals and mechanisms. Mixup (Zhang et al., 2018a) enforces local linearity of a DNN by linearly interpolating a random pair of training samples and their one-hot labels simultaneously. However, simply interpolating two labels may not match the generated sample as pointed out in (Guo et al., 2019). $\mathrm { K D + }$ does not have the above issue as it teaches a student to mimic the local shape of a powerful teacher. MixMatch (Berthelot et al., 2019b) linearly interpolates labeled and unlabeled data to improve the semi-supervised learning performances. ReMixMatch (Berthelot et al., 2019a) improves MixMatch by introducing distribution alignment and augmentation anchoring. DivideMix (Li et al., 2020) aims to learn with noisy labels by modifying MixMatch with label co-refinement and label co-guessing on labeled and unlabeled samples, respectively. AugMix (Hendrycks et al., 2019) linearly interpolates original training samples and augmented training samples to improves the robustness and uncertainty estimates of DNNs.
+
+# 3 REFORMULATING KD
+
+Hinton et al. (2015) propose KD which minimizes the softened logit differences between a student and a teacher over training data $D _ { t } = \left( X _ { t } , Y _ { t } \right)$ where $X _ { t }$ and $Y _ { t }$ are the training samples and the ground truth, respectively. The complete objective is:
+
+$$
+\mathcal { L } _ { K D } = \sum _ { ( x _ { t } , y _ { t } ) \in ( X _ { t } , Y _ { t } ) } [ \alpha \mathcal { L } _ { C E } ( f _ { S } , x _ { t } , y _ { t } ) + \beta \mathcal { L } _ { K L } ( f _ { S } , f _ { T } , x _ { t } ) ]
+$$
+
+where $\alpha$ and $\beta$ are balancing weights and $\mathcal { L } _ { C E }$ is the regular cross-entropy objective:
+
+$$
+\mathcal { L } _ { C E } ( f _ { S } , x _ { t } , y _ { t } ) = H ( y _ { t } , \sigma ( f _ { S } ( x _ { t } ) ) )
+$$
+
+where $H ( . )$ is the cross-entropy and $\sigma$ is softmax. $\mathcal { L } _ { K L }$ in (1) is the distillation objective:
+
+$$
+\mathcal { L } _ { K L } \left( f _ { S } , f _ { T } , x _ { t } \right) = \tau ^ { 2 } K L \left( \sigma \left( \frac { f _ { T } \left( x _ { t } \right) } { \tau } \right) , \sigma \left( \frac { f _ { S } \left( x _ { t } \right) } { \tau } \right) \right)
+$$
+
+where $\tau$ is a temperature to generate soft labels and $K L$ represents KL-divergence. KD can be considered as using one function $( f _ { S } )$ to fit the outputs of another function $( f _ { T } )$ .
+
+We notice that in (1), $\mathcal { L } _ { C E }$ requires both data samples $X _ { t }$ and the corresponding ground truth $Y _ { t }$ while $\mathcal { L } _ { K L }$ only needs data samples $X _ { t }$ for distilling the teacher knowledge. In light of the difference, we consider KD from semi-supervised perspective and reformulate (1) in a more general form:
+
+$$
+\mathcal { L } = \sum _ { ( x _ { t } , y _ { t } ) \in ( X _ { t } , Y _ { t } ) } \alpha \mathcal { L } _ { C E } ( f _ { S } , x _ { t } , y _ { t } ) + \sum _ { x _ { d } \in ( X _ { d } ) } \beta \mathcal { L } _ { K L } ( f _ { S } , f _ { T } , x _ { d } )
+$$
+
+where we introduce a new concept: distillation dataset $X _ { d }$ is a set of samples on which the knowledge is transferred from a teacher to a student. The first term in the right hand side of (4) is supervised while the second term is unsupervised. It is obvious that the widely used objective (1) is a special case of (4) when $X _ { d }$ is set to $X _ { t }$ .
+
+# 4 WHY SMALL STUDENTS UNDERPERFORM LARGE TEACHERS?
+
+In this part, we systematically analyze the reason for the performance gap between students and teachers in KD based model compression. We first introduce several definitions.
+
+Definition 4.1 Memorization Error $( M E )$ : For a given task with data distribution $P ( X , Y )$ , ME measures the degree of a student $f _ { S }$ fitting the outputs of a teacher $f _ { T }$ over the data distribution:
+
+$$
+E ( f _ { S } , f _ { T } , P ) = \underset { x \sim P \left( X \right) } { \mathbb { E } } M ( f _ { T } \left( x \right) , f _ { S } \left( x \right) )
+$$
+
+where $M$ denotes a distance metric such as KL-divergence or mean square error. When ME is 0, it means that the student can completely memorize the outputs of the teacher over the data distribution. In this paper, we take KL-divergence as $M$ .
+
+Definition 4.2 Capable Students (CSTs) and Incapable Students (ISTs): network $f _ { S }$ with parameters $\Theta _ { S }$ is a CST of teacher $f _ { T }$ if there exists $\Theta _ { S }$ such that $E ( f _ { S } , f _ { T } , P ) = 0 ,$ , otherwise, it is an IST.
+
+Obviously, a CST is able to fully fit the teacher outputs over data distribution $P ( X , Y )$ . In contrast, an IST does not have the capacity to fit the teacher. For ISTs, the common belief holds that the student-teacher capacity gap causes the performance gap. For example, we cannot expect a two-layer neural network with 1000 parameters to fit the outputs of ResNet-101 with $1 . 7 \mathbf { M }$ parameters on
+
+Table 1: ME of different networks on CIFAR-10, CIFAR-100, and Tiny ImageNet   
+
+<table><tr><td>Teacher Student</td><td>WRN-40-2 WRN-16-2</td><td>VGG-13 VGG-8</td><td>ResNet32×4 ResNet8×4</td><td>ResNet-110 VGG-8</td><td>ResNet32×4 ShuffleNetV2</td><td>VGG-13 SN2</td><td>VGG-13 SN3</td></tr><tr><td>CIFAR-10</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>1.7</td><td>0.1</td></tr><tr><td>CIFAR-100</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>2.4</td><td>0.3</td></tr><tr><td>Tiny ImageNet</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>4.2</td><td>1.9</td></tr></table>
+
+Table 2: Simulation results on CIFAR-100 in terms of test accuracy $( \% )$   
+
+<table><tr><td>Teacher Student</td><td>ResNet32×4 ResNet8×4</td><td>WRN-40-2 WRN-16-2</td><td>VGG-13 VGG-8</td><td>ResNet32×4 ShuffleNetV2</td><td>VGG-13 SN2</td><td>VGG-13 SN3</td></tr><tr><td>Teacher</td><td>79.52</td><td>75.81</td><td>74.97</td><td>79.52</td><td>74.97</td><td>74.97</td></tr><tr><td>Vanilla Student</td><td>72.50</td><td>73.26</td><td>70.36</td><td>71.82</td><td>26.29</td><td>55.31</td></tr><tr><td>Student Type</td><td>CST</td><td>CST</td><td>CST</td><td>CST</td><td>IST</td><td>IST</td></tr><tr><td>KD</td><td>73.33</td><td>74.92</td><td>72.98</td><td>72.14</td><td>26.04</td><td>55.32</td></tr><tr><td>Simulation KD</td><td>79.91</td><td>78.46</td><td>77.99</td><td>81.64</td><td>25.58</td><td>57.50</td></tr></table>
+
+CIFAR-100. However, in the current SOTA approaches and applications, the commonly used students are modern neural network architectures, such as ResNet-20, ResNet- $\cdot 8 \times 4$ , VGG-8, and WRN-40-1. We empirically show that these models are CSTs on commonly used benchmark datasets.
+
+To check whether student $f _ { S }$ is a CST of teacher $f _ { T }$ on a task, we minimize ME to check whether $E ( f _ { S } , f _ { T } , P )$ can achieve 0. However, in practice, it is impossible to calculate $E ( f _ { S } , f _ { T } , P )$ as the data distribution $P$ is typically unknown. Fortunately, we have the access to a set of training data $( X _ { t } , Y _ { t } )$ . With the training data, we approximate ME $E ( f _ { S } , f _ { T } , P )$ with the empirical error:
+
+$$
+E _ { e m } ( f _ { S } , f _ { T } , X _ { t } ) = \frac { 1 } { \left| X _ { t } \right| } \sum _ { x _ { t } \in X _ { t } } M ( f _ { T } \left( x _ { t } \right) , f _ { S } \left( x _ { t } \right) )
+$$
+
+For comparison, we also evaluate two small neural networks which are expected to be ISTs, i.e., SN-2 and SN-3 with two and three layers, respectively. We report the ME in Table $1 ^ { 3 }$ , where we adopt the students and the teachers that share the same architectures (e.g., WRN-40-2 and WRN-16-2) or use different architectures (e.g., ResNet-110 and VGG-8). As expected, the widely used students achieve $\mathrm { M E } \left. . 0 \right.$ on these benckmark datasets, i.e., CIFAR-10, CIFAR-100, and Tiny ImageNet while the small networks (i.e., SN2 and SN3) have large ME (e.g., 2.4 and 4.2), which demonstrates that the widely used students are CSTs. However, as observed in the existing literature, these CSTs underperform the teachers by a significant margin on the test data. This suggests that these students have well captured the knowledge on sparse training data points but have not well captured the local shapes of the teachers within the data distribution.
+
+Corollary 4.1 In KD, for CSTs, only fitting the outputs of teachers on sparse training data points cannot enable them to well capture the local, in-distribution shapes of the teachers, thus leading to a performance gap. For ISTs, capacity differences cause the performance gap.
+
+Proof: We empirically show this by comparing the student performances in the following two settings: (a) setting the distillation dataset to training data points; (b) setting the distillation dataset to real data distribution $P ( X )$ . As $P ( X )$ is typically unknown in practice, we conduct a simulation experiment on CIFAR-100. We suppose that the union of the training dataset and the test dataset in CIFAR-100 can accurately represent the real data distribution for this task. Then we randomly draw data samples from the vicinity around the training data and the test data as the distillation dataset, i.e., $X _ { d }$ in (4). Consequently, the distillation dataset can sufficiently represent the real data sample distribution. Note that in the experiments, we never spy the ground truth of the test samples, since the distillation dataset does not use ground truth as shown in (4). This means that the students are trained without any additional supervision compared with the teachers as training datset $( X _ { t } , Y _ { t } )$ in (4) does not change. As CSTs are able to fully memorize the outputs of the teachers, we expect them to achieve the same accuracies as or higher accuracies than those of the teachers. In contrast, we expect ISTs to achieve lower accuracies than those of the teachers. Table 2 shows the simulation results. As expected, all the CSTs outperform the teachers in the simulation experiments (i.e., Simulation KD). This is due to the following facts: first, by using the simulated distillation dataset, the distillation objective in (4) makes the CSTs fully capture the knowledge of the teachers within the data distribution; second, the cross-entropy objective in (4) enables the CSTs to learn their own knowledge. Consequently, CSTs contain both the teacher knowledge and the knowledge learned on their own, which results in better performances than those of the teachers. SN2 and SN3 still underperform the teachers in the simulation experiments due to their limited capacities. These results empirically prove Corollary 4.1.
+
+![](images/8d55fc72e693feb489c0c4676b7c48e0c662e0427690b954c85ea2269594aa48.jpg)  
+Figure 1: KD with training data
+
+![](images/e482e5f4c1f585eb451f42aeb051fb135d10e415edb522f6cba4916465234c0b.jpg)  
+Figure 2: KD with augmentation
+
+![](images/3f596573293b8c6d55ec6e0bcf56af82d132e23e690fe50b5256e7ef7bcb65b3.jpg)  
+Figure 3: KD+
+
+The simulation experiments also suggest a way for CSTs to outperform teachers. That is to sufficiently distill the knowledge in the teachers with a well representative distillation dataset. Unfortunately, it is impossible to have such a distillation datset as the real data sample distribution $P ( X )$ is typically unknown in practice. Motivated by this, we propose to go beyond in-distribution distillation.
+
+# 5 GOING BEYOND IN-DISTRIBUTION DISTILLATION
+
+# 5.1 DIFFERENCES BETWEEN SUPERVISED LEARNING AND KNOWLEDGE DISTILLATION
+
+As analyzed above, the reason for the performance gap lies in distillation datasets. Distillation datasets are different from training datsets. As shown in (4), training datsets contain both samples and their ground truth, which are used for standard supervised learning. In contrast, distillation datsets only contain samples without ground truth, which are used for knowledge distillation. Knowledge distillation and standard supervised learning differ substantially. Standard supervised learning is to learn a function $f$ (e.g., a DNN) for mapping $x$ to $y$ where $( x , y )$ follows real data distribution $P ( X , Y )$ . The quality of $f$ is constrained by the training data $( X _ { t } , Y _ { t } )$ that we have. In contrast, knowledge distillation is to learn a function (i.e., a student $f _ { S } )$ for mapping $x$ to $z$ where $( x , z )$ follows a teacher-defined distribution $Q ( X , Z )$ and $\begin{array} { r } { Z = \sigma ( \frac { f _ { T } ( X ) } { \tau } ) } \end{array}$ . $Q ( X , Z )$ is different from $P ( X , Y )$ unless teacher $f _ { T }$ is perfect. The advantage of knowledge distillation is that $Q ( X , Z )$ is more tractable than $P ( X , Y )$ , since for given any sample $x$ , $f _ { T }$ can always give output $f _ { T } ( x )$ , and $\textstyle ( x , \sigma ( { \frac { f _ { T } ( x ) } { \tau } } ) )$ follows $Q ( X , Z )$ . Even for out-of-distribution samples, $f _ { T }$ can still output soft labels although these soft labels are semantically meaningless. However, the existing literature ignores this advantage as they only distill the knowledge on sparse training data points.
+
+# 5.2 IMPROVING KD BY FURTHER EXPLORING TEACHER-DEFINED DISTRIBUTION
+
+The simulation experiments demonstrate that only fitting sparse individual data points cannot necessarily enable students to well capture the local shapes of the teacher functions. As shown in Figure 1 where the yellow regions denote real data sample distribution $P ( X )$ , even if student $f _ { S }$ perfectly fits teacher $f _ { T }$ at each training data point, i.e., $x _ { 1 }$ , $x _ { 2 }$ , and $x _ { 3 }$ , their local shapes near these samples can still be highly different. To mitigate this issue, the typically used strategy is data augmentation Simard et al. (1998) formalized by the Vicinal Risk Minimization (VRM) Chapelle et al. (2001) principle. In VRM, human knowledge is necessary to define a vicinity or neighborhood around each training data point. Then, additional new data points can be drawn from the vicinity distribution of the training data. For example, in image classification, it is common to define the vicinity of an image as the set of its random crops after mildly padding and flipping. Nevertheless, data augmentation has its own limitation that a newly generated data point is very close to the original training data point, since they contain almost the identical objective only with different backgrounds caused by padding or cropping. Due to this limitation, as shown in Figure 2, even if the student $f _ { S }$ fits the teacher $f _ { T }$ at all the training data points (i.e., $x _ { 1 } , x _ { 2 }$ , and $x _ { 3 }$ ) and the augmented data points (i.e., $x _ { 1 } ^ { a u g } , x _ { 2 } ^ { a u g }$ , and $x _ { 3 } ^ { a u g }$ ), their local shapes can still differ substantially.
+
+Table 3: Ablation study on CIFAR-100 in terms of test accuracy $( \% )$   
+
+<table><tr><td></td><td colspan="4">Teacher:WRN-4O-2, Student: WRN-40-1</td><td colspan="4">Teacher:ResNet32×4,Student:ShuffleNetV2</td></tr><tr><td>KD</td><td colspan="4">73.54±0.20</td><td colspan="4">74.45±0.27</td></tr><tr><td></td><td>p=2</td><td>p=3</td><td>p=5</td><td>p=10</td><td>p=2</td><td>p=3</td><td>p=5</td><td>p=10</td></tr><tr><td>r=2:1</td><td>75.10±0.13</td><td>74.79±0.17</td><td>74.72±0.19</td><td>74.68±0.24</td><td>75.72±0.32</td><td>76.03±0.15</td><td>75.77±0.12</td><td>76.03±0.17</td></tr><tr><td>r=1:1</td><td>75.21±0.14</td><td>75.35±0.16</td><td>75.13±0.17</td><td>74.72±0.31</td><td>76.80±0.08</td><td>77.22±0.21</td><td>76.42±0.27</td><td>76.44±0.29</td></tr><tr><td>r=1:2</td><td>75.00±0.11</td><td>75.25±0.12</td><td>74.76±0.32</td><td>74.76±0.41</td><td>76.50±0.07</td><td>77.21±0.14</td><td>76.57±0.17</td><td>76.01±0.38</td></tr><tr><td>r=1:5</td><td>74.40±0.18</td><td>75.15±0.14</td><td>74.16±0.42</td><td>74.25±0.34</td><td>75.35±0.34</td><td>76.02±0.37</td><td>75.17±0.35</td><td>75.50±0.32</td></tr></table>
+
+To address the above issue, we propose $\mathrm { K D + }$ that regularizes KD by enforcing students to mimic the behavior of teachers on the region between two training (or augmented) samples. As shown in Figure 3, $\mathrm { K D + }$ first defines $p - 1$ points (i.e., $p _ { 1 } , p _ { 2 } , . . . , p _ { p - 1 } )$ that evenly divide the region between two training samples (i.e., $x _ { 1 }$ and $x _ { 2 }$ ) into $p$ pieces. We denote the set of $p _ { 1 }$ , $p _ { 2 }$ , ..., and $p _ { p - 1 }$ by P. P contains in-distribution points and out-of-distribution points. $\mathrm { K D + }$ enforces the students to mimic the behavior of the teachers on P, which serves as a data-driven regularizer. $\mathrm { K D + }$ goes beyond in-distribution distillation as it also uses out-of-distribution points in the regulaizer. As seen from Figure 3, the regularizer can make the student better explore and capture the local shape of the teacher. Consequently, the complete objective of $\mathrm { K D + }$ is written as:
+
+$$
+\mathcal { L } _ { K D + } = \mathcal { L } _ { K D } + \lambda \sum _ { p _ { i } \in P } \mathcal { L } _ { K L } ( f _ { S } , f _ { T } , p _ { i } )
+$$
+
+where $\lambda$ is a balancing weight and simply setting $\lambda$ to 1 works pretty well. $\mathrm { K D + }$ is a very concise approach without requiring complex hyperparameter tuning and can sufficiently explore the knowledge in the teacher by using freely obtained in-distribution and out-of-distribution points as a regularizer.
+
+# 6 EXPERIMENTS FOR EVALUATING $\mathrm { K D + }$
+
+In this section, We first conduct ablation study. Then we show that $\mathrm { K D + }$ is superior to KD by (1) comparing $\mathrm { K D + }$ with KD and other SOTA approaches, (2) showing that $\mathrm { K D + }$ is more compatible with these approaches, (3) showing the superiority of $\mathrm { K D + }$ under few-shot setting.
+
+6.1 DATASETS, ARCHITECTURES, COMPETITORS, AND HYPER-PARAMETERS
+
+Experiments are conducted on three benchmark datasets. CIFAR-100 (Krizhevsky & Hinton, 2009) has 100 classes with $5 0 \mathrm { k }$ training images and 10k test images. Tiny ImageNet 4 has 200 classes with 100k training images and $1 0 \mathrm { k }$ test images. ImageNet (Deng et al., 2009) has 1000 classes with 1.28M training images and 50k validation images. We use the standard data augmentation strategy for each dataset. We adopt various modern architectures, i.e., ResNet (He et al., 2016), WRN (Zagoruyko & Komodakis, 2016), VGG (Simonyan & Zisserman, 2015), MobileNet (Sandler et al., 2018), and ShuffleNet (Ma et al., 2018). We compare $\mathrm { K D + }$ with KD and several SOTA methods, i.e., FitNet (Romero et al., 2015), AT (Zagoruyko & Komodakis, 2017), SP (Tung & Mori, 2019), FT (Kim et al., 2018), NST (Huang & Wang, 2017), CC (Peng et al., 2019), FSP (Yim et al., 2017), PKT (Passalis & Tefas, 2018), AB (Heo et al., 2019b), VID (Ahn et al., 2019), RKD (Park et al., 2019), CRD (Tian et al., 2020), and SSKD (Xu et al., 2020). For these SOTA approaches, we report the author-reported results, or use author-provided codes and the optimal hyper-parameters if they are publicly available. Otherwise, we use the implementation of Tian et al. (2020).
+
+We follow KD and set $\alpha$ , $\beta$ , $\lambda$ and $\tau$ to 0.1, 0.9, 1, and 4, respectively, on all the datasets except on ImageNet where we follow the existing literature to set $\alpha = 1$ and $\tau = 3$ . We have trained all the networks for 240, 100, and 120 epochs with SGD with momentum 0.9 on CIFAR-100, Tiny ImageNet, and ImageNet, respectively. We set the initial learning rate to 0.05 for for ResNet, WRN, and VGG, and 0.01 for MobileNet and ShuffleNet. On CIFAR, the learning rate is divided by 10 every 30 epochs after the first 150 epochs. On Tiny ImageNet, the learning rate is divided by 5 every 30 epochs. On ImageNet, the learning rate is initilized to 0.1 and is divided by 10 every 30 epochs. More implementation details are reported in Appendix A.
+
+Table 4: Test accuracy on CIFAR-100. Underline denotes that students match or outperform teachers.   
+
+<table><tr><td>Teacher Student</td><td>VGG-13 VGG-8</td><td>ResNet32×4 ResNet8×4</td><td>WRN-40-2 WRN-40-1</td><td>ResNet-110 ResNet-32</td><td>WRN-40-2 VGG-8</td><td>ResNet32×4 ShuffleNetV2</td></tr><tr><td>Teacher Vanilla Student</td><td>74.64 70.36</td><td>79.42 72.50</td><td>75.61 71.98</td><td>74.31 71.14</td><td>75.61 70.36</td><td>79.42 71.86</td></tr><tr><td>KD</td><td>72.98±0.19</td><td>73.33±0.25</td><td>73.54±0.20</td><td>73.08±0.18</td><td>73.51±0.17</td><td>74.45±0.27</td></tr><tr><td>KD+</td><td>75.05±0.24</td><td>76.19±0.19</td><td>75.35±0.16</td><td>74.22±0.21</td><td>75.47±0.13</td><td>77.22±0.21</td></tr><tr><td>FitNet</td><td>71.02±0.31</td><td>73.50±0.28</td><td>72.24±0.24</td><td>71.06±0.13</td><td>71.14±0.17</td><td>73.54±0.22</td></tr><tr><td>AT</td><td>71.43±0.09</td><td>73.44±0.19</td><td>72.77±0.10</td><td>72.31±0.08</td><td>70.30±0.21</td><td>72.73±0.09</td></tr><tr><td>SP</td><td>72.68±0.19</td><td>72.94±0.23</td><td>72.43±0.27</td><td>72.69±0.41</td><td>73.12±0.18</td><td>74.56±0.22</td></tr><tr><td>CC</td><td>70.71±0.24</td><td>72.97±0.17</td><td>72.21±0.25</td><td>71.48±0.21</td><td>70.64±0.20</td><td>71.29±0.38</td></tr><tr><td>VID</td><td>71.23±0.06</td><td>73.09±0.21</td><td>73.30±0.13</td><td>72.61±0.28</td><td>71.86±0.23</td><td>73.40±0.17</td></tr><tr><td>RKD</td><td>71.48±0.05</td><td>71.90±0.11</td><td>72.22±0.20</td><td>71.82±0.34</td><td>71.00±0.19</td><td>73.21±0.28</td></tr><tr><td>PKT</td><td>72.88±0.09</td><td>73.64±0.18</td><td>73.45±0.19</td><td>72.61±0.17</td><td>72.74±0.42</td><td>74.69±0.34</td></tr><tr><td>AB</td><td>70.94±0.18</td><td>73.17±0.31</td><td>72.38±0.31</td><td>70.98±0.39</td><td>72.21±0.41</td><td>74.31±0.11</td></tr><tr><td>FT</td><td>70.58±0.08</td><td>72.86±0.12</td><td>71.59±0.15</td><td>72.37±0.31</td><td>68.33±0.22</td><td>72.50±0.15</td></tr><tr><td>CRD</td><td>73.94±0.22</td><td>75.51±0.18</td><td>74.14±0.22</td><td>73.48±0.13</td><td>74.08±0.20</td><td>75.65±0.10</td></tr><tr><td>NST</td><td>71.53±0.13</td><td>73.30±0.25</td><td>72.24±0.22</td><td>71.96±0.07</td><td>69.56±0.24</td><td>74.68±0.26</td></tr></table>
+
+Table 5: Test accuracies $( \% )$ on Tiny ImageNet.   
+
+<table><tr><td>Teacher</td><td>Student</td><td>KD</td><td>KD+</td><td>FitNet</td><td>AT</td><td>CC</td><td>SP</td><td>VID</td><td>RKD</td><td>CRD</td><td>PKT</td><td>AB</td></tr><tr><td>VGG-13 (61.62)</td><td>VGG-8 (55.46)</td><td>60.21 ±0.19</td><td>62.20 ±0.11</td><td>55.26 ±0.20</td><td>56.82 ±0.46</td><td>54.14 ±0.19</td><td>56.99 ±0.42</td><td>54.57 ±0.26</td><td>56.60 ±0.13</td><td>59.95 ±0.23</td><td>56.36 ±0.17</td><td>55.41 ±0.36</td></tr><tr><td>WRN-40-2 (61.84)</td><td>WRN-40-1 (55.39)</td><td>56.25 ±0.15</td><td>57.65 ±0.25</td><td>55.41 ±0.31</td><td>55.84 ±0.41</td><td>55.10 ±0.43</td><td>54.09 ±0.26</td><td>56.07 ±0.23</td><td>55.37 ±0.29</td><td>56.75 ±0.33</td><td>56.31 ±0.22</td><td>55.76 ±0.26</td></tr></table>
+
+Table 6: Comparison results on ImageNet   
+
+<table><tr><td></td><td>Teacher</td><td>Student</td><td>KD</td><td>KD+</td><td>AT</td><td>CRD</td><td>SP</td><td>CC</td></tr><tr><td>TOP-1</td><td>73.31</td><td>69.75</td><td>70.66</td><td>71.81</td><td>70.70</td><td>71.17</td><td>70.22</td><td>69.96</td></tr><tr><td>TOP-5</td><td>91.42</td><td>89.07</td><td>89.88</td><td>90.72</td><td>90.00</td><td>90.13</td><td>89.80</td><td>89.17</td></tr></table>
+
+6.2 ABLATION STUDY AND OUT-OF-DISTRIBUTION DISTILLATION
+
+We investigate how the performance varies with the values of $p$ . We also check how the performance varies with the number of points used in the regularizer of $\mathrm { K D + }$ as $\mathrm { \bf P }$ contains much more samples than the training dataset. We use $r$ to denote the ratio of the number of training samples to the number of samples used in the regularizer. Table 3 reports the results of $\mathrm { K D + }$ with different $p$ and $r$ . The value of $p$ determines what points are included in the regularzier of $\mathrm { K D + }$ . When $\scriptstyle p = 2$ , it means that we only use the middle points between two training (or augmented) samples in the regularizer. These middle points have a high probability of being out-of-distribution as they do not belong to any predefined classes. As seen from Table 3, by distilling on these middle points (i.e., $p { = } 2 \rangle$ ) as a regularizer, $\mathrm { K D + }$ outperforms KD significantly (e.g., from 73.54 to 75.21 on WRN-40-1), which demonstrates that the out-of-distribution samples can be beneficial to knowledge distillation. Note that not all out-of-distribution samples are useful(e.g., randomly generated samples from normal distribution are harmful as shown in Appendix D). The reason for the usefulness of these middle points may be that these points are not far from the real data distribution as they share some statistics with the training data (e.g., the mean, the variance, and the relation among data dimensions). We also notice that the performance of $\mathrm { K D + }$ is not sensitive to the values of $r$ and $p$ . The best performance is achieved when $r { = } 1 { : } 1$ and $\scriptstyle { p = 3 }$ . Thus, we simply set $r { = } 1 { : } 1$ and $\scriptstyle { p = 3 }$ in the rest of the experiments.
+
+# 6.3 COMPARISON WITH KD AND SOTA APPROACHES
+
+Table 4 summarizes the comparison results on CIFAR-100. We have the following observations. First, there is an obvious performance gap between the students and the teachers for the existing approaches (e.g., KD, FitNet, and AT). Second, with a simple regularizer, $\mathrm { K D + }$ substantially reduces the performance gap on all the six teacher-student pairs, and even matches or outperforms the teachers on four pairs (that are denoted by underline). On the other two teacher-student pairs, although the students still underperform the teachers, the performance gap is largely reduced by $\mathrm { K D + }$ . Note that there is no guarantee for $\mathrm { K D + }$ to make students match or outperform teachers as the regularizer in $\mathrm { K D + }$ cannot fully compensate for the unknown data sample distribution. Third, $\mathrm { K D + }$ consistently outperforms KD and the other SOTA approaches by a large margin across different architectures, which demonstrates the superiority of $\mathrm { K D + }$ . Fourth, on the pair of WRN-40-2 and VGG-8, almost all the representation-based approaches (e.g., FitNet and AT) fail to transfer knowledge from the teacher to the student, even underperform the vanilla student. The reason is that WRN-40-2 and VGG-8 have extremely different architectures. Aligning their feature maps hurts the student performance. In contrast, $\mathrm { K D + }$ shows its robustness and superiority in this case, and even enables student VGG-8 to match the performance of teacher WRN-40-2.
+
+Table 7: Compatibility performances on CIFAR-100   
+
+<table><tr><td>Teacher Student</td><td>ResNet32×4 ResNet8×4</td><td>VGG-13 VGG-8</td><td>ResNet-50 VGG-8</td><td>ResNet32×4 ShuffleNetV2</td><td>ResNet-110 ResNet-20</td><td>WRN-40-2 WRN-16-2</td></tr><tr><td>FitNet+KD</td><td>74.66±0.26 76.22±0.23</td><td>73.22±0.21 74.68±0.16</td><td>73.24±0.27 75.48±0.22</td><td>75.15±0.19 77.90±0.28</td><td>70.67±0.21 71.27±0.26</td><td>75.12±0.33 75.89±0.15</td></tr><tr><td>FitNet+KD+ AT+KD</td><td>74.53±0.18</td><td>73.48±0.19</td><td>74.01±0.25</td><td>75.39±0.29</td><td>70.97±0.17</td><td>75.32±0.15</td></tr><tr><td>AT+KD+</td><td>75.41±0.17</td><td>74.08±0.25</td><td>74.93±0.13</td><td>75.97±0.31</td><td>71.23±0.23</td><td>75.87±0.18</td></tr><tr><td>SP+KD SP+KD+</td><td>74.02±0.24 75.34±0.28</td><td>73.49±0.19 74.77±0.16</td><td>73.52±0.25 75.22±0.23</td><td>74.88±0.16 76.24±0.18</td><td>71.02±0.22 71.21±0.24</td><td>74.98±0.28 75.23±0.18</td></tr><tr><td>CC+KD</td><td>74.21±0.26</td><td>73.04±0.15</td><td>73.48±0.29</td><td>74.71±0.21</td><td>70.88±0.20</td><td>75.09±0.23</td></tr><tr><td>CC+KD+ VID+KD</td><td>76.28±0.23 74.56±0.10</td><td>74.45±0.22 73.19±0.20</td><td>75.33±0.27 73.46±0.25</td><td>77.35±0.19 74.85±0.28</td><td>71.32±0.27 71.10±0.18</td><td>75.88±0.26 75.14±0.15</td></tr><tr><td>VID+KD+</td><td>76.07±0.19</td><td>75.08±0.24</td><td>75.63±0.17</td><td>77.00±0.29</td><td>71.48±0.16</td><td>75.70±0.23</td></tr><tr><td>RKD+KD RKD+KD+</td><td>73.79±0.18</td><td>72.97±0.08</td><td>73.51±0.33</td><td>74.55±0.23</td><td>70.77±0.16</td><td>74.89±0.20</td></tr><tr><td></td><td>75.81±0.28</td><td>74.49±0.12</td><td>75.58±0.31</td><td>76.47±0.16</td><td>71.32±0.17</td><td>75.20±0.22</td></tr><tr><td>PKT+KD</td><td>74.23±0.13</td><td>73.25±0.21</td><td>73.61±0.28</td><td>74.66±0.30</td><td>70.72±0.24</td><td>75.33±0.18</td></tr><tr><td>PKT+KD+</td><td>76.12±0.22</td><td>74.80±0.19</td><td>75.70±0.15</td><td>76.63±0.12</td><td>71.36±0.20</td><td>75.65±0.29</td></tr><tr><td>CRD+KD</td><td>75.46±0.25</td><td>74.29±0.12</td><td></td><td></td><td></td><td></td></tr><tr><td>CRD+KD+</td><td></td><td></td><td>74.58±0.27</td><td>76.05±0.09</td><td>71.56±0.16</td><td>75.64±0.21</td></tr><tr><td></td><td>76.84±0.19</td><td>74.74±0.21</td><td>75.82±0.17</td><td>76.89±0.12</td><td>72.00±0.23</td><td>76.08±0.20</td></tr><tr><td>AB+KD</td><td>74.40±0.27</td><td>73.35±0.20</td><td>73.65±0.41</td><td>74.99±0.35</td><td>70.97±0.19</td><td>70.27±0.17</td></tr><tr><td>AB+KD+</td><td>75.95±0.33</td><td>74.92±0.21</td><td>76.11±0.18</td><td>77.85±0.16</td><td>71.75±0.27</td><td>71.35±0.29</td></tr><tr><td>NST+KD</td><td></td><td>73.33±0.15</td><td></td><td></td><td></td><td></td></tr><tr><td>NST+KD+</td><td>74.28±0.22</td><td></td><td>71.74±0.29</td><td>75.24±0.40</td><td>71.01±0.24</td><td>74.67±0.26</td></tr><tr><td></td><td>75.60±0.19</td><td>74.53±0.23</td><td>73.85±0.17</td><td>77.67±0.27</td><td>71.13±0.29</td><td>75.68±0.32</td></tr><tr><td>SSKD</td><td>76.20±0.36</td><td>75.33±0.27</td><td>75.76±0.40</td><td>78.61±0.33</td><td>71.38±0.26</td><td>76.04±0.21</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>SSKD+</td><td>76.59±0.11</td><td>75.60±0.21</td><td>76.01±0.25</td><td>78.75±0.18</td><td>71.54±0.20</td><td>76.34±0.27</td></tr></table>
+
+Table 5 reports the comparison results on Tiny ImageNet. $\mathrm { K D + }$ beats KD and the other approaches significantly, and even outperforms teacher VGG-13, which demonstrates the effectiveness of $\mathrm { K D + }$
+
+We further evaluate $\mathrm { K D + }$ on large scale dataset ImageNet. Limited by computation resources, we only adopt one teacher-student pair on ImageNet. We follow CRD and use ResNet-34 and ResNet-18 as the teacher and the student, respectively. As shown in Table 6, $\mathrm { K D + }$ improves the accuracy over KD and the other approaches significantly, which demonstrates the applicability and usefulness of $\mathrm { K D + }$ on large scale datasets. We also notice that there is still an obvious performance gap between the teacher and the student on ImageNet. The reason can be the model capacity difference as we find that ResNet-18 is an IST of ResNet-34 on the large and complex dataset ImageNet.
+
+# 6.4 COMPATIBILITY WITH SOTA APPROACHES
+
+The existing SOTA approaches can be combined with KD to obtain further performance gain. We show that these approaches combined with $\mathrm { K D + }$ are able to obtain more performance gain. As shown in Table 7, the existing approaches when combined with $\mathrm { K D + }$ consistently achieve much better performances than when combined with KD in all the settings where the teachers and the students use similar or different architectures. This demonstrates that $\mathrm { K D + }$ has a better compatibility than KD and the regularizer of going beyond in-distribution distillation also benefits the existing approaches.
+
+Table 8: Test accuracies on CIFAR-100 under few-shot scenario   
+
+<table><tr><td></td><td colspan="2">60% Training Data</td><td colspan="2">40% TrainingData</td><td colspan="2">20% Training Data</td><td colspan="2">10% Training Data</td></tr><tr><td>Teacher</td><td>ResNet32×4</td><td>VGG-13</td><td>ResNet32×4</td><td>VGG-13</td><td>ResNet32×4</td><td>VGG-13</td><td>ResNet32×4</td><td>VGG-13</td></tr><tr><td>Student</td><td>ResNet8×4</td><td>VGG-8</td><td>ResNet8×4</td><td>VGG-8</td><td>ResNet8×4</td><td>VGG-8</td><td>ResNet8×4</td><td>VGG-8</td></tr><tr><td>Teacher Vanilla Student</td><td>79.42</td><td>74.64</td><td>79.42</td><td>74.64</td><td>79.42</td><td>74.64</td><td>79.42</td><td>74.64</td></tr><tr><td></td><td>68.54</td><td>65.57</td><td>64.35</td><td>61.45</td><td>54.70</td><td>52.50</td><td>42.76</td><td>39.30</td></tr><tr><td>KD</td><td>69.12</td><td>69.90</td><td>66.44</td><td>66.89</td><td>58.23</td><td>59.14</td><td>47.95</td><td>49.00</td></tr><tr><td>KD+</td><td>73.65</td><td>72.10</td><td>70.75</td><td>70.53</td><td>65.68</td><td>64.94</td><td>57.00</td><td>56.50</td></tr><tr><td>FitNet</td><td>69.61</td><td>66.60</td><td>66.97</td><td>62.06</td><td>60.18</td><td>53.57</td><td>51.46</td><td>39.89</td></tr><tr><td>AT</td><td>69.35</td><td>67.36</td><td>66.19</td><td>65.12</td><td>57.72</td><td>58.16</td><td>44.70</td><td>47.16</td></tr><tr><td>SP</td><td>69.62</td><td>69.76</td><td>65.82</td><td>66.40</td><td>59.00</td><td>58.57</td><td>45.44</td><td>40.27</td></tr><tr><td>CC</td><td>68.37</td><td>65.37</td><td>64.26</td><td>60.60</td><td>54.68</td><td>51.27</td><td>42.74</td><td>39.16</td></tr><tr><td>VID</td><td>69.12</td><td>67.29</td><td>65.87</td><td>62.58</td><td>57.31</td><td>54.86</td><td>44.41</td><td>41.07</td></tr><tr><td>RKD</td><td>67.71</td><td>66.18</td><td>63.51</td><td>62.32</td><td>52.29</td><td>52.13</td><td>39.19</td><td>39.70</td></tr><tr><td>PKT</td><td>70.48</td><td>69.21</td><td>66.41</td><td>65.97</td><td>59.06</td><td>58.08</td><td>43.50</td><td>41.15</td></tr><tr><td>CRD</td><td>71.29</td><td>70.46</td><td>68.15</td><td>66.27</td><td>59.38</td><td>57.57</td><td>48.23</td><td>46.33</td></tr><tr><td>AB</td><td>69.25</td><td>65.98</td><td>65.30</td><td>63.07</td><td>58.48</td><td>56.55</td><td>48.61</td><td>48.27</td></tr><tr><td>FT</td><td>67.05</td><td>64.88</td><td>63.38</td><td>60.37</td><td>53.85</td><td>50.42</td><td>39.55</td><td>38.10</td></tr><tr><td>NST</td><td>69.87</td><td>67.12</td><td>66.24</td><td>63.56</td><td>60.27</td><td>56.63</td><td>51.91</td><td>47.44</td></tr></table>
+
+# 6.5 FEW-SHOT SCENARIO
+
+In reality, it can happen that a powerful model is released, but only a few data samples are publicly accessible due to the privacy or confidentiality issues. We evaluate $\mathrm { K D + }$ under few-shot scenario where knowledge is transferred from a powerful teacher to a student with limited data. Table 8 presents the comparison results. We observe that $\mathrm { K D + }$ outperforms KD and the other approaches by a large margin in all the cases with $60 \%$ , $40 \%$ , $20 \%$ , and $10 \%$ training data available. The superiority of $\mathrm { K D + }$ becomes more obvious under few-shot scenario, e.g., $9 . 0 5 \%$ accuracy improvement over KD on $\mathrm { R e s N e t } 8 { \times } 4$ with $10 \%$ training data. The reason is that under few-shot scenario, the training data becomes extremely sparse. Corollary 4.1 holds strongly that only fitting sparse data points cannot enable the students to well capture the local shapes of the teachers. $\mathrm { K D + }$ substantially mitigates this issue by using a regularizer to go beyond the sparse in-distribution distillation.
+
+# 7 CONCLUSION
+
+In this paper, we systematically study why students underperform teachers and how students can outperform teachers under KD based model compression. Through designing exploratory experiments, we find that model capacity differences are not necessarily the root reason and the distillation data matters when the student capacity is greater than a threshold. Inspired by this, we propose $\mathrm { K D + }$ which goes beyond in-distribution distillation. Extensive experiments demonstrate that $\mathrm { K D + }$ is superior to KD as it outperforms KD and the other SOTA approaches substantially, is more compatible with the existing approaches, and shows obvious superiority in few-shot scenario.
+
+# REFERENCES
+
+Gustavo Aguilar, Yuan Ling, Yu Zhang, Benjamin Yao, Xing Fan, and Edward Guo. Knowledge distillation from internal representations. arXiv preprint arXiv:1910.03723, 2019.
+
+Sungsoo Ahn, Shell Xu Hu, Andreas Damianou, Neil D Lawrence, and Zhenwen Dai. Variational information distillation for knowledge transfer. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9163–9171, 2019.
+
+Rohan Anil, Gabriel Pereyra, Alexandre Passos, Robert Ormandi, George E Dahl, and Geoffrey E Hinton. Large scale distributed neural network training through online distillation. arXiv preprint arXiv:1804.03235, 2018.
+
+Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein gan. ´ arXiv preprint arXiv:1701.07875, 2017.
+
+David Berthelot, Nicholas Carlini, Ekin D Cubuk, Alex Kurakin, Kihyuk Sohn, Han Zhang, and Colin Raffel. Remixmatch: Semi-supervised learning with distribution alignment and augmentation anchoring. arXiv preprint arXiv:1911.09785, 2019a.
+
+David Berthelot, Nicholas Carlini, Ian Goodfellow, Nicolas Papernot, Avital Oliver, and Colin A Raffel. Mixmatch: A holistic approach to semi-supervised learning. In Advances in Neural Information Processing Systems, pp. 5049–5059, 2019b.
+
+Olivier Chapelle, Jason Weston, Leon Bottou, and Vladimir Vapnik. Vicinal risk minimization. In ´ Advances in neural information processing systems, pp. 416–422, 2001.
+
+Defang Chen, Jian-Ping Mei, Can Wang, Yan Feng, and Chun Chen. Online knowledge distillation with diverse peers. In Thirty-Forth AAAI Conference on Artificial Intelligence, 2020.
+
+Jang Hyun Cho and Bharath Hariharan. On the efficacy of knowledge distillation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 4794–4802, 2019.
+
+Inseop Chung, SeongUk Park, Jangho Kim, and Nojun Kwak. Feature-map-level online adversarial knowledge distillation. In Proceedings of International Conference on Machine Learning, 2020.
+
+J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR09, 2009.
+
+Tommaso Furlanello, Zachary C Lipton, Michael Tschannen, Laurent Itti, and Anima Anandkumar. Born again neural networks. arXiv preprint arXiv:1805.04770, 2018.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.
+
+Hongyu Guo, Yongyi Mao, and Richong Zhang. Mixup as locally linear out-of-manifold regularization. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 3714–3722, 2019.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Dan Hendrycks, Norman Mu, Ekin D Cubuk, Barret Zoph, Justin Gilmer, and Balaji Lakshminarayanan. Augmix: A simple data processing method to improve robustness and uncertainty. arXiv preprint arXiv:1912.02781, 2019.
+
+Byeongho Heo, Jeesoo Kim, Sangdoo Yun, Hyojin Park, Nojun Kwak, and Jin Young Choi. A comprehensive overhaul of feature distillation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1921–1930, 2019a.
+
+Byeongho Heo, Minsik Lee, Sangdoo Yun, and Jin Young Choi. Knowledge transfer via distillation of activation boundaries formed by hidden neurons. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 3779–3787, 2019b.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Zehao Huang and Naiyan Wang. Like what you like: Knowledge distill via neuron selectivity transfer. arXiv preprint arXiv:1707.01219, 2017.
+
+Jangho Kim, SeongUk Park, and Nojun Kwak. Paraphrasing complex network: Network compression via factor transfer. In Advances in Neural Information Processing Systems, pp. 2760–2769, 2018.
+
+Animesh Koratana, Daniel Kang, Peter Bailis, and Matei Zaharia. Lit: Learned intermediate representation training for model compression. In International Conference on Machine Learning, pp. 3509–3518, 2019.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Junnan Li, Richard Socher, and Steven CH Hoi. Dividemix: Learning with noisy labels as semisupervised learning. arXiv preprint arXiv:2002.07394, 2020.
+
+Ruishan Liu, Nicolo Fusi, and Lester Mackey. Teacher-student compression with generative adversarial networks. arXiv preprint arXiv:1812.02271, 2018.
+
+Yufan Liu, Jiajiong Cao, Bing Li, Chunfeng Yuan, Weiming Hu, Yangxi Li, and Yunqiang Duan. Knowledge distillation via instance relationship graph. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 7096–7104, 2019.
+
+Ningning Ma, Xiangyu Zhang, Hai-Tao Zheng, and Jian Sun. Shufflenet v2: Practical guidelines for efficient cnn architecture design. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 116–131, 2018.
+
+Seyed-Iman Mirzadeh, Mehrdad Farajtabar, Ang Li, Nir Levine, Akihiro Matsukawa, and Hassan Ghasemzadeh. Improved knowledge distillation via teacher assistant. AAAI Conference on Artificial Intelligence, 2020.
+
+Wonpyo Park, Dongju Kim, Yan Lu, and Minsu Cho. Relational knowledge distillation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3967–3976, 2019.
+
+Nikolaos Passalis and Anastasios Tefas. Learning deep representations with probabilistic knowledge transfer. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 268–284, 2018.
+
+Baoyun Peng, Xiao Jin, Jiaheng Liu, Dongsheng Li, Yichao Wu, Yu Liu, Shunfeng Zhou, and Zhaoning Zhang. Correlation congruence for knowledge distillation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 5007–5016, 2019.
+
+Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. Fitnets: Hints for thin deep nets. In International Conference on Learning Representations, 2015.
+
+Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4510–4520, 2018.
+
+Zhiqiang Shen and Marios Savvides. Meal v2: Boosting vanilla resnet-50 to $80 \text{‰}$ top-1 accuracy on imagenet without tricks. arXiv preprint arXiv:2009.08453, 2020.
+
+Patrice Y Simard, Yann A LeCun, John S Denker, and Bernard Victorri. Transformation invariance in pattern recognition—tangent distance and tangent propagation. In Neural networks: tricks of the trade, pp. 239–274. Springer, 1998.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In International Conference on Learning Representations, 2015.
+
+Suraj Srinivas and Francois Fleuret. Knowledge transfer with Jacobian matching. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 4723–4731, Stockholmsmassan, ¨ Stockholm Sweden, 10–15 Jul 2018. PMLR.
+
+Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive representation distillation. In International Conference on Learning Representations, 2020.
+
+Frederick Tung and Greg Mori. Similarity-preserving knowledge distillation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1365–1374, 2019.
+
+Xiaojie Wang, Rui Zhang, Yu Sun, and Jianzhong Qi. Kdgan: Knowledge distillation with generative adversarial networks. In Advances in Neural Information Processing Systems, pp. 775–786, 2018.
+
+Guodong Xu, Ziwei Liu, Xiaoxiao Li, and Chen Change Loy. Knowledge distillation meets selfsupervision. In European Conference on Computer Vision, pp. 588–604. Springer, 2020.
+
+Junho Yim, Donggyu Joo, Jihoon Bae, and Junmo Kim. A gift from knowledge distillation: Fast optimization, network minimization and transfer learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4133–4141, 2017.
+
+Li Yuan, Francis EH Tay, Guilin Li, Tao Wang, and Jiashi Feng. Revisiting knowledge distillation via label smoothing regularization. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 3903–3911, 2020.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In BMVC, 2016.
+
+Sergey Zagoruyko and Nikos Komodakis. Paying more attention to attention: Improving the performance of convolutional neural networks via attention transfer. In International Conference on Learning Representations, 2017.
+
+Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. International Conference on Learning Representations, 2018a. URL https: //openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ r1Ddp1-Rb.
+
+Ying Zhang, Tao Xiang, Timothy M Hospedales, and Huchuan Lu. Deep mutual learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4320–4328, 2018b.
+
+Xiatian Zhu, Shaogang Gong, et al. Knowledge distillation by on-the-fly native ensemble. In Advances in neural information processing systems, pp. 7517–7527, 2018.
+
+# A MORE IMPLEMENTATION DETAILS
+
+The code for this work will be released online. Besides the hyper-parameters reported in the paper, below we report more implementation details.
+
+We adopt the standard preprocessing and data augmentation strategies for each dataset. Each image is preprocessed by subtracting the mean of the whole training set and dividing it by the standard deviation. We use the standard data augmentation strategy, i.e., randomly flipping horizontally, padding 4 pixels for CIFAR (8 pixels for Tiny ImageNet), and then cropping to $3 2 \times 3 2$ for CIFAR $6 4 \times 6 4$ for Tiny ImageNet). On ImageNet, we use the widely used scale and aspect ratio augmentation strategy.
+
+On exploratory experiments, the architectures of SN2 and SN3 are Conv(128)-BN-AvgPooling(32)- FC and Conv(128)-BN-ReLU-Covn(256)-BN-ReLU-AvgPooling(16)-FC, respectively.
+
+Following KD, we set $\alpha$ , $\beta , \lambda$ and $\tau$ to 0.1, 0.9, 1, and 4, respectively. On CIFAR-100, we have trained all the networks for 240 epochs with SGD with momentum 0.9 and batch size 64. On Tiny ImageNet, all the networks are trained with SGD with momentum 0.9 for 100 epochs with batch size 64. On ImageNet, we have the network for 120 epochs with SGD with momentum 0.9 and batch size 256.
+
+For the SOTA approaches, their objective is a combination of the regular cross-entropy loss and a distillation loss:
+
+$$
+\mathcal { L } = \mathcal { L } _ { C E } + c \mathcal { L } _ { d i s t i l l }
+$$
+
+where $c$ is a weight for balancing the two terms. We report the author-reported results, or use author-provided codes and the optimal hyper-parameters from the original papers if they are publicly available. Otherwise, we use the implementation of Tian et al. (2020). Specifically, the hyperparameters for each method are: (1) FitNet: $c = 1 0 0$ ; (2) AT: $c = 1 0 0 0$ ; (3) SP: $c = 3 0 0 0$ ; (4) CC: $c = 0 . 0 2$ ; (5) VID: $c = 1$ ; (6) RKD: $c _ { 1 } = 2 5$ for the distance metric and $c _ { 2 } = 5 0$ for the angle metric; both terms are combined following the original paper; (7) PKT: $c = 3 0 0 0 0$ ; (8) AB: $c = 0$ ; distillation happens in the pre-training stage where only distillation objective is used; (9) FT: $c = 5 0 0$ ; (10) CRD: $c = 0 . 8$ ; (11) FSP: $c = 0$ ; distillation happens in the pre-training stage where only distillation objective is used; (12) NST: $c = 5 0$ ; (13) the KD objective is (1); $\alpha , \beta$ and $\tau$ is set to 0.1, 0.9, and 4, respectively.
+
+For compatibility experiments, $\mathrm { K D + }$ is combined with the existing SOTA approaches. The objective is written as:
+
+$$
+\mathcal { L } _ { C o m p K D + } = \mathcal { L } _ { K D + } + c \mathcal { L } _ { d i s t i l l }
+$$
+
+The values of $c$ have been reported above.
+
+When the state-of-the-art approaches are combined with KD, the objective is:
+
+$$
+\mathcal { L } _ { C o m p K D } = \mathcal { L } _ { K D } + c \mathcal { L } _ { d i s t i l l }
+$$
+
+For all the experiments, we report the last epoch test accuracy over 3 runs.
+
+# B TEACHER-STUDENT SHAPE DIFFERENCES
+
+As stated in Corollary 4.1, only fitting the teacher outputs at sparse data points cannot enable students to well capture the local, in-distribution shapes of teachers. In this part, we show that the students trained with $\mathrm { K D + }$ can better capture the local shapes of the teachers than those trained with KD. The
+
+local shape of a function can be represented by a set of pairs $( x , y )$ where $x$ is the input and $y$ is the output of the function. To measure the shape difference, we report the average mean square student-teacher output logit differences (S-T DIFs) by using test data as inputs. As
+
+Table 9: S-T DIFs (Shape differences) on CIFAR-100   
+
+<table><tr><td>Teacher Student</td><td>ResNet32×4 ResNet8×4</td><td>WRN-40-2 WRN-16-2</td><td>WRN-40-2 WRN-40-1</td><td>VGG-13 VGG-8</td></tr><tr><td>KD</td><td>2.81</td><td>2.74</td><td>2.94</td><td>1.77</td></tr><tr><td>KD+</td><td>1.45</td><td>2.02</td><td>2.10</td><td>1.11</td></tr></table>
+
+shown in Table 9, S-T DIFs of $\mathrm { K D + }$ are consistently smaller than those of KD, which demonstrates that the student shapes of $\mathrm { K D + }$ are closer to the teacher shapes and indicates that the regularizer benefits the students in capturing the local shpaes of the teachers.
+
+# C COMPARISON WITH THE REGULARIZER OF INJECTING NOISE TO INPUTS
+
+$\mathrm { K D + }$ goes beyond in-distribution distillation by using a data-driven regularizer. We compare the regularizer in $\mathrm { K D + }$ with the regularizer of injecting small noise to inputs. Intuitively, distilling on noise-injected samples can also explore more knowledge in the teacher. We call this method NoiseKD. We compare $\mathrm { K D + }$ with NoiseKD. We grid search the best hyperparameter for NoiseKD by using different levels of Gaussian noise, i.e., $\mathcal { N } ( 0 , 0 . 1 )$ , $\mathcal { N } ( 0 , 0 . 0 5 )$ , $\mathcal { N } ( 0 , 0 . 0 1 )$ , and $\mathcal { N } ( 0 , 0 . 0 0 5 )$ . Table ?? reports the comparison results. It is observed that when the noise in NoiseKD is large (e.g., $\mathcal { N } ( 0 , 0 . 1 )$ and $\mathcal { N } ( 0 , 0 . 0 5 ) ,$ , NoiseKD even underperforms KD, which indicates that large noise is harmful for knowledge distillation. When noise is relatively small (e.g., $\mathcal { N } ( 0 , 0 . 0 1 ) )$ , NoiseKD slightly improves the performances over KD, which indicates that small noise is useful for knowledge distillation. We also see that $\mathrm { K D + }$ consistently outperforms NoiseKD with different levels of noise as regularzers, which demonstrates the superiority of the proposed regularizer.
+
+# D NOT ALL OUT-OF-DISTRIBUTION SAMPLES ARE USEFUL
+
+In $\mathrm { K D + }$ , when $p = 2$ , the regularizer almost only uses out-of-distribution samples as the middle points of two samples do not belong to any predefined class. The experimental results in Table 3 have shown that by distillation on these out-of-distribution samples as a regularizer, the student performance is improved substantially. Here, we show that not all out-of-distribution samples are useful for knowledge distillation. We randomly draw image-size noise from a normal distribution. And then we distill on these randomly generated noisy samples as a regularizer for KD (we denote this method by NoiseRegKD). The results are reported in Table 10. It is not surprising that the performances drop significantly, e.g., from 72.98 to 6.59 on VGG-8. This indicates that the out-of-distribution samples far from the real data distribution are harmful for knowledge distillation.
+
+# E LEARNING DATA DISTRIBUTION WITH GENERATIVE MODELS
+
+As stated in Corollary 4.1, only fitting the teacher outputs at sparse data points cannot enable students to well capture the local, in-distribution shapes of teachers. One natural idea is to use generative adversarial networks (GAN) Goodfellow et al. (2014); Arjovsky et al. (2017); Liu et al. (2018) to learn the data distribution and then use the generator to generate fake data for knowledge distillation. However, there are two issues: first, training GAN is computationally expensive especially for large datasets (e.g., ImageNet) while $\mathrm { K D + }$ can use freely obtained in-distribution and out-of-distribution points; second, the diversity and quality of the generated fake data from GAN are highly limited by sparse training data, which means that it cannot accurately learn the real data sample distribution, just like we cannot obtain $100 \%$ test accuracy by training a deep neural network on the training data samples and their ground truth of CIFAR-100.
+
+Table 10: Out-of-distribution distillation as regularizes on CIFAR-100   
+
+<table><tr><td>Teacher Student</td><td>VGG-13 VGG-8</td><td>WRN-40-2 WRN-16-2</td><td>ResNet32×4 ShuffleNetV2</td><td>ResNet32×4 ResNet8×4</td></tr><tr><td>Teacher</td><td>74.64</td><td>75.61</td><td>75.61</td><td>79.42</td></tr><tr><td>Vanilla Student</td><td>70.36</td><td>73.26</td><td>71.98</td><td>72.50</td></tr><tr><td>KD</td><td>72.98</td><td>74.92</td><td>73.54</td><td>73.33</td></tr><tr><td>NoiseRegKD</td><td>6.59</td><td>6.32</td><td>16.35</td><td>3.26</td></tr></table>
+
+Table 11: KD with GAN as a regularize on CIFAR-10   
+
+<table><tr><td>Teacher Student</td><td>WRN-40-2 WRN-16-1</td><td>VGG-13 MobileNetV2</td></tr><tr><td>Teacher</td><td>94.80</td><td>93.65</td></tr><tr><td>Vanilla Student</td><td>91.32</td><td>89.19</td></tr><tr><td>KD</td><td>91.77</td><td>89.21</td></tr><tr><td>KD-GAN</td><td>92.23</td><td>89.25</td></tr><tr><td>KD+</td><td>93.15</td><td>90.51</td></tr></table>
+
+Table 12: Compatibility performances on CIFAR-100 under few-shot scenario   
+
+<table><tr><td colspan="2">60% Training Data</td><td colspan="2">40% Training I Data</td><td>10% Training I</td><td>Data</td></tr><tr><td>Teacher Student</td><td>ResNet32×4 ResNet8×4</td><td>VGG-13 ResNet32×4 VGG-8 ResNet8×4</td><td>VGG-13 VGG-8</td><td>ResNet32×4 ResNet8×4</td><td>VGG-13 VGG-8</td></tr><tr><td>Teacher Vanilla Student</td><td>79.42 68.54</td><td>74.64 65.57</td><td>79.42 74.64 64.35 61.45</td><td>79.42 42.76</td><td>74.64 39.30</td></tr><tr><td>FitNet+KD FitNet+KD+</td><td>72.09 74.57</td><td>69.21 69.64 72.23 72.34</td><td>65.94 69.94</td><td>54.72 62.43</td><td>46.30 56.43</td></tr><tr><td>AT+KD AT+KD+</td><td>71.54 73.15</td><td>70.61 68.01 71.88 70.47</td><td>68.22 69.58</td><td>50.22 56.20</td><td>53.91 57.08</td></tr><tr><td>SP+KD SP+KD+</td><td>70.45 72.42</td><td>69.70 67.22 72.03 70.42</td><td>66.73 70.28</td><td>49.94 55.82</td><td>45.62 54.42</td></tr><tr><td>CC+KD CC+KD+</td><td>70.67 73.71</td><td>69.38 66.81 72.70 70.72</td><td>66.27 70.53</td><td>48.54 57.00</td><td>48.37 57.32</td></tr><tr><td>VID+KD VID+KD+</td><td>70.00 73.86</td><td>69.54 67.65 72.59</td><td>66.42</td><td>47.84</td><td>46.81</td></tr><tr><td>RKD+KD RKD+KD+</td><td>70.33 72.85 72.49</td><td>71.25 69.74 66.63</td><td>70.76 66.15 70.47 69.79</td><td>57.38 46.43</td><td>56.98 48.20</td></tr></table>
+
+Table 13: Training time of KD and $\mathrm { K D + }$   
+
+<table><tr><td>Teacher Student</td><td>VGG-13 VGG-8</td><td>ResNet32×4 ResNet8×4</td><td>WRN-40-2 WRN-40-1</td></tr><tr><td>KD</td><td>7.32s/epoch</td><td>17.21s/epoch</td><td>15.62s/epoch</td></tr><tr><td>KD+</td><td>13.32s/epoch</td><td>32.18s/epoch</td><td>28.40s/epoch</td></tr></table>
+
+Table 14: Comparison between baselines and baselines+   
+
+<table><tr><td>Teacher Student</td><td>VGG-13 VGG-8</td><td>WRN-40-2 WRN-16-2</td></tr><tr><td>FitNet</td><td>71.02</td><td>72.24</td></tr><tr><td>FitNet+</td><td>74.15</td><td>75.09</td></tr><tr><td>AT</td><td>71.43 73.55</td><td>72.77 74.81</td></tr><tr><td>AT+</td><td></td><td></td></tr><tr><td>SP SP+</td><td>72.68 73.81</td><td>72.43 74.59</td></tr><tr><td></td><td></td><td></td></tr><tr><td>CC</td><td>70.71</td><td>72.21</td></tr><tr><td>CC+</td><td>74.21</td><td>74.99</td></tr><tr><td>PKT</td><td>72.88</td><td>73.45</td></tr><tr><td>PKT+</td><td>74.39</td><td>75.01</td></tr></table>
+
+We conduct an exploratory experiment by using GAN to learn the data sample distribution on CIFAR10 Krizhevsky & Hinton (2009) as GAN can easily converge on CIFAR-10. And then we distill on the generated fake data as a regularizer for KD. The Results are reported in Table 11. It is obsrved that the GAN regularizer (i.e., KD-GAN) improves the performances over KD, but it underperforms $\mathrm { K D + }$ substantially. This indicates that GAN can generate some useful fake samples for knowledge distillation, but the diversity and usefulness of these samples are highly constrained by the training data. As it is almost impossible to learn the real data sample distribution from sparse training data points, $\mathrm { K D + }$ compensates this by going beyond in-distribution distillation and thus beats KD and the other approaches by a large margin.
+
+# F COMPATIBILITY WITH SOTA APPROACHES UNDER FEW-SHOT SCENARIO
+
+In this part, we report the compatibility of $\mathrm { K D + }$ with the existing approaches under few-shot scenario as this case can happen in reality where only a few samples are available due to the privacy or confidentiality issues. The comparison results are reported in Table 12. It is observed that the existing approaches when combined with $\mathrm { K D + }$ obtain much better performances than when combined with KD. Moreover, the overall accuracy improvement becomes larger when less training data samples are available. The reason is that when the training data become extremely sparse, Corollary 4.1 holds strongly that only fitting sparse data points cannot enable the students to well capture the local shapes of the teachers. $\mathrm { K D + }$ substantially mitigates this issue by using a regularizer to go beyond the sparse in-distribution distillation.
+
+# G TRAINING TIME OF KD AND $\mathrm { K D + }$
+
+As $\mathrm { K D + }$ explores more knowledge in the teacher by going beyond in-distribution distillation, it is more computationally expensive than KD. We report the training data on CIFAR-100 with GPU RTX 2080Ti. Both KD and $\mathrm { K D + }$ are trained for 240 epochs. The training time is reported in Table 13.
+
+# H COMPARISON RESULTS BETWEEN BASELINES AND BASELINES+
+
+To further explore the performances of the proposed approaches on different distillation methods, we compare baselines with baselines+. Baselines $^ +$ are obtained by using the P points to assist the baselines (note that the $\mathrm { K D + }$ objective is not included). The comparison results are reported in Table 14. We observe that the beselines+ consistently outperform the baselines by a large margin (e.g., $3 . 1 3 \%$ accuracy improvement from FitNet to FitNet+), which demonstrates the generalization and effectiveness of the proposed strategy across different distillation approaches.